@vellumai/assistant 0.4.54 → 0.4.56

package/src/__tests__/memory-regressions.test.ts

@@ -1,4 +1,4 @@
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
@@ -13,6 +13,8 @@ import {
 
 const testDir = mkdtempSync(join(tmpdir(), "memory-regressions-"));
 
+const testWorkspaceDir = join(testDir, ".vellum", "workspace");
+
 mock.module("../util/platform.js", () => ({
   getDataDir: () => testDir,
   isMacOS: () => process.platform === "darwin",
@@ -22,6 +24,8 @@ mock.module("../util/platform.js", () => ({
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),
   ensureDataDir: () => {},
+  getWorkspaceDir: () => testWorkspaceDir,
+  getWorkspacePromptPath: (file: string) => join(testWorkspaceDir, file),
 }));
 
 mock.module("../util/logger.js", () => ({
@@ -128,6 +132,7 @@ import {
   memorySummaries,
   messages,
 } from "../memory/schema.js";
+import { buildCoreIdentityContext } from "../prompts/system-prompt.js";
 
 describe("Memory regressions", () => {
   beforeAll(() => {
@@ -661,7 +666,7 @@ describe("Memory regressions", () => {
     expect(updated!.verificationState).toBe("user_confirmed");
   });
 
-  test("private thread cannot update default-scope item by ID", async () => {
+  test("private conversation cannot update default-scope item by ID", async () => {
     const db = getDb();
     const now = Date.now();
     const { handleMemoryUpdate } = await import("../tools/memory/handlers.js");
@@ -704,7 +709,7 @@ describe("Memory regressions", () => {
     expect(item!.statement).toBe("Original default-scope statement");
   });
 
-  test("standard thread cannot update private-scope item by ID", async () => {
+  test("standard conversation cannot update private-scope item by ID", async () => {
     const db = getDb();
     const now = Date.now();
     const { handleMemoryUpdate } = await import("../tools/memory/handlers.js");
@@ -1935,7 +1940,7 @@ describe("Memory regressions", () => {
       VALUES ('seg-ovr-default', 'msg-override-fallback', '${convId}', 'user', 0, 'Global memory about microservices architecture patterns', 10, 'default', ${now}, ${now})
     `);
 
-    // Insert segment in private thread scope
+    // Insert segment in private conversation scope
     db.run(`
       INSERT INTO memory_segments (id, message_id, conversation_id, role, segment_index, text, token_estimate, scope_id, created_at, updated_at)
       VALUES ('seg-ovr-private', 'msg-override-fallback', '${convId}', 'user', 1, 'Private thread memory about microservices architecture patterns', 10, 'private-thread-42', ${now}, ${now})
@@ -2191,15 +2196,15 @@ describe("Memory regressions", () => {
   // PR-17: addMessage() passes conversation scope to the indexer
   test("addMessage inherits private conversation scope on memory segments", async () => {
     const conv = createConversation({
-      title: "Private thread",
-      threadType: "private",
+      title: "Private conversation",
+      conversationType: "private",
     });
     expect(conv.memoryScopeId).toMatch(/^private:/);
 
     const msg = await addMessage(
       conv.id,
       "user",
-      "My secret project details for the private thread.",
+      "My secret project details for the private conversation.",
     );
 
     const db = getDb();
@@ -2217,8 +2222,8 @@ describe("Memory regressions", () => {
 
   test("addMessage uses default scope for standard conversations", async () => {
     const conv = createConversation({
-      title: "Standard thread",
-      threadType: "standard",
+      title: "Standard conversation",
+      conversationType: "standard",
     });
     expect(conv.memoryScopeId).toBe("default");
 
@@ -2245,7 +2250,7 @@ describe("Memory regressions", () => {
   test("extract_items job payload includes scopeId from private conversation", async () => {
     const conv = createConversation({
       title: "Private scope job test",
-      threadType: "private",
+      conversationType: "private",
     });
     expect(conv.memoryScopeId).toMatch(/^private:/);
 
@@ -2271,7 +2276,7 @@ describe("Memory regressions", () => {
   test("extract_items job payload defaults scopeId to default for standard conversations", async () => {
     const conv = createConversation({
       title: "Standard scope job test",
-      threadType: "standard",
+      conversationType: "standard",
     });
     expect(conv.memoryScopeId).toBe("default");
 
@@ -2305,7 +2310,7 @@ describe("Memory regressions", () => {
         title: null,
         createdAt: now,
         updatedAt: now,
-        threadType: "standard",
+        conversationType: "standard",
         memoryScopeId: "default",
       })
       .run();
@@ -2362,7 +2367,7 @@ describe("Memory regressions", () => {
         title: null,
         createdAt: now,
         updatedAt: now,
-        threadType: "standard",
+        conversationType: "standard",
         memoryScopeId: "default",
       })
       .run();
@@ -2454,7 +2459,7 @@ describe("Memory regressions", () => {
         title: null,
         createdAt: now,
         updatedAt: now,
-        threadType: "standard",
+        conversationType: "standard",
         memoryScopeId: "default",
       })
       .run();
@@ -2518,7 +2523,7 @@ describe("Memory regressions", () => {
         title: null,
         createdAt: now,
         updatedAt: now,
-        threadType: "standard",
+        conversationType: "standard",
         memoryScopeId: "default",
       })
       .run();
@@ -2592,7 +2597,7 @@ describe("Memory regressions", () => {
 
   test("private conversation summary inherits private scope_id", async () => {
     const db = getDb();
-    const conv = createConversation({ threadType: "private" });
+    const conv = createConversation({ conversationType: "private" });
     const scopeId = getConversationMemoryScopeId(conv.id);
     expect(scopeId).toMatch(/^private:/);
 
@@ -2655,7 +2660,7 @@ describe("Memory regressions", () => {
     const now = Date.now();
 
     // Create a private conversation and build its summary
-    const privConv = createConversation({ threadType: "private" });
+    const privConv = createConversation({ conversationType: "private" });
     const privScope = getConversationMemoryScopeId(privConv.id);
 
     db.insert(messages)
@@ -2758,13 +2763,13 @@ describe("Memory regressions", () => {
 
   // ── End-to-end memory-boundary regression tests ─────────────────────
 
-  test("e2e: private-only facts are recalled in private thread but not in standard thread", async () => {
+  test("e2e: private-only facts are recalled in private conversation but not in standard conversation", async () => {
     const db = getDb();
 
     // 1. Create a private conversation and add a message with a distinctive fact
     const privConv = createConversation({
       title: "Private e2e test",
-      threadType: "private",
+      conversationType: "private",
     });
     const privScope = getConversationMemoryScopeId(privConv.id);
     expect(privScope).toMatch(/^private:/);
@@ -2796,10 +2801,10 @@ describe("Memory regressions", () => {
     // Collect the item IDs so we can check them in recall results
     const privateItemKeys = privateItems.map((i) => `item:${i.id}`);
 
-    // 3. Create a standard conversation for the "standard thread" perspective
+    // 3. Create a standard conversation for the "standard conversation" perspective
     const stdConv = createConversation({
       title: "Standard e2e test",
-      threadType: "standard",
+      conversationType: "standard",
     });
     const stdScope = getConversationMemoryScopeId(stdConv.id);
     expect(stdScope).toBe("default");
@@ -2824,7 +2829,7 @@ describe("Memory regressions", () => {
       },
     };
 
-    // 4. Private thread recall — should find the Zephyr fact
+    // 4. Private conversation recall — should find the Zephyr fact
     const privRecall = await buildMemoryRecall(
       "Zephyr framework microservices",
       privConv.id,
@@ -2840,8 +2845,8 @@ describe("Memory regressions", () => {
     // Verify the pipeline ran and recency search found segments.
     expect(privRecall.recencyHits).toBeGreaterThan(0);
 
-    // 5. Standard thread recall — must NOT find the Zephyr fact (no leak)
-    // Mirror the production call in session-memory.ts: for standard threads
+    // 5. Standard conversation recall — must NOT find the Zephyr fact (no leak)
+    // Mirror the production call in conversation-memory.ts: for standard conversations
     // (scopeId === 'default'), scopePolicyOverride is undefined.
     const stdRecall = await buildMemoryRecall(
       "Zephyr framework microservices",
@@ -2860,14 +2865,14 @@ describe("Memory regressions", () => {
     expect(stdRecall.injectedText.toLowerCase()).not.toContain("zephyr");
   });
 
-  test("e2e: private thread still recalls facts from default memory scope", async () => {
+  test("e2e: private conversation still recalls facts from default memory scope", async () => {
     const db = getDb();
     const now = Date.now();
 
     // 1. Create a standard conversation and add a fact to default scope
     const stdConv = createConversation({
       title: "Default scope source",
-      threadType: "standard",
+      conversationType: "standard",
     });
     const stdScope = getConversationMemoryScopeId(stdConv.id);
     expect(stdScope).toBe("default");
@@ -2903,7 +2908,7 @@ describe("Memory regressions", () => {
     // 2. Create a private conversation
     const privConv = createConversation({
       title: "Private fallback test",
-      threadType: "private",
+      conversationType: "private",
     });
     const privScope = getConversationMemoryScopeId(privConv.id);
     expect(privScope).toMatch(/^private:/);
@@ -2928,7 +2933,7 @@ describe("Memory regressions", () => {
       },
     };
 
-    // 3. Private thread recall with fallback to default — should find the Obsidian fact
+    // 3. Private conversation recall with fallback to default — should find the Obsidian fact
     const privRecall = await buildMemoryRecall(
       "Obsidian editor note-taking",
       privConv.id,
@@ -2953,7 +2958,7 @@ describe("Memory regressions", () => {
     // Create a private conversation with a message
     const conv = createConversation({
       title: "Backfill scope test",
-      threadType: "private",
+      conversationType: "private",
     });
     expect(conv.memoryScopeId).toMatch(/^private:/);
 
@@ -2965,7 +2970,7 @@ describe("Memory regressions", () => {
         conversationId: conv.id,
         role: "user",
         content:
-          "My confidential backfill test content for private thread preservation.",
+          "My confidential backfill test content for private conversation preservation.",
         createdAt: conv.createdAt + 1,
       })
       .run();
@@ -3392,4 +3397,36 @@ describe("Memory regressions", () => {
     const expectedJobs = result.indexedSegments + 1; // embed per segment + summary
     expect(result.enqueuedJobs).toBe(expectedJobs);
   });
+
+  test("buildCoreIdentityContext includes identity files when they exist", () => {
+    // Create workspace directory and write prompt files
+    mkdirSync(testWorkspaceDir, { recursive: true });
+    writeFileSync(
+      join(testWorkspaceDir, "SOUL.md"),
+      "You are a helpful assistant named Jarvis.",
+    );
+    writeFileSync(
+      join(testWorkspaceDir, "USER.md"),
+      "The user's name is Aaron Levin.",
+    );
+
+    const context = buildCoreIdentityContext();
+    expect(context).not.toBeNull();
+    expect(context).toContain("helpful assistant named Jarvis");
+    expect(context).toContain("Aaron Levin");
+  });
+
+  test("buildCoreIdentityContext returns null when no prompt files exist", () => {
+    // Remove workspace prompt files to simulate a clean state
+    try {
+      rmSync(join(testWorkspaceDir, "SOUL.md"), { force: true });
+      rmSync(join(testWorkspaceDir, "IDENTITY.md"), { force: true });
+      rmSync(join(testWorkspaceDir, "USER.md"), { force: true });
+    } catch {
+      // files may not exist
+    }
+
+    const context = buildCoreIdentityContext();
+    expect(context).toBeNull();
+  });
 });

package/src/__tests__/messaging-send-tool.test.ts

@@ -57,7 +57,6 @@ describe("messaging-send tool", () => {
       },
       {
         workingDir: "/tmp",
-        sessionId: "sess-1",
         conversationId: "conv-1",
         assistantId: "ast-alpha",
         trustClass: "guardian" as const,
@@ -88,7 +87,6 @@ describe("messaging-send tool", () => {
       },
       {
         workingDir: "/tmp",
-        sessionId: "sess-1",
         conversationId: "conv-1",
         assistantId: "ast-alpha",
         trustClass: "guardian" as const,

package/src/__tests__/no-domain-routing-in-prompt-guard.test.ts

@@ -0,0 +1,51 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+/**
+ * Guard test: domain-specific routing sections must NOT appear in the system
+ * prompt source file. Routing cues now live in skill frontmatter
+ * (`activation-hints` / `avoid-when`) and are projected into `<available_skills>` XML.
+ *
+ * If this test fails, you are re-introducing hardcoded routing into the system
+ * prompt. Instead, add `activation-hints` to the skill's SKILL.md frontmatter.
+ */
+
+const SYSTEM_PROMPT_PATH = join(
+  import.meta.dirname,
+  "../prompts/system-prompt.ts",
+);
+
+const source = readFileSync(SYSTEM_PROMPT_PATH, "utf-8");
+
+/** Function names that must not exist in the system prompt source. */
+const BANNED_FUNCTIONS = [
+  "buildVerificationRoutingSection",
+  "buildVoiceSetupRoutingSection",
+  "buildPhoneCallsRoutingSection",
+  "buildStarterTaskRoutingSection",
+  "buildChannelCommandIntentSection",
+];
+
+/** Section headings that must not appear as string literals. */
+const BANNED_HEADINGS = [
+  "## Routing: Guardian Verification",
+  "## Routing: Voice Setup",
+  "## Routing: Phone Calls",
+  "## Routing: Starter Tasks",
+  "## Channel Command Intents",
+];
+
+describe("no domain routing in system prompt", () => {
+  for (const fn of BANNED_FUNCTIONS) {
+    test(`source does not contain function "${fn}"`, () => {
+      expect(source).not.toContain(fn);
+    });
+  }
+
+  for (const heading of BANNED_HEADINGS) {
+    test(`source does not contain heading "${heading}"`, () => {
+      expect(source).not.toContain(heading);
+    });
+  }
+});

package/src/__tests__/notification-broadcaster.test.ts

@@ -6,9 +6,9 @@
  * - Handles missing adapters gracefully
  * - Falls back to copy-composer when decision copy is missing
  * - Reports delivery results per channel
- * - Emits notification_thread_created only when a new conversation is created
- * - Does NOT emit notification_thread_created when reusing an existing thread
- * - Threads destination binding context into conversation pairing for external channels
+ * - Emits notification_conversation_created only when a new conversation is created
+ * - Does NOT emit notification_conversation_created when reusing an existing conversation
+ * - Passes destination binding context into conversation pairing for external channels
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -89,12 +89,12 @@ mock.module("../notifications/conversation-pairing.js", () => ({
       messageId: `mock-msg-${pairingCallCount}`,
       strategy: "start_new_conversation" as const,
       createdNewConversation: true,
-      threadDecisionFallbackUsed: false,
+      conversationFallbackUsed: false,
     };
   },
 }));
 
-import type { ThreadCreatedInfo } from "../notifications/broadcaster.js";
+import type { ConversationCreatedInfo } from "../notifications/broadcaster.js";
 import { NotificationBroadcaster } from "../notifications/broadcaster.js";
 import type { NotificationSignal } from "../notifications/signal.js";
 import type {
@@ -295,7 +295,7 @@ describe("notification broadcaster", () => {
     expect(vellumAdapter.sent[0].copy.body).toBeDefined();
   });
 
-  test("adapter receives concise copy (title/body), not the thread seed message", async () => {
+  test("adapter receives concise copy (title/body), not the conversation seed message", async () => {
     const vellumAdapter = new MockAdapter("vellum");
     const broadcaster = new NotificationBroadcaster([vellumAdapter]);
 
@@ -305,7 +305,7 @@ describe("notification broadcaster", () => {
         vellum: {
           title: "Reminder",
           body: "Take out the trash",
-          threadSeedMessage:
+          conversationSeedMessage:
             "This is a much richer seed message with more context about the reminder and what you should do about it.",
         },
       },
@@ -315,7 +315,7 @@ describe("notification broadcaster", () => {
 
     expect(vellumAdapter.sent).toHaveLength(1);
     // The adapter payload uses the full copy object — title/body are what
-    // the native notification displays. threadSeedMessage is only consumed
+    // the native notification displays. The conversationSeedMessage is only consumed
     // by conversation pairing, not by the adapter's display logic.
     expect(vellumAdapter.sent[0].copy.title).toBe("Reminder");
     expect(vellumAdapter.sent[0].copy.body).toBe("Take out the trash");
@@ -336,46 +336,48 @@ describe("notification broadcaster", () => {
     expect(vellumAdapter.sent).toHaveLength(0);
   });
 
-  // ── Thread-created event emission ───────────────────────────────────
+  // ── Conversation-created event emission ─────────────────────────────
 
-  test("fires onThreadCreated when a new vellum conversation is created (start_new)", async () => {
+  test("fires onConversationCreated when a new vellum conversation is created (start_new)", async () => {
     const vellumAdapter = new MockAdapter("vellum");
     const broadcaster = new NotificationBroadcaster([vellumAdapter]);
-    const threadCreatedCalls: ThreadCreatedInfo[] = [];
-    broadcaster.setOnThreadCreated((info) => threadCreatedCalls.push(info));
+    const conversationCreatedCalls: ConversationCreatedInfo[] = [];
+    broadcaster.setOnConversationCreated((info) =>
+      conversationCreatedCalls.push(info),
+    );
 
     const signal = makeSignal();
-    // No threadActions means default start_new behavior
+    // No conversationActions means default start_new behavior
     const decision = makeDecision();
 
     await broadcaster.broadcastDecision(signal, decision);
 
-    // Pairing creates a new conversation by default, so onThreadCreated should fire
-    expect(threadCreatedCalls).toHaveLength(1);
-    expect(threadCreatedCalls[0].sourceEventName).toBe("test.event");
+    // Pairing creates a new conversation by default, so onConversationCreated should fire
+    expect(conversationCreatedCalls).toHaveLength(1);
+    expect(conversationCreatedCalls[0].sourceEventName).toBe("test.event");
   });
 
-  test("fires per-dispatch onThreadCreated callback on new conversation", async () => {
+  test("fires per-dispatch onConversationCreated callback on new conversation", async () => {
     const vellumAdapter = new MockAdapter("vellum");
     const broadcaster = new NotificationBroadcaster([vellumAdapter]);
-    const dispatchCalls: ThreadCreatedInfo[] = [];
+    const dispatchCalls: ConversationCreatedInfo[] = [];
 
     const signal = makeSignal();
     const decision = makeDecision();
 
     await broadcaster.broadcastDecision(signal, decision, {
-      onThreadCreated: (info) => dispatchCalls.push(info),
+      onConversationCreated: (info) => dispatchCalls.push(info),
     });
 
     expect(dispatchCalls).toHaveLength(1);
   });
 
-  test("does NOT fire class-level onThreadCreated when reusing an existing thread", async () => {
+  test("does NOT fire class-level onConversationCreated when reusing an existing conversation", async () => {
     const vellumAdapter = new MockAdapter("vellum");
     const broadcaster = new NotificationBroadcaster([vellumAdapter]);
-    const eventCalls: ThreadCreatedInfo[] = [];
-    const dispatchCalls: ThreadCreatedInfo[] = [];
-    broadcaster.setOnThreadCreated((info) => eventCalls.push(info));
+    const eventCalls: ConversationCreatedInfo[] = [];
+    const dispatchCalls: ConversationCreatedInfo[] = [];
+    broadcaster.setOnConversationCreated((info) => eventCalls.push(info));
 
     // Simulate a successful reuse by injecting a pairing result with
     // createdNewConversation=false. This bypasses the real conversation
@@ -386,12 +388,12 @@ describe("notification broadcaster", () => {
       messageId: "msg-reused-789",
       strategy: "start_new_conversation",
       createdNewConversation: false,
-      threadDecisionFallbackUsed: false,
+      conversationFallbackUsed: false,
     };
 
     const signal = makeSignal();
     const decision = makeDecision({
-      threadActions: {
+      conversationActions: {
         vellum: {
           action: "reuse_existing",
           conversationId: "conv-existing-123",
@@ -400,7 +402,7 @@ describe("notification broadcaster", () => {
     });
 
     await broadcaster.broadcastDecision(signal, decision, {
-      onThreadCreated: (info) => dispatchCalls.push(info),
+      onConversationCreated: (info) => dispatchCalls.push(info),
     });
 
     // The class-level event callback should NOT fire because
@@ -486,11 +488,11 @@ describe("notification broadcaster", () => {
     });
   });
 
-  test("reused thread via binding-key continuation does NOT emit class-level onThreadCreated", async () => {
+  test("reused conversation via binding-key continuation does NOT emit class-level onConversationCreated", async () => {
     const vellumAdapter = new MockAdapter("vellum");
     const broadcaster = new NotificationBroadcaster([vellumAdapter]);
-    const eventCalls: ThreadCreatedInfo[] = [];
-    broadcaster.setOnThreadCreated((info) => eventCalls.push(info));
+    const eventCalls: ConversationCreatedInfo[] = [];
+    broadcaster.setOnConversationCreated((info) => eventCalls.push(info));
 
     // Simulate binding-key continuation: pairing reuses an existing bound
     // conversation (createdNewConversation=false, strategy=continue_existing_conversation)
@@ -499,7 +501,7 @@ describe("notification broadcaster", () => {
       messageId: "msg-bound-voice-001",
       strategy: "continue_existing_conversation" as const,
       createdNewConversation: false,
-      threadDecisionFallbackUsed: false,
+      conversationFallbackUsed: false,
     };
 
     const signal = makeSignal();
@@ -508,27 +510,27 @@ describe("notification broadcaster", () => {
     await broadcaster.broadcastDecision(signal, decision);
 
     // The class-level event callback should NOT fire because
-    // createdNewConversation is false — the thread already exists
+    // createdNewConversation is false — the conversation already exists
     // in the external channel and the client already knows about it.
     expect(eventCalls).toHaveLength(0);
   });
 
-  test("fresh conversation for continue_existing_conversation does NOT emit class-level onThreadCreated", async () => {
+  test("fresh conversation for continue_existing_conversation does NOT emit class-level onConversationCreated", async () => {
     const vellumAdapter = new MockAdapter("vellum");
     const broadcaster = new NotificationBroadcaster([vellumAdapter]);
-    const eventCalls: ThreadCreatedInfo[] = [];
-    broadcaster.setOnThreadCreated((info) => eventCalls.push(info));
+    const eventCalls: ConversationCreatedInfo[] = [];
+    broadcaster.setOnConversationCreated((info) => eventCalls.push(info));
 
     // First delivery to a new destination: creates a fresh conversation but
     // the strategy is continue_existing_conversation (not start_new_conversation),
-    // so the event should NOT fire — these are background threads not
+    // so the event should NOT fire — these are background conversations not
     // meant to appear in the sidebar.
     nextPairingResult = {
       conversationId: "conv-new-telegram-dest",
       messageId: "msg-new-telegram-dest",
       strategy: "continue_existing_conversation" as const,
       createdNewConversation: true,
-      threadDecisionFallbackUsed: false,
+      conversationFallbackUsed: false,
     };
 
     const signal = makeSignal();
@@ -541,10 +543,10 @@ describe("notification broadcaster", () => {
     expect(eventCalls).toHaveLength(0);
   });
 
-  test("per-dispatch onThreadCreated fires for reused binding-key conversation", async () => {
+  test("per-dispatch onConversationCreated fires for reused binding-key conversation", async () => {
     const vellumAdapter = new MockAdapter("vellum");
     const broadcaster = new NotificationBroadcaster([vellumAdapter]);
-    const dispatchCalls: ThreadCreatedInfo[] = [];
+    const dispatchCalls: ConversationCreatedInfo[] = [];
 
     // Binding-key reuse: conversation already exists
     nextPairingResult = {
@@ -552,14 +554,14 @@ describe("notification broadcaster", () => {
       messageId: "msg-bound-telegram-789",
       strategy: "continue_existing_conversation" as const,
       createdNewConversation: false,
-      threadDecisionFallbackUsed: false,
+      conversationFallbackUsed: false,
     };
 
     const signal = makeSignal();
     const decision = makeDecision();
 
     await broadcaster.broadcastDecision(signal, decision, {
-      onThreadCreated: (info) => dispatchCalls.push(info),
+      onConversationCreated: (info) => dispatchCalls.push(info),
     });
 
     // The per-dispatch callback SHOULD fire regardless of reuse