@vibescope/mcp-server 0.2.4 → 0.2.5

package/src/handlers/validation.test.ts

@@ -1,582 +1,582 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import {
-	getTasksAwaitingValidation,
-	claimValidation,
-	validateTask,
-} from './validation.js';
-import { ValidationError } from '../validators.js';
-import { createMockContext } from './__test-utils__.js';
-import { mockApiClient } from './__test-setup__.js';
-
-// ============================================================================
-// Test Constants
-// ============================================================================
-
-const VALID_UUID = '123e4567-e89b-12d3-a456-426614174000';
-
-// ============================================================================
-// getTasksAwaitingValidation Tests
-// ============================================================================
-
-describe('getTasksAwaitingValidation', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing project_id', async () => {
-		const ctx = createMockContext();
-
-		await expect(getTasksAwaitingValidation({}, ctx)).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid project_id UUID', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			getTasksAwaitingValidation({ project_id: 'invalid' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should return empty list when no tasks awaiting validation', async () => {
-		mockApiClient.getTasksAwaitingValidation.mockResolvedValue({
-			ok: true,
-			data: { tasks: [], count: 0 },
-		});
-		const ctx = createMockContext();
-
-		const result = await getTasksAwaitingValidation(
-			{ project_id: VALID_UUID },
-			ctx
-		);
-
-		expect(result.result).toHaveProperty('tasks');
-		expect((result.result as { tasks: unknown[] }).tasks).toEqual([]);
-	});
-
-	it('should return tasks with review status info', async () => {
-		const mockTasks = [
-			{
-				id: 'task-1',
-				title: 'Implement feature A',
-				completed_at: '2025-01-14T10:00:00Z',
-				completed_by_session_id: 'other-session',
-				being_reviewed: false,
-				review_minutes: null,
-			},
-			{
-				id: 'task-2',
-				title: 'Implement feature B',
-				completed_at: '2025-01-14T11:00:00Z',
-				completed_by_session_id: 'other-session',
-				being_reviewed: true,
-				review_minutes: 5,
-			},
-		];
-
-		mockApiClient.getTasksAwaitingValidation.mockResolvedValue({
-			ok: true,
-			data: {
-				tasks: mockTasks,
-				count: 2,
-				hint: 'Use claim_validation to claim a task for review',
-			},
-		});
-		const ctx = createMockContext();
-
-		const result = await getTasksAwaitingValidation(
-			{ project_id: VALID_UUID },
-			ctx
-		);
-
-		const tasks = (result.result as { tasks: Array<{ being_reviewed: boolean; review_minutes: number | null }> }).tasks;
-		expect(tasks).toHaveLength(2);
-
-		// First task not being reviewed
-		expect(tasks[0].being_reviewed).toBe(false);
-		expect(tasks[0].review_minutes).toBeNull();
-
-		// Second task being reviewed for ~5 minutes
-		expect(tasks[1].being_reviewed).toBe(true);
-		expect(tasks[1].review_minutes).toBe(5);
-
-		// Should have hint when tasks are present
-		expect((result.result as { hint?: string }).hint).toContain('claim_validation');
-	});
-
-	it('should call API client with correct project_id', async () => {
-		mockApiClient.getTasksAwaitingValidation.mockResolvedValue({
-			ok: true,
-			data: { tasks: [], count: 0 },
-		});
-		const ctx = createMockContext();
-
-		await getTasksAwaitingValidation(
-			{ project_id: VALID_UUID },
-			ctx
-		);
-
-		expect(mockApiClient.getTasksAwaitingValidation).toHaveBeenCalledWith(VALID_UUID);
-	});
-
-	it('should return error when API call fails', async () => {
-		mockApiClient.getTasksAwaitingValidation.mockResolvedValue({
-			ok: false,
-			error: 'Failed to fetch tasks awaiting validation',
-		});
-		const ctx = createMockContext();
-
-		const result = await getTasksAwaitingValidation({ project_id: VALID_UUID }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: 'Failed to fetch tasks awaiting validation',
-		});
-	});
-});
-
-// ============================================================================
-// claimValidation Tests
-// ============================================================================
-
-describe('claimValidation', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing task_id', async () => {
-		const ctx = createMockContext();
-
-		await expect(claimValidation({}, ctx)).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid task_id UUID', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			claimValidation({ task_id: 'not-a-uuid' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should return error when task not found', async () => {
-		mockApiClient.claimValidation.mockResolvedValue({
-			ok: false,
-			error: 'Task not found',
-		});
-		const ctx = createMockContext();
-
-		const result = await claimValidation({ task_id: VALID_UUID }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: 'Task not found',
-		});
-	});
-
-	it('should return error when task is not completed', async () => {
-		mockApiClient.claimValidation.mockResolvedValue({
-			ok: false,
-			error: 'Can only claim completed tasks for review',
-		});
-		const ctx = createMockContext();
-
-		const result = await claimValidation({ task_id: VALID_UUID }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: 'Can only claim completed tasks for review',
-		});
-	});
-
-	it('should return error when task is already validated', async () => {
-		mockApiClient.claimValidation.mockResolvedValue({
-			ok: false,
-			error: 'Task has already been validated',
-		});
-		const ctx = createMockContext();
-
-		const result = await claimValidation({ task_id: VALID_UUID }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: 'Task has already been validated',
-		});
-	});
-
-	it('should return error when task is being reviewed by another agent', async () => {
-		mockApiClient.claimValidation.mockResolvedValue({
-			ok: false,
-			error: 'Task is already being reviewed by another agent',
-		});
-		const ctx = createMockContext({ sessionId: 'session-123' });
-
-		const result = await claimValidation({ task_id: VALID_UUID }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: 'Task is already being reviewed by another agent',
-		});
-	});
-
-	it('should allow same agent to re-claim their own review', async () => {
-		mockApiClient.claimValidation.mockResolvedValue({
-			ok: true,
-			data: {
-				success: true,
-				task_id: VALID_UUID,
-				title: 'Test Task',
-				message: 'Re-claimed task for review',
-			},
-		});
-		const ctx = createMockContext({ sessionId: 'session-123' });
-
-		const result = await claimValidation(
-			{ task_id: VALID_UUID },
-			ctx
-		);
-
-		expect(result.result).toMatchObject({
-			success: true,
-			task_id: VALID_UUID,
-			title: 'Test Task',
-		});
-	});
-
-	it('should claim task successfully', async () => {
-		mockApiClient.claimValidation.mockResolvedValue({
-			ok: true,
-			data: {
-				success: true,
-				task_id: VALID_UUID,
-				title: 'Test Task',
-				message: 'Task claimed for review. Dashboard updated.',
-				next_step: 'Run tests and verify implementation. Call validate_task when done.',
-			},
-		});
-		const ctx = createMockContext();
-
-		const result = await claimValidation(
-			{ task_id: VALID_UUID },
-			ctx
-		);
-
-		expect(result.result).toMatchObject({
-			success: true,
-			task_id: VALID_UUID,
-			title: 'Test Task',
-			message: expect.stringContaining('Dashboard'),
-		});
-		expect((result.result as { next_step: string }).next_step).toContain('validate_task');
-	});
-
-	it('should call API client with session_id', async () => {
-		mockApiClient.claimValidation.mockResolvedValue({
-			ok: true,
-			data: {
-				success: true,
-				task_id: VALID_UUID,
-				title: 'Test Task',
-			},
-		});
-		const ctx = createMockContext({ sessionId: 'reviewer-session' });
-
-		await claimValidation({ task_id: VALID_UUID }, ctx);
-
-		expect(mockApiClient.claimValidation).toHaveBeenCalledWith(
-			VALID_UUID,
-			'reviewer-session'
-		);
-	});
-
-	it('should return error when claim fails', async () => {
-		mockApiClient.claimValidation.mockResolvedValue({
-			ok: false,
-			error: 'Failed to claim task for validation',
-		});
-		const ctx = createMockContext();
-
-		const result = await claimValidation({ task_id: VALID_UUID }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: 'Failed to claim task for validation',
-		});
-	});
-});
-
-// ============================================================================
-// validateTask Tests
-// ============================================================================
-
-describe('validateTask', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing task_id', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			validateTask({ approved: true }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid task_id UUID', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			validateTask({ task_id: 'invalid', approved: true }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error when approved is missing', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			validateTask({ task_id: VALID_UUID }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should return error when task not found', async () => {
-		mockApiClient.validateTask.mockResolvedValue({
-			ok: false,
-			error: 'Task not found',
-		});
-		const ctx = createMockContext();
-
-		const result = await validateTask({ task_id: VALID_UUID, approved: true }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: 'Task not found',
-		});
-	});
-
-	it('should return error when task is not completed', async () => {
-		mockApiClient.validateTask.mockResolvedValue({
-			ok: false,
-			error: 'Can only validate completed tasks',
-		});
-		const ctx = createMockContext();
-
-		const result = await validateTask({ task_id: VALID_UUID, approved: true }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: 'Can only validate completed tasks',
-		});
-	});
-
-	it('should return error when task already validated', async () => {
-		mockApiClient.validateTask.mockResolvedValue({
-			ok: false,
-			error: 'Task has already been validated',
-		});
-		const ctx = createMockContext();
-
-		const result = await validateTask({ task_id: VALID_UUID, approved: true }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: 'Task has already been validated',
-		});
-	});
-
-	describe('when approved', () => {
-		it('should mark task as validated', async () => {
-			mockApiClient.validateTask.mockResolvedValue({
-				ok: true,
-				data: {
-					success: true,
-					validated_task_id: VALID_UUID,
-					self_validated: false,
-				},
-			});
-			const ctx = createMockContext({ sessionId: 'validator-session' });
-
-			const result = await validateTask(
-				{ task_id: VALID_UUID, approved: true },
-				ctx
-			);
-
-			expect(result.result).toMatchObject({
-				success: true,
-				validated_task_id: VALID_UUID,
-				self_validated: false,
-			});
-		});
-
-		it('should detect self-validation', async () => {
-			mockApiClient.validateTask.mockResolvedValue({
-				ok: true,
-				data: {
-					success: true,
-					validated_task_id: VALID_UUID,
-					self_validated: true,
-				},
-			});
-			const ctx = createMockContext({ sessionId: 'session-123' });
-
-			const result = await validateTask(
-				{ task_id: VALID_UUID, approved: true },
-				ctx
-			);
-
-			expect(result.result).toMatchObject({
-				success: true,
-				self_validated: true,
-			});
-		});
-
-		it('should pass validation_notes to API', async () => {
-			mockApiClient.validateTask.mockResolvedValue({
-				ok: true,
-				data: {
-					success: true,
-					validated_task_id: VALID_UUID,
-					self_validated: false,
-				},
-			});
-			const ctx = createMockContext({ sessionId: 'validator-session' });
-
-			await validateTask(
-				{
-					task_id: VALID_UUID,
-					approved: true,
-					validation_notes: 'Looks good!',
-				},
-				ctx
-			);
-
-			expect(mockApiClient.validateTask).toHaveBeenCalledWith(
-				VALID_UUID,
-				{ approved: true, validation_notes: 'Looks good!' },
-				'validator-session'
-			);
-		});
-	});
-
-	describe('when rejected', () => {
-		it('should reopen task', async () => {
-			mockApiClient.validateTask.mockResolvedValue({
-				ok: true,
-				data: {
-					success: true,
-					reopened_task_id: VALID_UUID,
-				},
-			});
-			const ctx = createMockContext();
-
-			const result = await validateTask(
-				{ task_id: VALID_UUID, approved: false },
-				ctx
-			);
-
-			expect(result.result).toMatchObject({
-				success: true,
-				reopened_task_id: VALID_UUID,
-			});
-		});
-
-		it('should pass rejection notes to API', async () => {
-			mockApiClient.validateTask.mockResolvedValue({
-				ok: true,
-				data: {
-					success: true,
-					reopened_task_id: VALID_UUID,
-				},
-			});
-			const ctx = createMockContext();
-
-			await validateTask(
-				{
-					task_id: VALID_UUID,
-					approved: false,
-					validation_notes: 'Tests failing',
-				},
-				ctx
-			);
-
-			expect(mockApiClient.validateTask).toHaveBeenCalledWith(
-				VALID_UUID,
-				{ approved: false, validation_notes: 'Tests failing' },
-				'session-123'
-			);
-		});
-	});
-
-	it('should return error when validation fails on approval', async () => {
-		mockApiClient.validateTask.mockResolvedValue({
-			ok: false,
-			error: 'Failed to validate task',
-		});
-		const ctx = createMockContext();
-
-		const result = await validateTask({ task_id: VALID_UUID, approved: true }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: 'Failed to validate task',
-		});
-	});
-
-	it('should return error when validation fails on rejection', async () => {
-		mockApiClient.validateTask.mockResolvedValue({
-			ok: false,
-			error: 'Failed to validate task',
-		});
-		const ctx = createMockContext();
-
-		const result = await validateTask({ task_id: VALID_UUID, approved: false }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: 'Failed to validate task',
-		});
-	});
-
-	describe('PR requirement', () => {
-		it('should return error when PR is required but not present', async () => {
-			mockApiClient.validateTask.mockResolvedValue({
-				ok: false,
-				error: 'pr_required',
-				data: {
-					message: 'This project uses git-flow workflow which requires a Pull Request before validation approval.',
-					workflow: 'git-flow',
-				},
-			});
-			const ctx = createMockContext();
-
-			const result = await validateTask(
-				{ task_id: VALID_UUID, approved: true },
-				ctx
-			);
-
-			expect(result.result).toMatchObject({
-				error: 'pr_required',
-				workflow: 'git-flow',
-				action_required: expect.stringContaining('add_task_reference'),
-			});
-		});
-
-		it('should pass skip_pr_check to API', async () => {
-			mockApiClient.validateTask.mockResolvedValue({
-				ok: true,
-				data: {
-					success: true,
-					validated_task_id: VALID_UUID,
-					self_validated: false,
-				},
-			});
-			const ctx = createMockContext({ sessionId: 'validator-session' });
-
-			await validateTask(
-				{
-					task_id: VALID_UUID,
-					approved: true,
-					skip_pr_check: true,
-				},
-				ctx
-			);
-
-			expect(mockApiClient.validateTask).toHaveBeenCalledWith(
-				VALID_UUID,
-				{ approved: true, skip_pr_check: true },
-				'validator-session'
-			);
-		});
-	});
-});
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+	getTasksAwaitingValidation,
+	claimValidation,
+	validateTask,
+} from './validation.js';
+import { ValidationError } from '../validators.js';
+import { createMockContext } from './__test-utils__.js';
+import { mockApiClient } from './__test-setup__.js';
+
+// ============================================================================
+// Test Constants
+// ============================================================================
+
+const VALID_UUID = '123e4567-e89b-12d3-a456-426614174000';
+
+// ============================================================================
+// getTasksAwaitingValidation Tests
+// ============================================================================
+
+describe('getTasksAwaitingValidation', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(getTasksAwaitingValidation({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			getTasksAwaitingValidation({ project_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should return empty list when no tasks awaiting validation', async () => {
+		mockApiClient.getTasksAwaitingValidation.mockResolvedValue({
+			ok: true,
+			data: { tasks: [], count: 0 },
+		});
+		const ctx = createMockContext();
+
+		const result = await getTasksAwaitingValidation(
+			{ project_id: VALID_UUID },
+			ctx
+		);
+
+		expect(result.result).toHaveProperty('tasks');
+		expect((result.result as { tasks: unknown[] }).tasks).toEqual([]);
+	});
+
+	it('should return tasks with review status info', async () => {
+		const mockTasks = [
+			{
+				id: 'task-1',
+				title: 'Implement feature A',
+				completed_at: '2025-01-14T10:00:00Z',
+				completed_by_session_id: 'other-session',
+				being_reviewed: false,
+				review_minutes: null,
+			},
+			{
+				id: 'task-2',
+				title: 'Implement feature B',
+				completed_at: '2025-01-14T11:00:00Z',
+				completed_by_session_id: 'other-session',
+				being_reviewed: true,
+				review_minutes: 5,
+			},
+		];
+
+		mockApiClient.getTasksAwaitingValidation.mockResolvedValue({
+			ok: true,
+			data: {
+				tasks: mockTasks,
+				count: 2,
+				hint: 'Use claim_validation to claim a task for review',
+			},
+		});
+		const ctx = createMockContext();
+
+		const result = await getTasksAwaitingValidation(
+			{ project_id: VALID_UUID },
+			ctx
+		);
+
+		const tasks = (result.result as { tasks: Array<{ being_reviewed: boolean; review_minutes: number | null }> }).tasks;
+		expect(tasks).toHaveLength(2);
+
+		// First task not being reviewed
+		expect(tasks[0].being_reviewed).toBe(false);
+		expect(tasks[0].review_minutes).toBeNull();
+
+		// Second task being reviewed for ~5 minutes
+		expect(tasks[1].being_reviewed).toBe(true);
+		expect(tasks[1].review_minutes).toBe(5);
+
+		// Should have hint when tasks are present
+		expect((result.result as { hint?: string }).hint).toContain('claim_validation');
+	});
+
+	it('should call API client with correct project_id', async () => {
+		mockApiClient.getTasksAwaitingValidation.mockResolvedValue({
+			ok: true,
+			data: { tasks: [], count: 0 },
+		});
+		const ctx = createMockContext();
+
+		await getTasksAwaitingValidation(
+			{ project_id: VALID_UUID },
+			ctx
+		);
+
+		expect(mockApiClient.getTasksAwaitingValidation).toHaveBeenCalledWith(VALID_UUID);
+	});
+
+	it('should return error when API call fails', async () => {
+		mockApiClient.getTasksAwaitingValidation.mockResolvedValue({
+			ok: false,
+			error: 'Failed to fetch tasks awaiting validation',
+		});
+		const ctx = createMockContext();
+
+		const result = await getTasksAwaitingValidation({ project_id: VALID_UUID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Failed to fetch tasks awaiting validation',
+		});
+	});
+});
+
+// ============================================================================
+// claimValidation Tests
+// ============================================================================
+
+describe('claimValidation', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing task_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(claimValidation({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid task_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			claimValidation({ task_id: 'not-a-uuid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should return error when task not found', async () => {
+		mockApiClient.claimValidation.mockResolvedValue({
+			ok: false,
+			error: 'Task not found',
+		});
+		const ctx = createMockContext();
+
+		const result = await claimValidation({ task_id: VALID_UUID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Task not found',
+		});
+	});
+
+	it('should return error when task is not completed', async () => {
+		mockApiClient.claimValidation.mockResolvedValue({
+			ok: false,
+			error: 'Can only claim completed tasks for review',
+		});
+		const ctx = createMockContext();
+
+		const result = await claimValidation({ task_id: VALID_UUID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Can only claim completed tasks for review',
+		});
+	});
+
+	it('should return error when task is already validated', async () => {
+		mockApiClient.claimValidation.mockResolvedValue({
+			ok: false,
+			error: 'Task has already been validated',
+		});
+		const ctx = createMockContext();
+
+		const result = await claimValidation({ task_id: VALID_UUID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Task has already been validated',
+		});
+	});
+
+	it('should return error when task is being reviewed by another agent', async () => {
+		mockApiClient.claimValidation.mockResolvedValue({
+			ok: false,
+			error: 'Task is already being reviewed by another agent',
+		});
+		const ctx = createMockContext({ sessionId: 'session-123' });
+
+		const result = await claimValidation({ task_id: VALID_UUID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Task is already being reviewed by another agent',
+		});
+	});
+
+	it('should allow same agent to re-claim their own review', async () => {
+		mockApiClient.claimValidation.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				task_id: VALID_UUID,
+				title: 'Test Task',
+				message: 'Re-claimed task for review',
+			},
+		});
+		const ctx = createMockContext({ sessionId: 'session-123' });
+
+		const result = await claimValidation(
+			{ task_id: VALID_UUID },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			task_id: VALID_UUID,
+			title: 'Test Task',
+		});
+	});
+
+	it('should claim task successfully', async () => {
+		mockApiClient.claimValidation.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				task_id: VALID_UUID,
+				title: 'Test Task',
+				message: 'Task claimed for review. Dashboard updated.',
+				next_step: 'Run tests and verify implementation. Call validate_task when done.',
+			},
+		});
+		const ctx = createMockContext();
+
+		const result = await claimValidation(
+			{ task_id: VALID_UUID },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			task_id: VALID_UUID,
+			title: 'Test Task',
+			message: expect.stringContaining('Dashboard'),
+		});
+		expect((result.result as { next_step: string }).next_step).toContain('validate_task');
+	});
+
+	it('should call API client with session_id', async () => {
+		mockApiClient.claimValidation.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				task_id: VALID_UUID,
+				title: 'Test Task',
+			},
+		});
+		const ctx = createMockContext({ sessionId: 'reviewer-session' });
+
+		await claimValidation({ task_id: VALID_UUID }, ctx);
+
+		expect(mockApiClient.claimValidation).toHaveBeenCalledWith(
+			VALID_UUID,
+			'reviewer-session'
+		);
+	});
+
+	it('should return error when claim fails', async () => {
+		mockApiClient.claimValidation.mockResolvedValue({
+			ok: false,
+			error: 'Failed to claim task for validation',
+		});
+		const ctx = createMockContext();
+
+		const result = await claimValidation({ task_id: VALID_UUID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Failed to claim task for validation',
+		});
+	});
+});
+
+// ============================================================================
+// validateTask Tests
+// ============================================================================
+
+describe('validateTask', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing task_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			validateTask({ approved: true }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid task_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			validateTask({ task_id: 'invalid', approved: true }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error when approved is missing', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			validateTask({ task_id: VALID_UUID }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should return error when task not found', async () => {
+		mockApiClient.validateTask.mockResolvedValue({
+			ok: false,
+			error: 'Task not found',
+		});
+		const ctx = createMockContext();
+
+		const result = await validateTask({ task_id: VALID_UUID, approved: true }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Task not found',
+		});
+	});
+
+	it('should return error when task is not completed', async () => {
+		mockApiClient.validateTask.mockResolvedValue({
+			ok: false,
+			error: 'Can only validate completed tasks',
+		});
+		const ctx = createMockContext();
+
+		const result = await validateTask({ task_id: VALID_UUID, approved: true }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Can only validate completed tasks',
+		});
+	});
+
+	it('should return error when task already validated', async () => {
+		mockApiClient.validateTask.mockResolvedValue({
+			ok: false,
+			error: 'Task has already been validated',
+		});
+		const ctx = createMockContext();
+
+		const result = await validateTask({ task_id: VALID_UUID, approved: true }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Task has already been validated',
+		});
+	});
+
+	describe('when approved', () => {
+		it('should mark task as validated', async () => {
+			mockApiClient.validateTask.mockResolvedValue({
+				ok: true,
+				data: {
+					success: true,
+					validated_task_id: VALID_UUID,
+					self_validated: false,
+				},
+			});
+			const ctx = createMockContext({ sessionId: 'validator-session' });
+
+			const result = await validateTask(
+				{ task_id: VALID_UUID, approved: true },
+				ctx
+			);
+
+			expect(result.result).toMatchObject({
+				success: true,
+				validated_task_id: VALID_UUID,
+				self_validated: false,
+			});
+		});
+
+		it('should detect self-validation', async () => {
+			mockApiClient.validateTask.mockResolvedValue({
+				ok: true,
+				data: {
+					success: true,
+					validated_task_id: VALID_UUID,
+					self_validated: true,
+				},
+			});
+			const ctx = createMockContext({ sessionId: 'session-123' });
+
+			const result = await validateTask(
+				{ task_id: VALID_UUID, approved: true },
+				ctx
+			);
+
+			expect(result.result).toMatchObject({
+				success: true,
+				self_validated: true,
+			});
+		});
+
+		it('should pass validation_notes to API', async () => {
+			mockApiClient.validateTask.mockResolvedValue({
+				ok: true,
+				data: {
+					success: true,
+					validated_task_id: VALID_UUID,
+					self_validated: false,
+				},
+			});
+			const ctx = createMockContext({ sessionId: 'validator-session' });
+
+			await validateTask(
+				{
+					task_id: VALID_UUID,
+					approved: true,
+					validation_notes: 'Looks good!',
+				},
+				ctx
+			);
+
+			expect(mockApiClient.validateTask).toHaveBeenCalledWith(
+				VALID_UUID,
+				{ approved: true, validation_notes: 'Looks good!' },
+				'validator-session'
+			);
+		});
+	});
+
+	describe('when rejected', () => {
+		it('should reopen task', async () => {
+			mockApiClient.validateTask.mockResolvedValue({
+				ok: true,
+				data: {
+					success: true,
+					reopened_task_id: VALID_UUID,
+				},
+			});
+			const ctx = createMockContext();
+
+			const result = await validateTask(
+				{ task_id: VALID_UUID, approved: false },
+				ctx
+			);
+
+			expect(result.result).toMatchObject({
+				success: true,
+				reopened_task_id: VALID_UUID,
+			});
+		});
+
+		it('should pass rejection notes to API', async () => {
+			mockApiClient.validateTask.mockResolvedValue({
+				ok: true,
+				data: {
+					success: true,
+					reopened_task_id: VALID_UUID,
+				},
+			});
+			const ctx = createMockContext();
+
+			await validateTask(
+				{
+					task_id: VALID_UUID,
+					approved: false,
+					validation_notes: 'Tests failing',
+				},
+				ctx
+			);
+
+			expect(mockApiClient.validateTask).toHaveBeenCalledWith(
+				VALID_UUID,
+				{ approved: false, validation_notes: 'Tests failing' },
+				'session-123'
+			);
+		});
+	});
+
+	it('should return error when validation fails on approval', async () => {
+		mockApiClient.validateTask.mockResolvedValue({
+			ok: false,
+			error: 'Failed to validate task',
+		});
+		const ctx = createMockContext();
+
+		const result = await validateTask({ task_id: VALID_UUID, approved: true }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Failed to validate task',
+		});
+	});
+
+	it('should return error when validation fails on rejection', async () => {
+		mockApiClient.validateTask.mockResolvedValue({
+			ok: false,
+			error: 'Failed to validate task',
+		});
+		const ctx = createMockContext();
+
+		const result = await validateTask({ task_id: VALID_UUID, approved: false }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Failed to validate task',
+		});
+	});
+
+	describe('PR requirement', () => {
+		it('should return error when PR is required but not present', async () => {
+			mockApiClient.validateTask.mockResolvedValue({
+				ok: false,
+				error: 'pr_required',
+				data: {
+					message: 'This project uses git-flow workflow which requires a Pull Request before validation approval.',
+					workflow: 'git-flow',
+				},
+			});
+			const ctx = createMockContext();
+
+			const result = await validateTask(
+				{ task_id: VALID_UUID, approved: true },
+				ctx
+			);
+
+			expect(result.result).toMatchObject({
+				error: 'pr_required',
+				workflow: 'git-flow',
+				action_required: expect.stringContaining('add_task_reference'),
+			});
+		});
+
+		it('should pass skip_pr_check to API', async () => {
+			mockApiClient.validateTask.mockResolvedValue({
+				ok: true,
+				data: {
+					success: true,
+					validated_task_id: VALID_UUID,
+					self_validated: false,
+				},
+			});
+			const ctx = createMockContext({ sessionId: 'validator-session' });
+
+			await validateTask(
+				{
+					task_id: VALID_UUID,
+					approved: true,
+					skip_pr_check: true,
+				},
+				ctx
+			);
+
+			expect(mockApiClient.validateTask).toHaveBeenCalledWith(
+				VALID_UUID,
+				{ approved: true, skip_pr_check: true },
+				'validator-session'
+			);
+		});
+	});
+});