vellum 0.2.13 → 0.3.2

package/src/__tests__/workspace-git-service.test.ts

@@ -1,1153 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
-import { mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { execFileSync } from 'node:child_process';
-import {
-  WorkspaceGitService,
-  getWorkspaceGitService,
-  _resetGitServiceRegistry,
-  _resetBreaker,
-  _getConsecutiveFailures,
-  _resetInitBreaker,
-  _getInitConsecutiveFailures,
-  isDeadlineExpired,
-} from '../workspace/git-service.js';
-
-describe('WorkspaceGitService', () => {
-  let testDir: string;
-
-  beforeEach(() => {
-    // Create a unique test directory for each test
-    testDir = join(tmpdir(), `vellum-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(testDir, { recursive: true });
-    _resetGitServiceRegistry();
-  });
-
-  afterEach(() => {
-    // Clean up test directory
-    if (existsSync(testDir)) {
-      rmSync(testDir, { recursive: true, force: true });
-    }
-  });
-
-  describe('lazy initialization', () => {
-    test('initializes git repo on first ensureInitialized call', async () => {
-      const service = new WorkspaceGitService(testDir);
-
-      expect(service.isInitialized()).toBe(false);
-
-      await service.ensureInitialized();
-
-      expect(service.isInitialized()).toBe(true);
-      expect(existsSync(join(testDir, '.git'))).toBe(true);
-    });
-
-    test('creates .gitignore with proper exclusions', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      const gitignorePath = join(testDir, '.gitignore');
-      expect(existsSync(gitignorePath)).toBe(true);
-
-      const content = readFileSync(gitignorePath, 'utf-8');
-      expect(content).toContain('data/db/');
-      expect(content).toContain('data/qdrant/');
-      expect(content).toContain('data/ipc-blobs/');
-      expect(content).toContain('*.log');
-      expect(content).toContain('*.sock');
-      expect(content).toContain('*.pid');
-      expect(content).toContain('vellum.sock');
-      expect(content).toContain('session-token');
-    });
-
-    test('sets git identity correctly', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      const userName = execFileSync('git', ['config', 'user.name'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      }).trim();
-      const userEmail = execFileSync('git', ['config', 'user.email'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      }).trim();
-
-      expect(userName).toBe('Vellum Assistant');
-      expect(userEmail).toBe('assistant@vellum.ai');
-    });
-
-    test('multiple ensureInitialized calls are idempotent', async () => {
-      const service = new WorkspaceGitService(testDir);
-
-      await service.ensureInitialized();
-      await service.ensureInitialized();
-      await service.ensureInitialized();
-
-      expect(service.isInitialized()).toBe(true);
-    });
-
-    test('handles concurrent ensureInitialized calls', async () => {
-      const service = new WorkspaceGitService(testDir);
-
-      // Start multiple initialization calls concurrently
-      const promises = [
-        service.ensureInitialized(),
-        service.ensureInitialized(),
-        service.ensureInitialized(),
-      ];
-
-      await Promise.all(promises);
-
-      expect(service.isInitialized()).toBe(true);
-    });
-  });
-
-  describe('initial commit', () => {
-    test('creates initial commit for new empty workspace', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      const log = execFileSync('git', ['log', '--oneline'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      });
-
-      expect(log).toContain('Initial commit: new workspace');
-    });
-
-    test('creates initial commit for existing workspace with files', async () => {
-      // Create some files before initializing git
-      writeFileSync(join(testDir, 'README.md'), '# Test\n');
-      writeFileSync(join(testDir, 'config.json'), '{}');
-      mkdirSync(join(testDir, 'subdir'));
-      writeFileSync(join(testDir, 'subdir', 'file.txt'), 'content');
-
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      const log = execFileSync('git', ['log', '--oneline'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      });
-
-      expect(log).toContain('Initial commit: migrated existing workspace');
-
-      // Verify files were committed
-      const files = execFileSync('git', ['ls-files'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      }).trim().split('\n');
-
-      expect(files).toContain('.gitignore');
-      expect(files).toContain('README.md');
-      expect(files).toContain('config.json');
-      expect(files).toContain('subdir/file.txt');
-    });
-
-    test('initial commit completes within ensureInitialized', async () => {
-      // Create some files before initializing git
-      for (let i = 0; i < 10; i++) {
-        writeFileSync(join(testDir, `file${i}.txt`), 'content');
-      }
-
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      // Initial commit should already be done - no need to wait
-      const log = execFileSync('git', ['log', '--oneline'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      });
-
-      expect(log).toContain('Initial commit: migrated existing workspace');
-    });
-
-    test('initial commit does not race with first commitChanges', async () => {
-      // Pre-populate workspace with files (simulating a migrated workspace)
-      writeFileSync(join(testDir, 'existing.txt'), 'pre-existing content');
-
-      const service = new WorkspaceGitService(testDir);
-
-      // Initialize - the initial commit now happens synchronously within
-      // ensureInitialized, so it completes before we can write new files.
-      await service.ensureInitialized();
-
-      // Now write a file AFTER init and commit it
-      writeFileSync(join(testDir, 'user-edit.txt'), 'user content');
-      await service.commitChanges('User turn 1');
-
-      // The user's commit (HEAD) should contain user-edit.txt
-      const userCommitFiles = execFileSync(
-        'git', ['diff', '--name-only', 'HEAD~1', 'HEAD'],
-        { cwd: testDir, encoding: 'utf-8' },
-      ).trim();
-
-      expect(userCommitFiles).toContain('user-edit.txt');
-      // user-edit.txt should NOT appear in the initial commit
-      expect(userCommitFiles).not.toContain('existing.txt');
-
-      // The initial commit (HEAD~1) should contain existing.txt and .gitignore
-      const initialCommitFiles = execFileSync(
-        'git', ['show', '--name-only', '--pretty=format:', 'HEAD~1'],
-        { cwd: testDir, encoding: 'utf-8' },
-      ).trim();
-
-      expect(initialCommitFiles).toContain('existing.txt');
-      expect(initialCommitFiles).toContain('.gitignore');
-      // The initial commit should NOT contain user-edit.txt
-      expect(initialCommitFiles).not.toContain('user-edit.txt');
-    });
-  });
-
-  describe('commitChanges', () => {
-    test('commits changes with message', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      writeFileSync(join(testDir, 'test.txt'), 'hello world');
-      await service.commitChanges('Add test file');
-
-      const log = execFileSync('git', ['log', '--oneline', '-n', '1'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      });
-
-      expect(log).toContain('Add test file');
-    });
-
-    test('commits with metadata', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      writeFileSync(join(testDir, 'test.txt'), 'content');
-      await service.commitChanges('Add file', {
-        sessionId: 'session-123',
-        timestamp: 1234567890,
-        author: 'user@example.com',
-      });
-
-      const message = execFileSync('git', ['log', '-1', '--pretty=%B'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      });
-
-      expect(message).toContain('Add file');
-      expect(message).toContain('sessionId: "session-123"');
-      expect(message).toContain('timestamp: 1234567890');
-      expect(message).toContain('author: "user@example.com"');
-    });
-
-    test('commits multiple files at once', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      writeFileSync(join(testDir, 'file1.txt'), 'content1');
-      writeFileSync(join(testDir, 'file2.txt'), 'content2');
-      writeFileSync(join(testDir, 'file3.txt'), 'content3');
-
-      await service.commitChanges('Add multiple files');
-
-      const files = execFileSync('git', ['diff', '--name-only', 'HEAD~1', 'HEAD'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      }).trim().split('\n');
-
-      expect(files).toContain('file1.txt');
-      expect(files).toContain('file2.txt');
-      expect(files).toContain('file3.txt');
-    });
-
-    test('allows empty commits', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      // Commit without any changes
-      await service.commitChanges('Empty commit for checkpoint');
-
-      const log = execFileSync('git', ['log', '--oneline', '-n', '1'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      });
-
-      expect(log).toContain('Empty commit for checkpoint');
-    });
-  });
-
-  describe('getStatus', () => {
-    test('returns clean status for new workspace', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      const status = await service.getStatus();
-
-      expect(status.clean).toBe(true);
-      expect(status.staged).toEqual([]);
-      expect(status.modified).toEqual([]);
-      expect(status.untracked).toEqual([]);
-    });
-
-    test('detects untracked files', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      writeFileSync(join(testDir, 'new-file.txt'), 'content');
-
-      const status = await service.getStatus();
-
-      expect(status.clean).toBe(false);
-      expect(status.untracked).toContain('new-file.txt');
-    });
-
-    test('detects modified files', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      writeFileSync(join(testDir, 'file.txt'), 'original');
-      await service.commitChanges('Add file');
-
-      writeFileSync(join(testDir, 'file.txt'), 'modified');
-
-      const status = await service.getStatus();
-
-      expect(status.clean).toBe(false);
-      expect(status.modified).toContain('file.txt');
-    });
-
-    test('detects staged files', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      writeFileSync(join(testDir, 'file.txt'), 'content');
-
-      // Manually stage the file
-      execFileSync('git', ['add', 'file.txt'], { cwd: testDir });
-
-      const status = await service.getStatus();
-
-      expect(status.clean).toBe(false);
-      expect(status.staged).toContain('file.txt');
-    });
-  });
-
-  describe('mutex locking', () => {
-    test('serializes concurrent commit operations', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      // Start multiple concurrent commits
-      const commits = [];
-      for (let i = 0; i < 10; i++) {
-        commits.push(
-          (async () => {
-            writeFileSync(join(testDir, `file${i}.txt`), `content ${i}`);
-            await service.commitChanges(`Add file ${i}`);
-          })(),
-        );
-      }
-
-      await Promise.all(commits);
-
-      // All commits should have succeeded
-      const log = execFileSync('git', ['log', '--oneline'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      });
-
-      for (let i = 0; i < 10; i++) {
-        expect(log).toContain(`Add file ${i}`);
-      }
-
-      // Count commits (excluding initial commit)
-      const commitCount = log.trim().split('\n').length;
-      expect(commitCount).toBe(11); // 10 + 1 initial
-    });
-
-    test('serializes concurrent status checks', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      // Start multiple concurrent status checks
-      const checks = [];
-      for (let i = 0; i < 20; i++) {
-        checks.push(service.getStatus());
-      }
-
-      const results = await Promise.all(checks);
-
-      // All should succeed and return consistent results
-      for (const status of results) {
-        expect(status).toBeDefined();
-        expect(status.clean).toBe(true);
-      }
-    });
-  });
-
-  describe('getWorkspaceGitService singleton', () => {
-    test('returns same instance for same workspace', () => {
-      const service1 = getWorkspaceGitService(testDir);
-      const service2 = getWorkspaceGitService(testDir);
-
-      expect(service1).toBe(service2);
-    });
-
-    test('returns different instances for different workspaces', () => {
-      const testDir2 = join(tmpdir(), `vellum-test-${Date.now()}-other`);
-      mkdirSync(testDir2, { recursive: true });
-
-      try {
-        const service1 = getWorkspaceGitService(testDir);
-        const service2 = getWorkspaceGitService(testDir2);
-
-        expect(service1).not.toBe(service2);
-        expect(service1.getWorkspaceDir()).toBe(testDir);
-        expect(service2.getWorkspaceDir()).toBe(testDir2);
-      } finally {
-        rmSync(testDir2, { recursive: true, force: true });
-      }
-    });
-  });
-
-  describe('error handling', () => {
-    test('handles invalid workspace directory', async () => {
-      const invalidDir = '/nonexistent/path/that/does/not/exist';
-      const service = new WorkspaceGitService(invalidDir);
-
-      await expect(service.ensureInitialized()).rejects.toThrow();
-    });
-
-    test('failed initialization can be retried', async () => {
-      // Create a service pointing to a directory that doesn't exist yet
-      const retryDir = join(tmpdir(), `vellum-retry-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-      const service = new WorkspaceGitService(retryDir);
-
-      // First attempt: directory doesn't exist, should fail
-      await expect(service.ensureInitialized()).rejects.toThrow();
-
-      // Create the directory so the retry can succeed
-      mkdirSync(retryDir, { recursive: true });
-
-      try {
-        // Second attempt: directory now exists, should succeed because
-        // the .catch handler cleared initPromise after the first failure
-        await service.ensureInitialized();
-        expect(service.isInitialized()).toBe(true);
-
-        // Verify the repo was actually initialized
-        const log = execFileSync('git', ['log', '--oneline'], {
-          cwd: retryDir,
-          encoding: 'utf-8',
-        });
-        expect(log).toContain('Initial commit');
-      } finally {
-        rmSync(retryDir, { recursive: true, force: true });
-      }
-    });
-
-    test('continues to work after failed operation', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      // Try to commit without any changes and without allow-empty
-      // (This should succeed with --allow-empty, but let's test recovery)
-      writeFileSync(join(testDir, 'test.txt'), 'content');
-      await service.commitChanges('Valid commit');
-
-      // Service should still work
-      const status = await service.getStatus();
-      expect(status).toBeDefined();
-    });
-  });
-
-  describe('existing repo normalization', () => {
-    test('existing repo on feature branch auto-switches to main on init', async () => {
-      // Set up a pre-existing git repo on a feature branch
-      execFileSync('git', ['init', '-b', 'main'], { cwd: testDir });
-      execFileSync('git', ['config', 'user.name', 'Test'], { cwd: testDir });
-      execFileSync('git', ['config', 'user.email', 'test@test.com'], { cwd: testDir });
-      writeFileSync(join(testDir, 'file.txt'), 'content');
-      execFileSync('git', ['add', '-A'], { cwd: testDir });
-      execFileSync('git', ['commit', '-m', 'init'], { cwd: testDir });
-      execFileSync('git', ['checkout', '-b', 'feature-branch'], { cwd: testDir });
-
-      // Verify we're on feature-branch
-      const branchBefore = execFileSync('git', ['symbolic-ref', '--short', 'HEAD'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      }).trim();
-      expect(branchBefore).toBe('feature-branch');
-
-      // Initialize the service — should auto-switch to main
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      const branchAfter = execFileSync('git', ['symbolic-ref', '--short', 'HEAD'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      }).trim();
-      expect(branchAfter).toBe('main');
-    });
-
-    test('detached HEAD recovers to main on init', async () => {
-      // Set up a pre-existing git repo then detach HEAD
-      execFileSync('git', ['init', '-b', 'main'], { cwd: testDir });
-      execFileSync('git', ['config', 'user.name', 'Test'], { cwd: testDir });
-      execFileSync('git', ['config', 'user.email', 'test@test.com'], { cwd: testDir });
-      writeFileSync(join(testDir, 'file.txt'), 'content');
-      execFileSync('git', ['add', '-A'], { cwd: testDir });
-      execFileSync('git', ['commit', '-m', 'init'], { cwd: testDir });
-      // Detach HEAD by checking out the commit hash
-      const commitHash = execFileSync('git', ['rev-parse', 'HEAD'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      }).trim();
-      execFileSync('git', ['checkout', commitHash], { cwd: testDir });
-
-      // Verify we're in detached HEAD
-      let isDetached = false;
-      try {
-        execFileSync('git', ['symbolic-ref', '--short', 'HEAD'], { cwd: testDir });
-      } catch {
-        isDetached = true;
-      }
-      expect(isDetached).toBe(true);
-
-      // Initialize the service — should recover to main
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      const branchAfter = execFileSync('git', ['symbolic-ref', '--short', 'HEAD'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      }).trim();
-      expect(branchAfter).toBe('main');
-    });
-
-    test('existing repo on feature branch with dirty working tree switches to main', async () => {
-      // Set up a pre-existing git repo on a feature branch with uncommitted changes.
-      // This exercises the --discard-changes fallback in ensureOnMainLocked().
-      execFileSync('git', ['init', '-b', 'main'], { cwd: testDir });
-      execFileSync('git', ['config', 'user.name', 'Test'], { cwd: testDir });
-      execFileSync('git', ['config', 'user.email', 'test@test.com'], { cwd: testDir });
-      writeFileSync(join(testDir, 'file.txt'), 'original content');
-      execFileSync('git', ['add', '-A'], { cwd: testDir });
-      execFileSync('git', ['commit', '-m', 'init'], { cwd: testDir });
-      execFileSync('git', ['checkout', '-b', 'feature-branch'], { cwd: testDir });
-
-      // Create uncommitted changes that would block a normal `git switch main`
-      writeFileSync(join(testDir, 'file.txt'), 'modified on feature branch');
-
-      // Verify we're on feature-branch with dirty working tree
-      const branchBefore = execFileSync('git', ['symbolic-ref', '--short', 'HEAD'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      }).trim();
-      expect(branchBefore).toBe('feature-branch');
-      const statusBefore = execFileSync('git', ['status', '--porcelain'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      }).trim();
-      expect(statusBefore).toContain('file.txt');
-
-      // Initialize the service — should auto-switch to main despite dirty tree
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      const branchAfter = execFileSync('git', ['symbolic-ref', '--short', 'HEAD'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      }).trim();
-      expect(branchAfter).toBe('main');
-    });
-
-    test('existing repo gets .gitignore rules appended on init', async () => {
-      // Set up a pre-existing git repo without our gitignore rules
-      execFileSync('git', ['init', '-b', 'main'], { cwd: testDir });
-      execFileSync('git', ['config', 'user.name', 'Test'], { cwd: testDir });
-      execFileSync('git', ['config', 'user.email', 'test@test.com'], { cwd: testDir });
-      writeFileSync(join(testDir, '.gitignore'), 'node_modules/\n');
-      writeFileSync(join(testDir, 'file.txt'), 'content');
-      execFileSync('git', ['add', '-A'], { cwd: testDir });
-      execFileSync('git', ['commit', '-m', 'init'], { cwd: testDir });
-
-      // Verify .gitignore does NOT have our rules yet
-      const contentBefore = readFileSync(join(testDir, '.gitignore'), 'utf-8');
-      expect(contentBefore).not.toContain('data/db/');
-      expect(contentBefore).not.toContain('vellum.sock');
-
-      // Initialize the service — should append rules
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      const contentAfter = readFileSync(join(testDir, '.gitignore'), 'utf-8');
-      expect(contentAfter).toContain('node_modules/');  // original rule preserved
-      expect(contentAfter).toContain('data/db/');
-      expect(contentAfter).toContain('data/qdrant/');
-      expect(contentAfter).toContain('data/ipc-blobs/');
-      expect(contentAfter).toContain('*.log');
-      expect(contentAfter).toContain('vellum.sock');
-      expect(contentAfter).toContain('session-token');
-    });
-
-    test('existing repo with old data/ rule gets it replaced with selective rules', async () => {
-      // Set up a pre-existing git repo with the OLD broad data/ rule
-      execFileSync('git', ['init', '-b', 'main'], { cwd: testDir });
-      execFileSync('git', ['config', 'user.name', 'Test'], { cwd: testDir });
-      execFileSync('git', ['config', 'user.email', 'test@test.com'], { cwd: testDir });
-      const oldGitignore = '# Runtime state - excluded from git tracking\ndata/\nlogs/\n*.log\n*.sock\n*.pid\n*.sqlite\n*.sqlite-journal\n*.sqlite-wal\n*.sqlite-shm\n*.db\n*.db-journal\n*.db-wal\n*.db-shm\nvellum.sock\nvellum.pid\nsession-token\nhttp-token\n';
-      writeFileSync(join(testDir, '.gitignore'), oldGitignore);
-      writeFileSync(join(testDir, 'file.txt'), 'content');
-      execFileSync('git', ['add', '-A'], { cwd: testDir });
-      execFileSync('git', ['commit', '-m', 'init'], { cwd: testDir });
-
-      // Verify the old broad rule is present
-      const contentBefore = readFileSync(join(testDir, '.gitignore'), 'utf-8');
-      expect(contentBefore).toContain('data/\n');
-
-      // Initialize the service — should migrate the gitignore
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      const contentAfter = readFileSync(join(testDir, '.gitignore'), 'utf-8');
-
-      // Old broad rule should be removed
-      expect(contentAfter).not.toMatch(/^data\/$/m);
-
-      // New selective rules should be present
-      expect(contentAfter).toContain('data/db/');
-      expect(contentAfter).toContain('data/qdrant/');
-      expect(contentAfter).toContain('data/ipc-blobs/');
-
-      // Other existing rules should be preserved
-      expect(contentAfter).toContain('logs/');
-      expect(contentAfter).toContain('*.log');
-      expect(contentAfter).toContain('vellum.sock');
-    });
-
-    test('existing repo gets local identity set on init', async () => {
-      // Set up a pre-existing git repo with a different identity
-      execFileSync('git', ['init', '-b', 'main'], { cwd: testDir });
-      execFileSync('git', ['config', 'user.name', 'Old Name'], { cwd: testDir });
-      execFileSync('git', ['config', 'user.email', 'old@example.com'], { cwd: testDir });
-      writeFileSync(join(testDir, 'file.txt'), 'content');
-      execFileSync('git', ['add', '-A'], { cwd: testDir });
-      execFileSync('git', ['commit', '-m', 'init'], { cwd: testDir });
-
-      // Initialize the service — should set identity
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      const userName = execFileSync('git', ['config', 'user.name'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      }).trim();
-      const userEmail = execFileSync('git', ['config', 'user.email'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      }).trim();
-
-      expect(userName).toBe('Vellum Assistant');
-      expect(userEmail).toBe('assistant@vellum.ai');
-    });
-
-    test('existing repo with correct config is idempotent', async () => {
-      // Set up a repo that already has everything configured correctly
-      execFileSync('git', ['init', '-b', 'main'], { cwd: testDir });
-      execFileSync('git', ['config', 'user.name', 'Vellum Assistant'], { cwd: testDir });
-      execFileSync('git', ['config', 'user.email', 'assistant@vellum.ai'], { cwd: testDir });
-      const gitignoreContent = '# Runtime state - excluded from git tracking\ndata/db/\ndata/qdrant/\ndata/ipc-blobs/\nlogs/\n*.log\n*.sock\n*.pid\n*.sqlite\n*.sqlite-journal\n*.sqlite-wal\n*.sqlite-shm\n*.db\n*.db-journal\n*.db-wal\n*.db-shm\nvellum.sock\nvellum.pid\nsession-token\nhttp-token\n';
-      writeFileSync(join(testDir, '.gitignore'), gitignoreContent);
-      writeFileSync(join(testDir, 'file.txt'), 'content');
-      execFileSync('git', ['add', '-A'], { cwd: testDir });
-      execFileSync('git', ['commit', '-m', 'init'], { cwd: testDir });
-
-      const gitignoreBefore = readFileSync(join(testDir, '.gitignore'), 'utf-8');
-
-      // Initialize the service — should be a no-op
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      // Verify nothing changed
-      const gitignoreAfter = readFileSync(join(testDir, '.gitignore'), 'utf-8');
-      expect(gitignoreAfter).toBe(gitignoreBefore);
-
-      const userName = execFileSync('git', ['config', 'user.name'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      }).trim();
-      expect(userName).toBe('Vellum Assistant');
-
-      const branch = execFileSync('git', ['symbolic-ref', '--short', 'HEAD'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      }).trim();
-      expect(branch).toBe('main');
-
-      // No errors, no duplicate rules
-      const ruleCount = (gitignoreAfter.match(/data\/db\//g) || []).length;
-      expect(ruleCount).toBe(1);
-    });
-  });
-
-  describe('gitignore behavior', () => {
-    test('ignores data/db/ but tracks other data/ subdirectories', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      // Create files in ignored data subdirectories
-      mkdirSync(join(testDir, 'data', 'db'), { recursive: true });
-      writeFileSync(join(testDir, 'data', 'db', 'conversations.sqlite'), 'db content');
-      mkdirSync(join(testDir, 'data', 'qdrant'), { recursive: true });
-      writeFileSync(join(testDir, 'data', 'qdrant', 'index.bin'), 'qdrant content');
-      mkdirSync(join(testDir, 'data', 'ipc-blobs'), { recursive: true });
-      writeFileSync(join(testDir, 'data', 'ipc-blobs', 'blob1'), 'ipc content');
-
-      // Create files in tracked data subdirectories
-      mkdirSync(join(testDir, 'data', 'memory'), { recursive: true });
-      writeFileSync(join(testDir, 'data', 'memory', 'index.json'), '{}');
-      mkdirSync(join(testDir, 'data', 'apps'), { recursive: true });
-      writeFileSync(join(testDir, 'data', 'apps', 'state.json'), '{}');
-
-      // Commit all changes, then verify what was included
-      await service.commitChanges('test commit');
-
-      const committedFiles = execFileSync(
-        'git', ['diff', '--name-only', 'HEAD~1', 'HEAD'],
-        { cwd: testDir, encoding: 'utf-8' },
-      ).trim();
-
-      // Ignored subdirectories should NOT be in the commit
-      expect(committedFiles).not.toContain('data/db/');
-      expect(committedFiles).not.toContain('data/qdrant/');
-      expect(committedFiles).not.toContain('data/ipc-blobs/');
-
-      // Tracked subdirectories SHOULD be in the commit
-      expect(committedFiles).toContain('data/memory/index.json');
-      expect(committedFiles).toContain('data/apps/state.json');
-    });
-
-    test('respects .gitignore for log files', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      writeFileSync(join(testDir, 'test.log'), 'log content');
-
-      const status = await service.getStatus();
-
-      // .log files should be ignored
-      expect(status.untracked).not.toContain('test.log');
-    });
-
-    test('tracks non-ignored files', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      writeFileSync(join(testDir, 'config.json'), '{}');
-      writeFileSync(join(testDir, 'README.md'), '# Test');
-
-      const status = await service.getStatus();
-
-      expect(status.untracked).toContain('config.json');
-      expect(status.untracked).toContain('README.md');
-    });
-  });
-
-  describe('deadline-aware commitIfDirty', () => {
-    test('deadline expired before lock acquisition skips commit quickly', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      // Create a file so the workspace is dirty
-      writeFileSync(join(testDir, 'test.txt'), 'content');
-
-      // Use a deadline that has already passed
-      const pastDeadline = Date.now() - 1000;
-      const result = await service.commitIfDirty(
-        () => ({ message: 'should not commit' }),
-        { deadlineMs: pastDeadline },
-      );
-
-      expect(result.committed).toBe(false);
-
-      // File should still be uncommitted
-      const status = await service.getStatus();
-      expect(status.clean).toBe(false);
-      expect(status.untracked).toContain('test.txt');
-    });
-
-    test('deadline far in the future allows commit to proceed', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      writeFileSync(join(testDir, 'test.txt'), 'content');
-
-      // Use a deadline far in the future
-      const futureDeadline = Date.now() + 60_000;
-      const result = await service.commitIfDirty(
-        () => ({ message: 'deadline commit' }),
-        { deadlineMs: futureDeadline },
-      );
-
-      expect(result.committed).toBe(true);
-
-      // Verify the commit was actually created
-      const log = execFileSync('git', ['log', '--oneline', '-n', '1'], {
-        cwd: testDir,
-        encoding: 'utf-8',
-      });
-      expect(log).toContain('deadline commit');
-    });
-
-    test('no deadline option allows commit as normal', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      writeFileSync(join(testDir, 'test.txt'), 'content');
-
-      // No deadline option at all
-      const result = await service.commitIfDirty(
-        () => ({ message: 'no deadline commit' }),
-      );
-
-      expect(result.committed).toBe(true);
-    });
-  });
-
-  describe('breaker re-check under lock', () => {
-    test('queued call that acquires lock after breaker opens skips commit', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      writeFileSync(join(testDir, 'test.txt'), 'content');
-
-      // Simulate a breaker that opened between the pre-lock check and lock acquisition.
-      // We do this by:
-      // 1. Starting a commitIfDirty call (which passes the pre-lock breaker check)
-      // 2. Forcing the breaker open while the call is in progress
-
-      // First, force the breaker open by setting internal state directly.
-      // Since commitIfDirty re-checks the breaker after acquiring the lock,
-      // a call that passes the pre-lock check but finds the breaker open
-      // after acquiring the lock should bail out.
-      const internal = service as unknown as {
-        consecutiveFailures: number;
-        nextAllowedAttemptMs: number;
-      };
-      internal.consecutiveFailures = 5;
-      internal.nextAllowedAttemptMs = Date.now() + 60_000; // far in the future
-
-      // With breaker open, commitIfDirty should skip (pre-lock check)
-      const result = await service.commitIfDirty(
-        () => ({ message: 'should not commit' }),
-      );
-      expect(result.committed).toBe(false);
-
-      // Reset breaker
-      _resetBreaker(service);
-
-      // Now the commit should proceed normally
-      const result2 = await service.commitIfDirty(
-        () => ({ message: 'after breaker reset' }),
-      );
-      expect(result2.committed).toBe(true);
-    });
-
-    test('breaker early return inside lock does not reset breaker via recordSuccess', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      writeFileSync(join(testDir, 'test.txt'), 'content');
-
-      // Force breaker open with known failure count
-      const internal = service as unknown as {
-        consecutiveFailures: number;
-        nextAllowedAttemptMs: number;
-      };
-      internal.consecutiveFailures = 5;
-      internal.nextAllowedAttemptMs = Date.now() + 60_000;
-
-      // Pre-lock check catches the open breaker and returns early.
-      // Verify that consecutiveFailures is NOT reset to 0.
-      const result = await service.commitIfDirty(
-        () => ({ message: 'should not commit' }),
-      );
-      expect(result.committed).toBe(false);
-      expect(_getConsecutiveFailures(service)).toBe(5);
-    });
-
-    test('deadline early return inside lock does not reset breaker via recordSuccess', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      writeFileSync(join(testDir, 'test.txt'), 'content');
-
-      // Set up prior failures (breaker closed but failures recorded)
-      const internal = service as unknown as {
-        consecutiveFailures: number;
-        nextAllowedAttemptMs: number;
-      };
-      internal.consecutiveFailures = 3;
-      // Set nextAllowedAttemptMs in the past so the breaker check passes
-      // but consecutiveFailures is non-zero
-      internal.nextAllowedAttemptMs = Date.now() - 1000;
-
-      // Use a deadline that has already passed — this triggers the pre-lock
-      // deadline fast-path. consecutiveFailures should NOT be reset.
-      const result = await service.commitIfDirty(
-        () => ({ message: 'should not commit' }),
-        { deadlineMs: Date.now() - 1000 },
-      );
-      expect(result.committed).toBe(false);
-      expect(_getConsecutiveFailures(service)).toBe(3);
-    });
-
-    test('successful git operation after failures resets breaker', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      writeFileSync(join(testDir, 'test.txt'), 'content');
-
-      // Set up prior failures with breaker closed (backoff expired)
-      const internal = service as unknown as {
-        consecutiveFailures: number;
-        nextAllowedAttemptMs: number;
-      };
-      internal.consecutiveFailures = 3;
-      internal.nextAllowedAttemptMs = Date.now() - 1000;
-
-      // Commit should succeed and reset the breaker
-      const result = await service.commitIfDirty(
-        () => ({ message: 'recovery commit' }),
-      );
-      expect(result.committed).toBe(true);
-      expect(_getConsecutiveFailures(service)).toBe(0);
-    });
-
-    test('bypassBreaker ignores breaker state', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      writeFileSync(join(testDir, 'test.txt'), 'content');
-
-      // Force breaker open
-      const internal = service as unknown as {
-        consecutiveFailures: number;
-        nextAllowedAttemptMs: number;
-      };
-      internal.consecutiveFailures = 5;
-      internal.nextAllowedAttemptMs = Date.now() + 60_000;
-
-      // With bypassBreaker, commit should succeed despite open breaker
-      const result = await service.commitIfDirty(
-        () => ({ message: 'bypass breaker commit' }),
-        { bypassBreaker: true },
-      );
-      expect(result.committed).toBe(true);
-    });
-  });
-
-  describe('commitIfDirty diff error handling', () => {
-    test('non-1 exit code from git diff --cached --quiet is treated as an error', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      // Create a file so the workspace is dirty and commitIfDirty will
-      // proceed past the "clean" early-return.
-      writeFileSync(join(testDir, 'test.txt'), 'content');
-
-      // Access the private execGit method and wrap it so that
-      // 'git diff --cached --quiet' throws with exit code 2 (simulating
-      // a real git error rather than the expected exit code 1 for
-      // "staged changes exist").
-      const proto = Object.getPrototypeOf(service);
-      const originalExecGit = proto.execGit;
-      proto.execGit = async function (this: unknown, args: string[]) {
-        if (args[0] === 'diff' && args[1] === '--cached' && args[2] === '--quiet') {
-          const err = new Error(
-            'Git command failed: git diff --cached --quiet\nError: simulated error\nStderr: ',
-          ) as Error & { code?: number };
-          err.code = 2;
-          throw err;
-        }
-        return originalExecGit.call(this, args);
-      };
-
-      try {
-        // commitIfDirty should propagate the error (not treat code 2 as
-        // "staged changes exist")
-        await expect(
-          service.commitIfDirty(() => ({ message: 'should not commit' })),
-        ).rejects.toThrow();
-      } finally {
-        // Restore the original method
-        proto.execGit = originalExecGit;
-      }
-    });
-  });
-
-  describe('init circuit breaker', () => {
-    test('init breaker opens after consecutive failures', async () => {
-      // Use a directory that doesn't exist so init fails
-      const badDir = '/nonexistent/path/that/does/not/exist';
-      const service = new WorkspaceGitService(badDir);
-
-      // First failure — breaker does NOT open (requires 2+ failures)
-      await expect(service.ensureInitialized()).rejects.toThrow();
-      expect(_getInitConsecutiveFailures(service)).toBe(1);
-
-      // Second failure — expire the backoff window from the first failure
-      // so the attempt actually runs (not blocked by breaker).
-      const internal = service as unknown as {
-        initNextAllowedAttemptMs: number;
-      };
-      internal.initNextAllowedAttemptMs = Date.now() - 1;
-
-      await expect(service.ensureInitialized()).rejects.toThrow();
-      expect(_getInitConsecutiveFailures(service)).toBe(2);
-
-      // Third attempt within the backoff window — breaker is now open
-      // (2+ consecutive failures) so the attempt is skipped.
-      await expect(service.ensureInitialized()).rejects.toThrow(
-        'Init circuit breaker open: backing off after repeated failures',
-      );
-      // Failure count should NOT increase (the breaker prevented the attempt)
-      expect(_getInitConsecutiveFailures(service)).toBe(2);
-    });
-
-    test('init breaker skips init attempts during backoff window', async () => {
-      const service = new WorkspaceGitService(testDir);
-
-      // Force the init breaker open
-      const internal = service as unknown as {
-        initConsecutiveFailures: number;
-        initNextAllowedAttemptMs: number;
-      };
-      internal.initConsecutiveFailures = 3;
-      internal.initNextAllowedAttemptMs = Date.now() + 60_000; // far in the future
-
-      // ensureInitialized should throw with circuit breaker message
-      await expect(service.ensureInitialized()).rejects.toThrow(
-        'Init circuit breaker open: backing off after repeated failures',
-      );
-
-      // Failure count should NOT increase (the breaker prevented the attempt)
-      expect(_getInitConsecutiveFailures(service)).toBe(3);
-    });
-
-    test('init breaker resets on success', async () => {
-      const service = new WorkspaceGitService(testDir);
-
-      // Simulate prior init failures
-      const internal = service as unknown as {
-        initConsecutiveFailures: number;
-        initNextAllowedAttemptMs: number;
-      };
-      internal.initConsecutiveFailures = 3;
-      // Set backoff in the past so the breaker is closed and allows retry
-      internal.initNextAllowedAttemptMs = Date.now() - 1;
-
-      // This should succeed and reset the init breaker
-      await service.ensureInitialized();
-
-      expect(_getInitConsecutiveFailures(service)).toBe(0);
-      expect(service.isInitialized()).toBe(true);
-    });
-
-    test('init breaker allows retry after backoff window expires', async () => {
-      const service = new WorkspaceGitService(testDir);
-
-      // Simulate prior init failures with expired backoff
-      const internal = service as unknown as {
-        initConsecutiveFailures: number;
-        initNextAllowedAttemptMs: number;
-      };
-      internal.initConsecutiveFailures = 5;
-      internal.initNextAllowedAttemptMs = Date.now() - 1; // expired
-
-      // Breaker should be closed (backoff expired), allowing init to proceed
-      await service.ensureInitialized();
-
-      expect(_getInitConsecutiveFailures(service)).toBe(0);
-      expect(service.isInitialized()).toBe(true);
-    });
-
-    test('init breaker is independent from commit breaker', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-
-      // Force commit breaker open
-      const internal = service as unknown as {
-        consecutiveFailures: number;
-        nextAllowedAttemptMs: number;
-      };
-      internal.consecutiveFailures = 5;
-      internal.nextAllowedAttemptMs = Date.now() + 60_000;
-
-      // Init breaker should still be clean
-      expect(_getInitConsecutiveFailures(service)).toBe(0);
-
-      // Commit breaker should be open
-      expect(_getConsecutiveFailures(service)).toBe(5);
-
-      // Reset commit breaker
-      _resetBreaker(service);
-
-      // Force init breaker open
-      const internal2 = service as unknown as {
-        initConsecutiveFailures: number;
-        initNextAllowedAttemptMs: number;
-      };
-      internal2.initConsecutiveFailures = 3;
-      internal2.initNextAllowedAttemptMs = Date.now() + 60_000;
-
-      // Commit breaker should be clean
-      expect(_getConsecutiveFailures(service)).toBe(0);
-
-      // Init breaker should be open
-      expect(_getInitConsecutiveFailures(service)).toBe(3);
-
-      // Reset init breaker
-      _resetInitBreaker(service);
-      expect(_getInitConsecutiveFailures(service)).toBe(0);
-    });
-
-    test('already initialized service bypasses init breaker check', async () => {
-      const service = new WorkspaceGitService(testDir);
-      await service.ensureInitialized();
-      expect(service.isInitialized()).toBe(true);
-
-      // Force init breaker open
-      const internal = service as unknown as {
-        initConsecutiveFailures: number;
-        initNextAllowedAttemptMs: number;
-      };
-      internal.initConsecutiveFailures = 5;
-      internal.initNextAllowedAttemptMs = Date.now() + 60_000;
-
-      // ensureInitialized should succeed via the fast path (already initialized)
-      // without hitting the breaker
-      await service.ensureInitialized();
-    });
-  });
-
-  describe('isDeadlineExpired helper', () => {
-    test('returns false when deadlineMs is undefined', () => {
-      expect(isDeadlineExpired(undefined)).toBe(false);
-    });
-
-    test('returns false when deadline is in the future', () => {
-      expect(isDeadlineExpired(Date.now() + 60_000)).toBe(false);
-    });
-
-    test('returns true when deadline is in the past', () => {
-      expect(isDeadlineExpired(Date.now() - 1000)).toBe(true);
-    });
-
-    test('returns true when deadline equals current time', () => {
-      const now = Date.now();
-      // Use a deadline slightly in the past to avoid timing flakes
-      expect(isDeadlineExpired(now - 1)).toBe(true);
-    });
-  });
-});