vellum 0.2.0 → 0.2.1

package/src/__tests__/commit-message-enrichment-service.test.ts

@@ -0,0 +1,409 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { mkdirSync, rmSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { execFileSync } from 'node:child_process';
+import {
+  CommitEnrichmentService,
+  _resetEnrichmentService,
+} from '../workspace/commit-message-enrichment-service.js';
+import { WorkspaceGitService, _resetGitServiceRegistry } from '../workspace/git-service.js';
+import type { CommitContext } from '../workspace/commit-message-provider.js';
+
+describe('CommitEnrichmentService', () => {
+  let testDir: string;
+  let gitService: WorkspaceGitService;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `vellum-enrichment-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(testDir, { recursive: true });
+    _resetGitServiceRegistry();
+    _resetEnrichmentService();
+
+    gitService = new WorkspaceGitService(testDir);
+    await gitService.ensureInitialized();
+  });
+
+  afterEach(async () => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  function makeContext(overrides?: Partial<CommitContext>): CommitContext {
+    return {
+      workspaceDir: testDir,
+      trigger: 'turn',
+      sessionId: 'sess_test',
+      turnNumber: 1,
+      changedFiles: ['file.txt'],
+      timestampMs: Date.now(),
+      ...overrides,
+    };
+  }
+
+  async function createCommit(): Promise<string> {
+    writeFileSync(join(testDir, `file-${Date.now()}.txt`), 'content');
+    await gitService.commitChanges('test commit');
+    return await gitService.getHeadHash();
+  }
+
+  test('enqueue and execute writes git note on success', async () => {
+    const commitHash = await createCommit();
+    const service = new CommitEnrichmentService({
+      maxQueueSize: 10,
+      maxConcurrency: 1,
+      jobTimeoutMs: 5000,
+      maxRetries: 0,
+    });
+
+    service.enqueue({
+      workspaceDir: testDir,
+      commitHash,
+      context: makeContext(),
+      gitService,
+    });
+
+    // Wait for async processing
+    await service.shutdown();
+
+    // Verify git note was written
+    const noteContent = execFileSync('git', ['notes', '--ref=vellum', 'show', commitHash], {
+      cwd: testDir,
+      encoding: 'utf-8',
+    });
+
+    const note = JSON.parse(noteContent);
+    expect(note.enriched).toBe(true);
+    expect(note.trigger).toBe('turn');
+    expect(note.sessionId).toBe('sess_test');
+    expect(note.turnNumber).toBe(1);
+    expect(note.filesChanged).toBe(1);
+    expect(service._getSucceededCount()).toBe(1);
+  });
+
+  test('queue overflow drops oldest job', async () => {
+    const service = new CommitEnrichmentService({
+      maxQueueSize: 2,
+      maxConcurrency: 1,
+      jobTimeoutMs: 30000,
+      maxRetries: 0,
+    });
+
+    const hash1 = await createCommit();
+    const hash2 = await createCommit();
+    const hash3 = await createCommit();
+
+    // Enqueue 3 jobs — hash1 starts immediately (active worker),
+    // hash2 goes to queue (size=1), hash3 goes to queue (size=2), no overflow drop.
+    service.enqueue({ workspaceDir: testDir, commitHash: hash1, context: makeContext(), gitService });
+    service.enqueue({ workspaceDir: testDir, commitHash: hash2, context: makeContext(), gitService });
+    service.enqueue({ workspaceDir: testDir, commitHash: hash3, context: makeContext(), gitService });
+
+    // No overflow drops — queue size 2 can hold 2 pending while 1 is active
+    expect(service._getDroppedCount()).toBe(0);
+    expect(service._getQueueSize()).toBe(2);
+
+    // Shutdown discards the 2 pending jobs
+    await service.shutdown();
+    expect(service._getDroppedCount()).toBe(2);
+    expect(service._getSucceededCount()).toBe(1);
+  });
+
+  test('queue overflow actually drops when truly full', async () => {
+    // Create a service where the worker is slow
+    const service = new CommitEnrichmentService({
+      maxQueueSize: 1,
+      maxConcurrency: 1,
+      jobTimeoutMs: 30000,
+      maxRetries: 0,
+    });
+
+    const hash1 = await createCommit();
+    const hash2 = await createCommit();
+    const hash3 = await createCommit();
+
+    // hash1 starts processing immediately (active worker = 1, queue empty)
+    // hash2 goes to queue (queue size = 1)
+    // hash3 tries to go to queue but it's full → drops hash2, adds hash3
+    service.enqueue({ workspaceDir: testDir, commitHash: hash1, context: makeContext(), gitService });
+    service.enqueue({ workspaceDir: testDir, commitHash: hash2, context: makeContext(), gitService });
+    service.enqueue({ workspaceDir: testDir, commitHash: hash3, context: makeContext(), gitService });
+
+    expect(service._getDroppedCount()).toBe(1);
+
+    await service.shutdown();
+  });
+
+  test('fire-and-forget enqueue does not block caller', async () => {
+    const commitHash = await createCommit();
+    const service = new CommitEnrichmentService({
+      maxQueueSize: 10,
+      maxConcurrency: 1,
+      jobTimeoutMs: 5000,
+      maxRetries: 0,
+    });
+
+    const start = Date.now();
+    service.enqueue({
+      workspaceDir: testDir,
+      commitHash,
+      context: makeContext(),
+      gitService,
+    });
+    const elapsed = Date.now() - start;
+
+    // enqueue should return immediately (< 50ms)
+    expect(elapsed).toBeLessThan(50);
+
+    await service.shutdown();
+  });
+
+  test('graceful shutdown drains in-flight and discards pending', async () => {
+    const hash1 = await createCommit();
+    const hash2 = await createCommit();
+
+    const service = new CommitEnrichmentService({
+      maxQueueSize: 10,
+      maxConcurrency: 1,
+      jobTimeoutMs: 5000,
+      maxRetries: 0,
+    });
+
+    service.enqueue({ workspaceDir: testDir, commitHash: hash1, context: makeContext(), gitService });
+    service.enqueue({ workspaceDir: testDir, commitHash: hash2, context: makeContext(), gitService });
+
+    // Shutdown should complete without hanging
+    await service.shutdown();
+
+    // The first job was in-flight and should complete. The second was pending
+    // and should be discarded, counted as dropped.
+    expect(service._getSucceededCount()).toBe(1);
+    expect(service._getDroppedCount()).toBe(1);
+    expect(service._getQueueSize()).toBe(0);
+  });
+
+  test('shutdown discards all pending jobs and counts them as dropped', async () => {
+    // Use maxConcurrency 1 so only one job starts processing; the rest stay pending.
+    const hashes: string[] = [];
+    for (let i = 0; i < 5; i++) {
+      hashes.push(await createCommit());
+    }
+
+    const service = new CommitEnrichmentService({
+      maxQueueSize: 10,
+      maxConcurrency: 1,
+      jobTimeoutMs: 5000,
+      maxRetries: 0,
+    });
+
+    for (const hash of hashes) {
+      service.enqueue({ workspaceDir: testDir, commitHash: hash, context: makeContext(), gitService });
+    }
+
+    // First job is in-flight, remaining 4 are pending
+    await service.shutdown();
+
+    // In-flight job completes, pending jobs are discarded
+    expect(service._getSucceededCount()).toBe(1);
+    expect(service._getDroppedCount()).toBe(4);
+  });
+
+  test('shutdown does not cause concurrency spike', async () => {
+    const hashes: string[] = [];
+    for (let i = 0; i < 3; i++) {
+      hashes.push(await createCommit());
+    }
+
+    const service = new CommitEnrichmentService({
+      maxQueueSize: 10,
+      maxConcurrency: 1,
+      jobTimeoutMs: 5000,
+      maxRetries: 0,
+    });
+
+    for (const hash of hashes) {
+      service.enqueue({ workspaceDir: testDir, commitHash: hash, context: makeContext(), gitService });
+    }
+
+    await service.shutdown();
+
+    // Active workers should be 0 after shutdown
+    expect(service._getActiveWorkers()).toBe(0);
+  });
+
+  test('discards jobs enqueued after shutdown', async () => {
+    const commitHash = await createCommit();
+    const service = new CommitEnrichmentService({
+      maxQueueSize: 10,
+      maxConcurrency: 1,
+      jobTimeoutMs: 5000,
+      maxRetries: 0,
+    });
+
+    await service.shutdown();
+
+    // Enqueue after shutdown should be silently discarded
+    service.enqueue({
+      workspaceDir: testDir,
+      commitHash,
+      context: makeContext(),
+      gitService,
+    });
+
+    expect(service._getQueueSize()).toBe(0);
+    expect(service._getSucceededCount()).toBe(0);
+  });
+
+  test('multiple successful enrichments write separate git notes', async () => {
+    const hash1 = await createCommit();
+    const hash2 = await createCommit();
+
+    const service = new CommitEnrichmentService({
+      maxQueueSize: 10,
+      maxConcurrency: 1,
+      jobTimeoutMs: 5000,
+      maxRetries: 0,
+    });
+
+    service.enqueue({
+      workspaceDir: testDir,
+      commitHash: hash1,
+      context: makeContext({ turnNumber: 1 }),
+      gitService,
+    });
+    service.enqueue({
+      workspaceDir: testDir,
+      commitHash: hash2,
+      context: makeContext({ turnNumber: 2 }),
+      gitService,
+    });
+
+    // Wait for queue to drain before shutdown (avoids discarding pending jobs)
+    while (service._getQueueSize() > 0 || service._getActiveWorkers() > 0) {
+      await new Promise(resolve => setTimeout(resolve, 50));
+    }
+    await service.shutdown();
+
+    // Both notes should exist
+    const note1 = JSON.parse(execFileSync('git', ['notes', '--ref=vellum', 'show', hash1], {
+      cwd: testDir, encoding: 'utf-8',
+    }));
+    const note2 = JSON.parse(execFileSync('git', ['notes', '--ref=vellum', 'show', hash2], {
+      cwd: testDir, encoding: 'utf-8',
+    }));
+
+    expect(note1.turnNumber).toBe(1);
+    expect(note2.turnNumber).toBe(2);
+    expect(service._getSucceededCount()).toBe(2);
+  });
+
+  test('job timeout triggers retry with backoff then fails after max retries', async () => {
+    // Use a very short timeout so the real git notes write times out
+    const service = new CommitEnrichmentService({
+      maxQueueSize: 10,
+      maxConcurrency: 1,
+      jobTimeoutMs: 1, // 1ms timeout — will always time out
+      maxRetries: 2,
+    });
+
+    const commitHash = await createCommit();
+    service.enqueue({
+      workspaceDir: testDir,
+      commitHash,
+      context: makeContext(),
+      gitService,
+    });
+
+    // Wait for all retries to complete (initial + 2 retries, with backoff)
+    // Backoff: 1s after attempt 1, 2s after attempt 2 = ~3s total
+    // But since the job itself is very fast to time out, total time is dominated by backoff
+    while (service._getActiveWorkers() > 0 || service._getQueueSize() > 0) {
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    await service.shutdown();
+
+    // After 1 initial attempt + 2 retries (3 total), the job should be counted as failed
+    expect(service._getFailedCount()).toBe(1);
+    expect(service._getSucceededCount()).toBe(0);
+  }, 15000); // Allow up to 15s for backoff delays
+
+  test('queue overflow drop behavior is deterministic', async () => {
+    // With maxQueueSize=2 and maxConcurrency=1:
+    // - Job A starts processing immediately (in-flight)
+    // - Job B enters queue (size=1)
+    // - Job C enters queue (size=2)
+    // - Job D overflows: drops oldest (B), adds D → queue has [C, D]
+    // - Job E overflows: drops oldest (C), adds E → queue has [D, E]
+    const service = new CommitEnrichmentService({
+      maxQueueSize: 2,
+      maxConcurrency: 1,
+      jobTimeoutMs: 30000,
+      maxRetries: 0,
+    });
+
+    const hashA = await createCommit();
+    const hashB = await createCommit();
+    const hashC = await createCommit();
+    const hashD = await createCommit();
+    const hashE = await createCommit();
+
+    service.enqueue({ workspaceDir: testDir, commitHash: hashA, context: makeContext({ turnNumber: 1 }), gitService });
+    service.enqueue({ workspaceDir: testDir, commitHash: hashB, context: makeContext({ turnNumber: 2 }), gitService });
+    service.enqueue({ workspaceDir: testDir, commitHash: hashC, context: makeContext({ turnNumber: 3 }), gitService });
+    // No drops yet: A is in-flight, B and C in queue (size=2)
+    expect(service._getDroppedCount()).toBe(0);
+
+    service.enqueue({ workspaceDir: testDir, commitHash: hashD, context: makeContext({ turnNumber: 4 }), gitService });
+    // Queue was full (2), so oldest (B) was dropped
+    expect(service._getDroppedCount()).toBe(1);
+
+    service.enqueue({ workspaceDir: testDir, commitHash: hashE, context: makeContext({ turnNumber: 5 }), gitService });
+    // Queue was full again (2), so oldest (C) was dropped
+    expect(service._getDroppedCount()).toBe(2);
+
+    // Queue should have exactly 2 items: D and E
+    expect(service._getQueueSize()).toBe(2);
+
+    await service.shutdown();
+
+    // A was in-flight and completed; D and E were pending and discarded at shutdown
+    expect(service._getSucceededCount()).toBe(1);
+    // 2 overflow drops + 2 shutdown discards = 4 total
+    expect(service._getDroppedCount()).toBe(4);
+  });
+
+  test('enqueue is fire-and-forget and never throws even when called rapidly', async () => {
+    const service = new CommitEnrichmentService({
+      maxQueueSize: 3,
+      maxConcurrency: 1,
+      jobTimeoutMs: 5000,
+      maxRetries: 0,
+    });
+
+    const hashes: string[] = [];
+    for (let i = 0; i < 5; i++) {
+      hashes.push(await createCommit());
+    }
+
+    // Rapidly enqueue more jobs than the queue can hold — must never throw
+    const fn = () => {
+      for (const hash of hashes) {
+        service.enqueue({
+          workspaceDir: testDir,
+          commitHash: hash,
+          context: makeContext(),
+          gitService,
+        });
+      }
+    };
+
+    expect(fn).not.toThrow();
+
+    // Some jobs should have been dropped due to overflow (queue size 3, 1 in-flight)
+    // 5 jobs: 1 in-flight + 3 queue + 1 overflow = at least 1 drop
+    expect(service._getDroppedCount()).toBeGreaterThanOrEqual(1);
+
+    await service.shutdown();
+  });
+});

package/src/__tests__/config-schema.test.ts

@@ -496,6 +496,55 @@ describe('AssistantConfigSchema', () => {
       expect(msgs.some(m => m.includes('permissions.mode'))).toBe(true);
     }
   });
+
+  test('applies workspaceGit defaults including interactiveGitTimeoutMs', () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.workspaceGit).toEqual({
+      turnCommitMaxWaitMs: 4000,
+      failureBackoffBaseMs: 2000,
+      failureBackoffMaxMs: 60000,
+      interactiveGitTimeoutMs: 10000,
+      enrichmentQueueSize: 50,
+      enrichmentConcurrency: 1,
+      enrichmentJobTimeoutMs: 30000,
+      enrichmentMaxRetries: 2,
+    });
+  });
+
+  test('accepts custom workspaceGit.interactiveGitTimeoutMs', () => {
+    const result = AssistantConfigSchema.parse({
+      workspaceGit: { interactiveGitTimeoutMs: 5000 },
+    });
+    expect(result.workspaceGit.interactiveGitTimeoutMs).toBe(5000);
+    // Other fields should still get defaults
+    expect(result.workspaceGit.turnCommitMaxWaitMs).toBe(4000);
+  });
+
+  test('rejects non-positive workspaceGit.interactiveGitTimeoutMs', () => {
+    const zeroResult = AssistantConfigSchema.safeParse({
+      workspaceGit: { interactiveGitTimeoutMs: 0 },
+    });
+    expect(zeroResult.success).toBe(false);
+
+    const negativeResult = AssistantConfigSchema.safeParse({
+      workspaceGit: { interactiveGitTimeoutMs: -1 },
+    });
+    expect(negativeResult.success).toBe(false);
+  });
+
+  test('rejects non-integer workspaceGit.interactiveGitTimeoutMs', () => {
+    const result = AssistantConfigSchema.safeParse({
+      workspaceGit: { interactiveGitTimeoutMs: 3.5 },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test('rejects non-number workspaceGit.interactiveGitTimeoutMs', () => {
+    const result = AssistantConfigSchema.safeParse({
+      workspaceGit: { interactiveGitTimeoutMs: 'fast' },
+    });
+    expect(result.success).toBe(false);
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/doordash-session.test.ts

@@ -11,6 +11,7 @@ import {
 
 // Override getDataDir to use a temp directory during tests
 const TEST_DIR = join(tmpdir(), `vellum-dd-test-${process.pid}`);
+let originalDataDir: string | undefined;
 
 // We mock getDataDir by patching the module at the fs level:
 // session.ts calls getSessionDir() -> join(getDataDir(), 'doordash')
@@ -81,11 +82,19 @@ describe('DoorDash session persistence', () => {
   // we test via importFromRecording which exercises save+load.
 
   beforeEach(() => {
+    originalDataDir = process.env.BASE_DATA_DIR;
+    process.env.BASE_DATA_DIR = TEST_DIR;
     // Ensure test dir exists
     mkdirSync(TEST_DIR, { recursive: true });
   });
 
   afterEach(() => {
+    // Restore original BASE_DATA_DIR
+    if (originalDataDir === undefined) {
+      delete process.env.BASE_DATA_DIR;
+    } else {
+      process.env.BASE_DATA_DIR = originalDataDir;
+    }
     // Clean up test dir
     if (existsSync(TEST_DIR)) {
       rmSync(TEST_DIR, { recursive: true, force: true });

package/src/__tests__/ipc-snapshot.test.ts

@@ -70,6 +70,10 @@ const clientMessages: Record<ClientMessageType, ClientMessage> = {
     type: 'model_set',
     model: 'claude-opus-4-6',
   },
+  image_gen_model_set: {
+    type: 'image_gen_model_set',
+    model: 'gemini-2.5-flash-image',
+  },
   history_request: {
     type: 'history_request',
     sessionId: 'sess-001',
@@ -437,10 +441,18 @@ const clientMessages: Record<ClientMessageType, ClientMessage> = {
     type: 'work_item_complete',
     id: 'wi-001',
   },
+  work_item_delete: {
+    type: 'work_item_delete',
+    id: 'wi-001',
+  },
   work_item_run_task: {
     type: 'work_item_run_task',
     id: 'wi-001',
   },
+  work_item_output: {
+    type: 'work_item_output',
+    id: 'wi-001',
+  },
   document_save: {
     type: 'document_save',
     surfaceId: 'doc-001',
@@ -1309,12 +1321,31 @@ const serverMessages: Record<ServerMessageType, ServerMessage> = {
       updatedAt: 1700001000,
     },
   },
+  work_item_delete_response: {
+    type: 'work_item_delete_response',
+    id: 'wi-001',
+    success: true,
+  },
   work_item_run_task_response: {
     type: 'work_item_run_task_response',
     id: 'wi-001',
     lastRunId: 'run-001',
     success: true,
   },
+  work_item_output_response: {
+    type: 'work_item_output_response',
+    id: 'wi-001',
+    success: true,
+    output: {
+      title: 'Process report',
+      status: 'completed',
+      runId: 'run-001',
+      conversationId: 'conv-001',
+      completedAt: 1700002000,
+      summary: 'Report processed successfully.',
+      highlights: ['- Key finding 1', '- Key finding 2'],
+    },
+  },
   work_item_status_changed: {
     type: 'work_item_status_changed',
     item: {
@@ -1328,6 +1359,9 @@ const serverMessages: Record<ServerMessageType, ServerMessage> = {
       updatedAt: 1700001000,
     },
   },
+  tasks_changed: {
+    type: 'tasks_changed',
+  },
   open_tasks_window: {
     type: 'open_tasks_window',
   },

package/src/__tests__/registry.test.ts

@@ -19,7 +19,7 @@ import {
   __resetRegistryForTesting,
   __clearRegistryForTesting,
 } from '../tools/registry.js';
-import { eagerModules, explicitTools, lazyTools } from '../tools/tool-manifest.js';
+import { eagerModuleToolNames, explicitTools, lazyTools } from '../tools/tool-manifest.js';
 
 // Clean up global registry after this file completes to prevent
 // contamination of subsequent test files in combined runs.
@@ -175,8 +175,8 @@ describe('tool manifest', () => {
     expect(lazyNames.has('swarm_delegate')).toBe(true);
   });
 
-  test('eager module list contains expected count', () => {
-    expect(eagerModules.length).toBe(28);
+  test('eager module tool names list contains expected count', () => {
+    expect(eagerModuleToolNames.length).toBe(31);
   });
 
   test('explicit tools list includes memory, credential, and timer tools', () => {
@@ -192,7 +192,7 @@ describe('tool manifest', () => {
   test('registered tool count is at least eager + lazy + host', async () => {
     await initializeTools();
     const tools = getAllTools();
-    expect(tools.length).toBeGreaterThanOrEqual(eagerModules.length + lazyTools.length);
+    expect(tools.length).toBeGreaterThanOrEqual(eagerModuleToolNames.length + lazyTools.length);
   });
 });
 
@@ -210,8 +210,13 @@ describe('baseline characterization: hardcoded tool loading', () => {
     }
   });
 
-  test('gmail eager module is NOT in eagerModules manifest', () => {
-    expect(eagerModules).not.toContain('./gmail/executors.js');
+  test('gmail tool names are NOT in eagerModuleToolNames manifest', () => {
+    const gmailTools = ['gmail_search', 'gmail_list_messages', 'gmail_get_message', 'gmail_mark_read',
+      'gmail_draft', 'gmail_archive', 'gmail_batch_archive', 'gmail_label', 'gmail_batch_label',
+      'gmail_trash', 'gmail_send', 'gmail_unsubscribe'];
+    for (const name of gmailTools) {
+      expect(eagerModuleToolNames).not.toContain(name);
+    }
   });
 
   test('weather tool is NOT in global registry after initializeTools()', async () => {
@@ -220,8 +225,8 @@ describe('baseline characterization: hardcoded tool loading', () => {
     expect(tool).toBeUndefined();
   });
 
-  test('weather eager module is NOT in eagerModules manifest', () => {
-    expect(eagerModules).not.toContain('./weather/get-weather.js');
+  test('weather tool name is NOT in eagerModuleToolNames manifest', () => {
+    expect(eagerModuleToolNames).not.toContain('get_weather');
   });
 
   test('claude_code is NOT in global registry after initializeTools()', async () => {