vellum 0.2.1 → 0.2.7

package/src/__tests__/llm-usage-store.test.ts

@@ -23,7 +23,7 @@ mock.module('../util/logger.js', () => ({
   }),
 }));
 
-import { initializeDb, getDb } from '../memory/db.js';
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
 import { recordUsageEvent, listUsageEvents } from '../memory/llm-usage-store.js';
 import type { UsageEventInput, PricingResult } from '../usage/types.js';
 
@@ -31,6 +31,7 @@ import type { UsageEventInput, PricingResult } from '../usage/types.js';
 initializeDb();
 
 afterAll(() => {
+  resetDb();
   try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
 });
 
@@ -43,7 +44,6 @@ function makeInput(overrides?: Partial<UsageEventInput>): UsageEventInput {
     cacheCreationInputTokens: null,
     cacheReadInputTokens: null,
     actor: 'main_agent',
-    assistantId: null,
     conversationId: null,
     runId: null,
     requestId: null,
@@ -86,7 +86,7 @@ describe('recordUsageEvent', () => {
   });
 
   test('persists a priced event that can be retrieved', () => {
-    const input = makeInput({ assistantId: 'a1', conversationId: 'c1' });
+    const input = makeInput({ conversationId: 'c1' });
     const event = recordUsageEvent(input, pricedResult);
 
     const events = listUsageEvents();
@@ -94,7 +94,6 @@ describe('recordUsageEvent', () => {
     expect(events[0].id).toBe(event.id);
     expect(events[0].estimatedCostUsd).toBe(0.0045);
     expect(events[0].pricingStatus).toBe('priced');
-    expect(events[0].assistantId).toBe('a1');
     expect(events[0].conversationId).toBe('c1');
   });
 
@@ -113,7 +112,6 @@ describe('recordUsageEvent', () => {
 
   test('handles null optional fields', () => {
     const input = makeInput({
-      assistantId: null,
       conversationId: null,
       runId: null,
       requestId: null,
@@ -124,7 +122,6 @@ describe('recordUsageEvent', () => {
 
     const events = listUsageEvents();
     expect(events).toHaveLength(1);
-    expect(events[0].assistantId).toBeNull();
     expect(events[0].conversationId).toBeNull();
     expect(events[0].runId).toBeNull();
     expect(events[0].requestId).toBeNull();
@@ -134,7 +131,6 @@ describe('recordUsageEvent', () => {
 
   test('handles populated optional fields', () => {
     const input = makeInput({
-      assistantId: 'assistant-1',
       conversationId: 'conv-1',
       runId: 'run-1',
       requestId: 'req-1',
@@ -145,7 +141,6 @@ describe('recordUsageEvent', () => {
 
     const events = listUsageEvents();
     expect(events).toHaveLength(1);
-    expect(events[0].assistantId).toBe('assistant-1');
     expect(events[0].conversationId).toBe('conv-1');
     expect(events[0].runId).toBe('run-1');
     expect(events[0].requestId).toBe('req-1');

package/src/__tests__/media-generate-image.test.ts

@@ -232,7 +232,7 @@ describe('image-studio TOOLS.json manifest', () => {
     const props = manifest.tools[0].input_schema.properties;
     expect(props.mode.enum).toEqual(['generate', 'edit']);
     expect(props.attachment_ids.type).toBe('array');
-    expect(props.model.enum).toEqual(['gemini-2.5-flash-image', 'gemini-3-pro-image']);
+    expect(props.model.enum).toEqual(['gemini-2.5-flash-image', 'gemini-3-pro-image', 'gemini-3-pro-image-preview']);
     expect(props.variants.type).toBe('number');
   });
 });

package/src/__tests__/media-reuse-story.e2e.test.ts

@@ -96,7 +96,7 @@ mock.module('../tools/network/script-proxy/certs.js', () => ({
 // Source imports (after mocks)
 // ---------------------------------------------------------------------------
 
-import { initializeDb, getDb } from '../memory/db.js';
+import { initializeDb, getDb, resetDb } from '../memory/db.js';
 import { uploadAttachment, linkAttachmentToMessage } from '../memory/attachments-store.js';
 import { createConversation, addMessage } from '../memory/conversation-store.js';
 import { assetSearchTool, searchAttachments } from '../tools/assets/search.js';
@@ -114,6 +114,7 @@ initializeDb();
 mkdirSync(sandboxDir, { recursive: true });
 
 afterAll(async () => {
+  resetDb();
   await stopAllSessions();
   resolveByIdResults = new Map();
   secureKeyValues = new Map();
@@ -211,7 +212,7 @@ describe('Story E2E: selfie yesterday -> generated image today', () => {
 
     // -- Step 2: Selfie uploaded in Thread A (standard) --
     threadA = createConversation({ title: 'Thread A — selfie upload' });
-    selfieAttachment = uploadAttachment('asst-story-01', 'selfie.png', 'image/png', TINY_PNG_BASE64);
+    selfieAttachment = uploadAttachment('selfie.png', 'image/png', TINY_PNG_BASE64);
     selfieId = selfieAttachment.id;
 
     const msgA = addMessage(threadA.id, 'user', 'Here is my selfie from yesterday');
@@ -358,7 +359,6 @@ describe('Story E2E: selfie yesterday -> generated image today', () => {
     // in the attachment store (same hash = returns existing row).
     const generatedImageBase64 = Buffer.from('generated-portrait-data-unique').toString('base64');
     const outputAttachment = uploadAttachment(
-      'asst-story-01',
       'generated-portrait.png',
       'image/png',
       generatedImageBase64,
@@ -473,7 +473,7 @@ describe('Private-thread variant: cross-thread media blocking', () => {
   test('selfie in private thread A is NOT discoverable via search from Thread B', async () => {
     // Upload selfie in a private thread
     const privateThread = createConversation({ title: 'Private selfie thread', threadType: 'private' });
-    const selfie = uploadAttachment('asst-priv', 'private-selfie.png', 'image/png', TINY_PNG_BASE64);
+    const selfie = uploadAttachment('private-selfie.png', 'image/png', TINY_PNG_BASE64);
     const msg = addMessage(privateThread.id, 'user', 'My private selfie');
     linkAttachmentToMessage(msg.id, selfie.id, 0);
 
@@ -497,7 +497,7 @@ describe('Private-thread variant: cross-thread media blocking', () => {
   test('selfie in private thread A is NOT materializable from Thread B', async () => {
     const privateThread = createConversation({ title: 'Private selfie thread', threadType: 'private' });
     const base64 = Buffer.from('private image data').toString('base64');
-    const selfie = uploadAttachment('asst-priv', 'private-selfie.png', 'image/png', base64);
+    const selfie = uploadAttachment('private-selfie.png', 'image/png', base64);
     const msg = addMessage(privateThread.id, 'user', 'My private selfie');
     linkAttachmentToMessage(msg.id, selfie.id, 0);
 
@@ -521,7 +521,7 @@ describe('Private-thread variant: cross-thread media blocking', () => {
 
   test('selfie in private thread IS accessible from the same private thread', async () => {
     const privateThread = createConversation({ title: 'Private selfie thread', threadType: 'private' });
-    const selfie = uploadAttachment('asst-priv', 'private-selfie.png', 'image/png', TINY_PNG_BASE64);
+    const selfie = uploadAttachment('private-selfie.png', 'image/png', TINY_PNG_BASE64);
     const msg = addMessage(privateThread.id, 'user', 'My private selfie');
     linkAttachmentToMessage(msg.id, selfie.id, 0);
 
@@ -550,7 +550,7 @@ describe('Private-thread variant: cross-thread media blocking', () => {
 
   test('selfie in private thread A is NOT accessible from private thread B', async () => {
     const privateThreadA = createConversation({ title: 'Private thread A', threadType: 'private' });
-    const selfie = uploadAttachment('asst-priv', 'thread-a-selfie.png', 'image/png', TINY_PNG_BASE64);
+    const selfie = uploadAttachment('thread-a-selfie.png', 'image/png', TINY_PNG_BASE64);
     const msgA = addMessage(privateThreadA.id, 'user', 'Selfie in thread A');
     linkAttachmentToMessage(msgA.id, selfie.id, 0);
 

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

@@ -949,7 +949,7 @@ describe('Memory regressions', () => {
         id: 'msg-conflicts-bg',
         conversationId: 'conv-conflicts-bg',
         role: 'user',
-        content: JSON.stringify([{ type: 'text', text: 'Keep the new one instead.' }]),
+        content: JSON.stringify([{ type: 'text', text: 'Keep the new MySQL default instead.' }]),
         createdAt: now + 1,
       }).run();
 
@@ -1047,7 +1047,7 @@ describe('Memory regressions', () => {
         id: 'msg-conflicts-age',
         conversationId: 'conv-conflicts-age',
         role: 'user',
-        content: JSON.stringify([{ type: 'text', text: 'Keep the new one instead.' }]),
+        content: JSON.stringify([{ type: 'text', text: 'Keep the new Bun runtime instead.' }]),
         createdAt: now + 1,
       }).run();
 
@@ -1118,6 +1118,104 @@ describe('Memory regressions', () => {
     }
   });
 
+  test('background conflict resolver ignores clarification-like replies with no topical overlap when conflict was never asked', async () => {
+    const db = getDb();
+    const now = 1_700_001_400_000;
+    const originalConflictsEnabled = TEST_CONFIG.memory.conflicts.enabled;
+    TEST_CONFIG.memory.conflicts.enabled = true;
+
+    try {
+      db.insert(conversations).values({
+        id: 'conv-conflicts-unrelated',
+        title: null,
+        createdAt: now,
+        updatedAt: now,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalEstimatedCost: 0,
+        contextSummary: null,
+        contextCompactedMessageCount: 0,
+        contextCompactedAt: null,
+      }).run();
+
+      db.insert(messages).values({
+        id: 'msg-conflicts-unrelated',
+        conversationId: 'conv-conflicts-unrelated',
+        role: 'user',
+        content: JSON.stringify([{ type: 'text', text: 'Keep the new one instead.' }]),
+        createdAt: now + 1,
+      }).run();
+
+      db.insert(memoryItems).values([
+        {
+          id: 'item-conflict-existing-unrelated',
+          kind: 'preference',
+          subject: 'database',
+          statement: 'Use Postgres by default.',
+          status: 'active',
+          confidence: 0.8,
+          fingerprint: 'fp-conflict-existing-unrelated',
+          verificationState: 'assistant_inferred',
+          scopeId: 'scope-conflicts-unrelated',
+          firstSeenAt: now - 10_000,
+          lastSeenAt: now - 5_000,
+          validFrom: now - 10_000,
+          invalidAt: null,
+        },
+        {
+          id: 'item-conflict-candidate-unrelated',
+          kind: 'preference',
+          subject: 'database',
+          statement: 'Use MySQL by default.',
+          status: 'pending_clarification',
+          confidence: 0.8,
+          fingerprint: 'fp-conflict-candidate-unrelated',
+          verificationState: 'assistant_inferred',
+          scopeId: 'scope-conflicts-unrelated',
+          firstSeenAt: now - 9_000,
+          lastSeenAt: now - 4_000,
+          validFrom: now - 9_000,
+          invalidAt: null,
+        },
+      ]).run();
+
+      const conflict = createOrUpdatePendingConflict({
+        scopeId: 'scope-conflicts-unrelated',
+        existingItemId: 'item-conflict-existing-unrelated',
+        candidateItemId: 'item-conflict-candidate-unrelated',
+        relationship: 'ambiguous_contradiction',
+      });
+      db.update(memoryItemConflicts)
+        .set({ createdAt: now, updatedAt: now, lastAskedAt: null })
+        .where(eq(memoryItemConflicts.id, conflict.id))
+        .run();
+
+      enqueueResolvePendingConflictsForMessageJob('msg-conflicts-unrelated', 'scope-conflicts-unrelated');
+      const processed = await runMemoryJobsOnce();
+      expect(processed).toBe(1);
+
+      const existing = db
+        .select()
+        .from(memoryItems)
+        .where(eq(memoryItems.id, 'item-conflict-existing-unrelated'))
+        .get();
+      const candidate = db
+        .select()
+        .from(memoryItems)
+        .where(eq(memoryItems.id, 'item-conflict-candidate-unrelated'))
+        .get();
+      const updatedConflict = getConflictById(conflict.id);
+
+      expect(existing?.status).toBe('active');
+      expect(existing?.invalidAt).toBeNull();
+      expect(candidate?.status).toBe('pending_clarification');
+      expect(updatedConflict?.status).toBe('pending_clarification');
+      expect(updatedConflict?.resolutionNote).toBeNull();
+    } finally {
+      TEST_CONFIG.memory.conflicts.enabled = originalConflictsEnabled;
+    }
+  });
+
   test('cleanup job enqueue is deduped and retention overrides upgrade payload', () => {
     const db = getDb();