@vibescope/mcp-server 0.0.1 → 0.2.0

package/src/handlers/validation.test.ts

@@ -1,119 +1,18 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { SupabaseClient } from '@supabase/supabase-js';
-import type { HandlerContext, TokenUsage } from './types.js';
 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 Utilities
+// Test Constants
 // ============================================================================
 
-function createMockSupabase(overrides: {
-	selectResult?: { data: unknown; error: unknown };
-	insertResult?: { data: unknown; error: unknown };
-	updateResult?: { data: unknown; error: unknown };
-} = {}) {
-	const defaultResult = { data: null, error: null };
-	let currentOperation = 'select';
-	let insertThenSelect = false;
-
-	const mock = {
-		from: vi.fn().mockReturnThis(),
-		select: vi.fn(() => {
-			if (currentOperation === 'insert') {
-				insertThenSelect = true;
-			} else {
-				currentOperation = 'select';
-				insertThenSelect = false;
-			}
-			return mock;
-		}),
-		insert: vi.fn(() => {
-			currentOperation = 'insert';
-			insertThenSelect = false;
-			return mock;
-		}),
-		update: vi.fn(() => {
-			currentOperation = 'update';
-			insertThenSelect = false;
-			return mock;
-		}),
-		delete: vi.fn(() => {
-			currentOperation = 'delete';
-			insertThenSelect = false;
-			return mock;
-		}),
-		eq: vi.fn().mockReturnThis(),
-		neq: vi.fn().mockReturnThis(),
-		in: vi.fn().mockReturnThis(),
-		is: vi.fn().mockReturnThis(),
-		not: vi.fn().mockReturnThis(),
-		or: vi.fn().mockReturnThis(),
-		gte: vi.fn().mockReturnThis(),
-		lte: vi.fn().mockReturnThis(),
-		lt: vi.fn().mockReturnThis(),
-		order: vi.fn().mockReturnThis(),
-		limit: vi.fn().mockReturnThis(),
-		single: vi.fn(() => {
-			if (currentOperation === 'insert' || insertThenSelect) {
-				return Promise.resolve(overrides.insertResult ?? defaultResult);
-			}
-			if (currentOperation === 'select') {
-				return Promise.resolve(overrides.selectResult ?? defaultResult);
-			}
-			if (currentOperation === 'update') {
-				return Promise.resolve(overrides.updateResult ?? defaultResult);
-			}
-			return Promise.resolve(defaultResult);
-		}),
-		maybeSingle: vi.fn(() => {
-			return Promise.resolve(overrides.selectResult ?? defaultResult);
-		}),
-		then: vi.fn((resolve: (value: unknown) => void) => {
-			if (currentOperation === 'insert' || insertThenSelect) {
-				return Promise.resolve(overrides.insertResult ?? defaultResult).then(resolve);
-			}
-			if (currentOperation === 'select') {
-				return Promise.resolve(overrides.selectResult ?? defaultResult).then(resolve);
-			}
-			if (currentOperation === 'update') {
-				return Promise.resolve(overrides.updateResult ?? defaultResult).then(resolve);
-			}
-			return Promise.resolve(defaultResult).then(resolve);
-		}),
-	};
-
-	return mock as unknown as SupabaseClient;
-}
-
-function createMockContext(
-	supabase: SupabaseClient,
-	options: { sessionId?: string | null } = {}
-): HandlerContext {
-	const defaultTokenUsage: TokenUsage = {
-		callCount: 5,
-		totalTokens: 2500,
-		byTool: {},
-	};
-
-	const sessionId = 'sessionId' in options ? options.sessionId : 'session-123';
-
-	return {
-		supabase,
-		auth: { userId: 'user-123', apiKeyId: 'api-key-123' },
-		session: {
-			instanceId: 'instance-abc',
-			currentSessionId: sessionId,
-			currentPersona: 'Wave',
-			tokenUsage: defaultTokenUsage,
-		},
-		updateSession: vi.fn(),
-	};
-}
+const VALID_UUID = '123e4567-e89b-12d3-a456-426614174000';
 
 // ============================================================================
 // getTasksAwaitingValidation Tests
@@ -123,15 +22,13 @@ describe('getTasksAwaitingValidation', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(getTasksAwaitingValidation({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid project_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			getTasksAwaitingValidation({ project_id: 'invalid' }, ctx)
@@ -139,26 +36,19 @@ describe('getTasksAwaitingValidation', () => {
 	});
 
 	it('should return empty list when no tasks awaiting validation', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+		mockApiClient.getTasksAwaitingValidation.mockResolvedValue({
+			ok: true,
+			data: { tasks: [], count: 0 },
 		});
-		const ctx = createMockContext(supabase);
-
-		// Override to return array result
-		vi.mocked(supabase.from('').select).mockReturnValue({
-			...supabase,
-			then: (resolve: (val: unknown) => void) =>
-				Promise.resolve({ data: [], error: null }).then(resolve),
-		} as unknown as ReturnType<SupabaseClient['from']>);
+		const ctx = createMockContext();
 
 		const result = await getTasksAwaitingValidation(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			{ project_id: VALID_UUID },
 			ctx
 		);
 
 		expect(result.result).toHaveProperty('tasks');
 		expect((result.result as { tasks: unknown[] }).tasks).toEqual([]);
-		expect((result.result as { hint?: string }).hint).toBeUndefined();
 	});
 
 	it('should return tasks with review status info', async () => {
@@ -168,33 +58,31 @@ describe('getTasksAwaitingValidation', () => {
 				title: 'Implement feature A',
 				completed_at: '2025-01-14T10:00:00Z',
 				completed_by_session_id: 'other-session',
-				reviewing_by_session_id: null,
-				reviewing_started_at: null,
+				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',
-				reviewing_by_session_id: 'reviewer-session',
-				reviewing_started_at: new Date(Date.now() - 5 * 60000).toISOString(), // 5 minutes ago
+				being_reviewed: true,
+				review_minutes: 5,
 			},
 		];
 
-		const supabase = createMockSupabase({
-			selectResult: { data: mockTasks, error: null },
+		mockApiClient.getTasksAwaitingValidation.mockResolvedValue({
+			ok: true,
+			data: {
+				tasks: mockTasks,
+				count: 2,
+				hint: 'Use claim_validation to claim a task for review',
+			},
 		});
-		const ctx = createMockContext(supabase);
-
-		// Override to return array result
-		vi.mocked(supabase.from('').select).mockReturnValue({
-			...supabase,
-			then: (resolve: (val: unknown) => void) =>
-				Promise.resolve({ data: mockTasks, error: null }).then(resolve),
-		} as unknown as ReturnType<SupabaseClient['from']>);
+		const ctx = createMockContext();
 
 		const result = await getTasksAwaitingValidation(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			{ project_id: VALID_UUID },
 			ctx
 		);
 
@@ -207,46 +95,37 @@ describe('getTasksAwaitingValidation', () => {
 
 		// Second task being reviewed for ~5 minutes
 		expect(tasks[1].being_reviewed).toBe(true);
-		expect(tasks[1].review_minutes).toBeGreaterThanOrEqual(4);
-		expect(tasks[1].review_minutes).toBeLessThanOrEqual(6);
+		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 query correct table with filters', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+	it('should call API client with correct project_id', async () => {
+		mockApiClient.getTasksAwaitingValidation.mockResolvedValue({
+			ok: true,
+			data: { tasks: [], count: 0 },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await getTasksAwaitingValidation(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			{ project_id: VALID_UUID },
 			ctx
 		);
 
-		expect(supabase.from).toHaveBeenCalledWith('tasks');
-		expect(supabase.eq).toHaveBeenCalledWith('project_id', '123e4567-e89b-12d3-a456-426614174000');
-		expect(supabase.eq).toHaveBeenCalledWith('status', 'completed');
-		expect(supabase.is).toHaveBeenCalledWith('validated_at', null);
+		expect(mockApiClient.getTasksAwaitingValidation).toHaveBeenCalledWith(VALID_UUID);
 	});
 
-	it('should throw error when database query fails', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: { message: 'Database error' } },
+	it('should throw error when API call fails', async () => {
+		mockApiClient.getTasksAwaitingValidation.mockResolvedValue({
+			ok: false,
+			error: 'Failed to fetch tasks awaiting validation',
 		});
-		const ctx = createMockContext(supabase);
-
-		// Override to return error
-		vi.mocked(supabase.from('').select).mockReturnValue({
-			...supabase,
-			then: (resolve: (val: unknown) => void) =>
-				Promise.resolve({ data: null, error: { message: 'Database error' } }).then(resolve),
-		} as unknown as ReturnType<SupabaseClient['from']>);
+		const ctx = createMockContext();
 
 		await expect(
-			getTasksAwaitingValidation({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow('Failed to fetch tasks');
+			getTasksAwaitingValidation({ project_id: VALID_UUID }, ctx)
+		).rejects.toThrow('Failed to fetch tasks awaiting validation');
 	});
 });
 
@@ -258,15 +137,13 @@ describe('claimValidation', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing task_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(claimValidation({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid task_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			claimValidation({ task_id: 'not-a-uuid' }, ctx)
@@ -274,194 +151,133 @@ describe('claimValidation', () => {
 	});
 
 	it('should throw error when task not found', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: { message: 'Not found' } },
+		mockApiClient.claimValidation.mockResolvedValue({
+			ok: false,
+			error: 'Task not found',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			claimValidation({ task_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+			claimValidation({ task_id: VALID_UUID }, ctx)
 		).rejects.toThrow('Task not found');
 	});
 
 	it('should throw error when task is not completed', async () => {
-		const supabase = createMockSupabase({
-			selectResult: {
-				data: {
-					id: 'task-1',
-					title: 'Test Task',
-					status: 'in_progress',
-					validated_at: null,
-					completed_by_session_id: 'other-session',
-					reviewing_by_session_id: null,
-				},
-				error: null,
-			},
+		mockApiClient.claimValidation.mockResolvedValue({
+			ok: false,
+			error: 'Can only claim completed tasks for review',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			claimValidation({ task_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+			claimValidation({ task_id: VALID_UUID }, ctx)
 		).rejects.toThrow('Can only claim completed tasks for review');
 	});
 
 	it('should throw error when task is already validated', async () => {
-		const supabase = createMockSupabase({
-			selectResult: {
-				data: {
-					id: 'task-1',
-					title: 'Test Task',
-					status: 'completed',
-					validated_at: '2025-01-14T12:00:00Z',
-					completed_by_session_id: 'other-session',
-					reviewing_by_session_id: null,
-				},
-				error: null,
-			},
+		mockApiClient.claimValidation.mockResolvedValue({
+			ok: false,
+			error: 'Task has already been validated',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			claimValidation({ task_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+			claimValidation({ task_id: VALID_UUID }, ctx)
 		).rejects.toThrow('Task has already been validated');
 	});
 
 	it('should throw error when task is being reviewed by another agent', async () => {
-		const supabase = createMockSupabase({
-			selectResult: {
-				data: {
-					id: 'task-1',
-					title: 'Test Task',
-					status: 'completed',
-					validated_at: null,
-					completed_by_session_id: 'other-session',
-					reviewing_by_session_id: 'different-reviewer',
-				},
-				error: null,
-			},
+		mockApiClient.claimValidation.mockResolvedValue({
+			ok: false,
+			error: 'Task is already being reviewed by another agent',
 		});
-		const ctx = createMockContext(supabase, { sessionId: 'session-123' });
+		const ctx = createMockContext({ sessionId: 'session-123' });
 
 		await expect(
-			claimValidation({ task_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+			claimValidation({ task_id: VALID_UUID }, ctx)
 		).rejects.toThrow('Task is already being reviewed by another agent');
 	});
 
 	it('should allow same agent to re-claim their own review', async () => {
-		const supabase = createMockSupabase({
-			selectResult: {
-				data: {
-					id: 'task-1',
-					title: 'Test Task',
-					status: 'completed',
-					validated_at: null,
-					completed_by_session_id: 'other-session',
-					reviewing_by_session_id: 'session-123', // Same as current session
-				},
-				error: null,
+		mockApiClient.claimValidation.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				task_id: VALID_UUID,
+				title: 'Test Task',
+				message: 'Re-claimed task for review',
 			},
-			updateResult: { data: null, error: null },
 		});
-		const ctx = createMockContext(supabase, { sessionId: 'session-123' });
+		const ctx = createMockContext({ sessionId: 'session-123' });
 
 		const result = await claimValidation(
-			{ task_id: '123e4567-e89b-12d3-a456-426614174000' },
+			{ task_id: VALID_UUID },
 			ctx
 		);
 
 		expect(result.result).toMatchObject({
 			success: true,
-			task_id: '123e4567-e89b-12d3-a456-426614174000',
+			task_id: VALID_UUID,
 			title: 'Test Task',
 		});
 	});
 
 	it('should claim task successfully', async () => {
-		const supabase = createMockSupabase({
-			selectResult: {
-				data: {
-					id: 'task-1',
-					title: 'Test Task',
-					status: 'completed',
-					validated_at: null,
-					completed_by_session_id: 'other-session',
-					reviewing_by_session_id: null,
-				},
-				error: null,
+		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.',
 			},
-			updateResult: { data: null, error: null },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await claimValidation(
-			{ task_id: '123e4567-e89b-12d3-a456-426614174000' },
+			{ task_id: VALID_UUID },
 			ctx
 		);
 
 		expect(result.result).toMatchObject({
 			success: true,
-			task_id: '123e4567-e89b-12d3-a456-426614174000',
+			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 update task with reviewing session info', async () => {
-		const supabase = createMockSupabase({
-			selectResult: {
-				data: {
-					id: 'task-1',
-					title: 'Test Task',
-					status: 'completed',
-					validated_at: null,
-					completed_by_session_id: 'other-session',
-					reviewing_by_session_id: null,
-				},
-				error: null,
+	it('should call API client with session_id', async () => {
+		mockApiClient.claimValidation.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				task_id: VALID_UUID,
+				title: 'Test Task',
 			},
-			updateResult: { data: null, error: null },
 		});
-		const ctx = createMockContext(supabase, { sessionId: 'reviewer-session' });
+		const ctx = createMockContext({ sessionId: 'reviewer-session' });
 
-		await claimValidation({ task_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx);
+		await claimValidation({ task_id: VALID_UUID }, ctx);
 
-		expect(supabase.update).toHaveBeenCalledWith(
-			expect.objectContaining({
-				reviewing_by_session_id: 'reviewer-session',
-				reviewing_started_at: expect.any(String),
-			})
+		expect(mockApiClient.claimValidation).toHaveBeenCalledWith(
+			VALID_UUID,
+			'reviewer-session'
 		);
 	});
 
-	it('should throw error when update fails', async () => {
-		const supabase = createMockSupabase({
-			selectResult: {
-				data: {
-					id: 'task-1',
-					title: 'Test Task',
-					status: 'completed',
-					validated_at: null,
-					completed_by_session_id: 'other-session',
-					reviewing_by_session_id: null,
-				},
-				error: null,
-			},
+	it('should throw error when claim fails', async () => {
+		mockApiClient.claimValidation.mockResolvedValue({
+			ok: false,
+			error: 'Failed to claim task for validation',
 		});
-		const ctx = createMockContext(supabase);
-
-		// Override update to return error
-		vi.mocked(supabase.from('').update).mockReturnValue({
-			...supabase,
-			eq: vi.fn().mockReturnValue({
-				then: (resolve: (val: unknown) => void) =>
-					Promise.resolve({ data: null, error: { message: 'Update failed' } }).then(resolve),
-			}),
-		} as unknown as ReturnType<SupabaseClient['from']>);
+		const ctx = createMockContext();
 
 		await expect(
-			claimValidation({ task_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow('Failed to claim task');
+			claimValidation({ task_id: VALID_UUID }, ctx)
+		).rejects.toThrow('Failed to claim task for validation');
 	});
 });
 
@@ -473,8 +289,7 @@ describe('validateTask', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing task_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			validateTask({ approved: true }, ctx)
@@ -482,122 +297,94 @@ describe('validateTask', () => {
 	});
 
 	it('should throw error for invalid task_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		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('approved is required');
+	});
+
 	it('should throw error when task not found', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: { message: 'Not found' } },
+		mockApiClient.validateTask.mockResolvedValue({
+			ok: false,
+			error: 'Task not found',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			validateTask({ task_id: '123e4567-e89b-12d3-a456-426614174000', approved: true }, ctx)
+			validateTask({ task_id: VALID_UUID, approved: true }, ctx)
 		).rejects.toThrow('Task not found');
 	});
 
 	it('should throw error when task is not completed', async () => {
-		const supabase = createMockSupabase({
-			selectResult: {
-				data: {
-					id: 'task-1',
-					title: 'Test Task',
-					status: 'in_progress',
-					validated_at: null,
-					completed_by_session_id: 'other-session',
-					project_id: 'proj-1',
-					git_branch: null,
-				},
-				error: null,
-			},
+		mockApiClient.validateTask.mockResolvedValue({
+			ok: false,
+			error: 'Can only validate completed tasks',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			validateTask({ task_id: '123e4567-e89b-12d3-a456-426614174000', approved: true }, ctx)
+			validateTask({ task_id: VALID_UUID, approved: true }, ctx)
 		).rejects.toThrow('Can only validate completed tasks');
 	});
 
 	it('should throw error when task already validated', async () => {
-		const supabase = createMockSupabase({
-			selectResult: {
-				data: {
-					id: 'task-1',
-					title: 'Test Task',
-					status: 'completed',
-					validated_at: '2025-01-14T12:00:00Z',
-					completed_by_session_id: 'other-session',
-					project_id: 'proj-1',
-					git_branch: null,
-				},
-				error: null,
-			},
+		mockApiClient.validateTask.mockResolvedValue({
+			ok: false,
+			error: 'Task has already been validated',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			validateTask({ task_id: '123e4567-e89b-12d3-a456-426614174000', approved: true }, ctx)
+			validateTask({ task_id: VALID_UUID, approved: true }, ctx)
 		).rejects.toThrow('Task has already been validated');
 	});
 
 	describe('when approved', () => {
 		it('should mark task as validated', async () => {
-			const supabase = createMockSupabase({
-				selectResult: {
-					data: {
-						id: 'task-1',
-						title: 'Test Task',
-						status: 'completed',
-						validated_at: null,
-						completed_by_session_id: 'other-session',
-						project_id: 'proj-1',
-						git_branch: null,
-					},
-					error: null,
+			mockApiClient.validateTask.mockResolvedValue({
+				ok: true,
+				data: {
+					success: true,
+					validated_task_id: VALID_UUID,
+					self_validated: false,
 				},
-				updateResult: { data: null, error: null },
-				insertResult: { data: null, error: null },
 			});
-			const ctx = createMockContext(supabase, { sessionId: 'validator-session' });
+			const ctx = createMockContext({ sessionId: 'validator-session' });
 
 			const result = await validateTask(
-				{ task_id: '123e4567-e89b-12d3-a456-426614174000', approved: true },
+				{ task_id: VALID_UUID, approved: true },
 				ctx
 			);
 
 			expect(result.result).toMatchObject({
 				success: true,
-				validated_task_id: '123e4567-e89b-12d3-a456-426614174000',
+				validated_task_id: VALID_UUID,
 				self_validated: false,
 			});
 		});
 
 		it('should detect self-validation', async () => {
-			const supabase = createMockSupabase({
-				selectResult: {
-					data: {
-						id: 'task-1',
-						title: 'Test Task',
-						status: 'completed',
-						validated_at: null,
-						completed_by_session_id: 'session-123', // Same as validator
-						project_id: 'proj-1',
-						git_branch: null,
-					},
-					error: null,
+			mockApiClient.validateTask.mockResolvedValue({
+				ok: true,
+				data: {
+					success: true,
+					validated_task_id: VALID_UUID,
+					self_validated: true,
 				},
-				updateResult: { data: null, error: null },
-				insertResult: { data: null, error: null },
 			});
-			const ctx = createMockContext(supabase, { sessionId: 'session-123' });
+			const ctx = createMockContext({ sessionId: 'session-123' });
 
 			const result = await validateTask(
-				{ task_id: '123e4567-e89b-12d3-a456-426614174000', approved: true },
+				{ task_id: VALID_UUID, approved: true },
 				ctx
 			);
 
@@ -607,274 +394,156 @@ describe('validateTask', () => {
 			});
 		});
 
-		it('should clear reviewing status on approval', async () => {
-			const supabase = createMockSupabase({
-				selectResult: {
-					data: {
-						id: 'task-1',
-						title: 'Test Task',
-						status: 'completed',
-						validated_at: null,
-						completed_by_session_id: 'other-session',
-						project_id: 'proj-1',
-						git_branch: null,
-					},
-					error: null,
-				},
-				updateResult: { data: null, error: null },
-				insertResult: { data: null, error: null },
-			});
-			const ctx = createMockContext(supabase);
-
-			await validateTask(
-				{ task_id: '123e4567-e89b-12d3-a456-426614174000', approved: true },
-				ctx
-			);
-
-			expect(supabase.update).toHaveBeenCalledWith(
-				expect.objectContaining({
-					validated_at: expect.any(String),
-					reviewing_by_session_id: null,
-					reviewing_started_at: null,
-				})
-			);
-		});
-
-		it('should log validation in progress_logs', async () => {
-			const supabase = createMockSupabase({
-				selectResult: {
-					data: {
-						id: 'task-1',
-						title: 'Test Feature',
-						status: 'completed',
-						validated_at: null,
-						completed_by_session_id: 'other-session',
-						project_id: 'proj-123',
-						git_branch: null,
-					},
-					error: null,
+		it('should pass validation_notes to API', async () => {
+			mockApiClient.validateTask.mockResolvedValue({
+				ok: true,
+				data: {
+					success: true,
+					validated_task_id: VALID_UUID,
+					self_validated: false,
 				},
-				updateResult: { data: null, error: null },
-				insertResult: { data: null, error: null },
 			});
-			const ctx = createMockContext(supabase, { sessionId: 'validator-session' });
+			const ctx = createMockContext({ sessionId: 'validator-session' });
 
 			await validateTask(
 				{
-					task_id: '123e4567-e89b-12d3-a456-426614174000',
+					task_id: VALID_UUID,
 					approved: true,
 					validation_notes: 'Looks good!',
 				},
 				ctx
 			);
 
-			expect(supabase.from).toHaveBeenCalledWith('progress_logs');
-			expect(supabase.insert).toHaveBeenCalledWith(
-				expect.objectContaining({
-					project_id: 'proj-123',
-					task_id: '123e4567-e89b-12d3-a456-426614174000',
-					summary: expect.stringContaining('Validated'),
-					details: 'Looks good!',
-					created_by: 'agent',
-				})
+			expect(mockApiClient.validateTask).toHaveBeenCalledWith(
+				VALID_UUID,
+				{ approved: true, validation_notes: 'Looks good!' },
+				'validator-session'
 			);
 		});
 	});
 
 	describe('when rejected', () => {
 		it('should reopen task', async () => {
-			const supabase = createMockSupabase({
-				selectResult: {
-					data: {
-						id: 'task-1',
-						title: 'Test Task',
-						status: 'completed',
-						validated_at: null,
-						completed_by_session_id: 'other-session',
-						project_id: 'proj-1',
-						git_branch: null,
-					},
-					error: null,
+			mockApiClient.validateTask.mockResolvedValue({
+				ok: true,
+				data: {
+					success: true,
+					reopened_task_id: VALID_UUID,
 				},
-				updateResult: { data: null, error: null },
-				insertResult: { data: null, error: null },
 			});
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
 			const result = await validateTask(
-				{ task_id: '123e4567-e89b-12d3-a456-426614174000', approved: false },
+				{ task_id: VALID_UUID, approved: false },
 				ctx
 			);
 
 			expect(result.result).toMatchObject({
 				success: true,
-				reopened_task_id: '123e4567-e89b-12d3-a456-426614174000',
+				reopened_task_id: VALID_UUID,
 			});
 		});
 
-		it('should set task to in_progress with 80% progress', async () => {
-			const supabase = createMockSupabase({
-				selectResult: {
-					data: {
-						id: 'task-1',
-						title: 'Test Task',
-						status: 'completed',
-						validated_at: null,
-						completed_by_session_id: 'other-session',
-						project_id: 'proj-1',
-						git_branch: null,
-					},
-					error: null,
-				},
-				updateResult: { data: null, error: null },
-				insertResult: { data: null, error: null },
-			});
-			const ctx = createMockContext(supabase);
-
-			await validateTask(
-				{ task_id: '123e4567-e89b-12d3-a456-426614174000', approved: false },
-				ctx
-			);
-
-			expect(supabase.update).toHaveBeenCalledWith(
-				expect.objectContaining({
-					status: 'in_progress',
-					completed_at: null,
-					progress_percentage: 80,
-					reviewing_by_session_id: null,
-					reviewing_started_at: null,
-				})
-			);
-		});
-
-		it('should log rejection in progress_logs', async () => {
-			const supabase = createMockSupabase({
-				selectResult: {
-					data: {
-						id: 'task-1',
-						title: 'Broken Feature',
-						status: 'completed',
-						validated_at: null,
-						completed_by_session_id: 'other-session',
-						project_id: 'proj-123',
-						git_branch: null,
-					},
-					error: null,
+		it('should pass rejection notes to API', async () => {
+			mockApiClient.validateTask.mockResolvedValue({
+				ok: true,
+				data: {
+					success: true,
+					reopened_task_id: VALID_UUID,
 				},
-				updateResult: { data: null, error: null },
-				insertResult: { data: null, error: null },
 			});
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
 			await validateTask(
 				{
-					task_id: '123e4567-e89b-12d3-a456-426614174000',
+					task_id: VALID_UUID,
 					approved: false,
 					validation_notes: 'Tests failing',
 				},
 				ctx
 			);
 
-			expect(supabase.from).toHaveBeenCalledWith('progress_logs');
-			expect(supabase.insert).toHaveBeenCalledWith(
-				expect.objectContaining({
-					summary: expect.stringContaining('Validation failed'),
-					details: 'Tests failing',
-				})
+			expect(mockApiClient.validateTask).toHaveBeenCalledWith(
+				VALID_UUID,
+				{ approved: false, validation_notes: 'Tests failing' },
+				'session-123'
 			);
 		});
+	});
 
-		it('should use default message when no validation_notes provided', async () => {
-			const supabase = createMockSupabase({
-				selectResult: {
-					data: {
-						id: 'task-1',
-						title: 'Test Task',
-						status: 'completed',
-						validated_at: null,
-						completed_by_session_id: 'other-session',
-						project_id: 'proj-123',
-						git_branch: null,
-					},
-					error: null,
-				},
-				updateResult: { data: null, error: null },
-				insertResult: { data: null, error: null },
-			});
-			const ctx = createMockContext(supabase);
-
-			await validateTask(
-				{ task_id: '123e4567-e89b-12d3-a456-426614174000', approved: false },
-				ctx
-			);
-
-			expect(supabase.insert).toHaveBeenCalledWith(
-				expect.objectContaining({
-					details: 'Needs more work',
-				})
-			);
+	it('should throw error when validation fails on approval', async () => {
+		mockApiClient.validateTask.mockResolvedValue({
+			ok: false,
+			error: 'Failed to validate task',
 		});
+		const ctx = createMockContext();
+
+		await expect(
+			validateTask({ task_id: VALID_UUID, approved: true }, ctx)
+		).rejects.toThrow('Failed to validate task');
 	});
 
-	it('should throw error when update fails on approval', async () => {
-		const supabase = createMockSupabase({
-			selectResult: {
-				data: {
-					id: 'task-1',
-					title: 'Test Task',
-					status: 'completed',
-					validated_at: null,
-					completed_by_session_id: 'other-session',
-					project_id: 'proj-1',
-					git_branch: null,
-				},
-				error: null,
-			},
+	it('should throw error when validation fails on rejection', async () => {
+		mockApiClient.validateTask.mockResolvedValue({
+			ok: false,
+			error: 'Failed to validate task',
 		});
-		const ctx = createMockContext(supabase);
-
-		// Override update to return error
-		vi.mocked(supabase.from('').update).mockReturnValue({
-			...supabase,
-			eq: vi.fn().mockReturnValue({
-				then: (resolve: (val: unknown) => void) =>
-					Promise.resolve({ data: null, error: { message: 'Update failed' } }).then(resolve),
-			}),
-		} as unknown as ReturnType<SupabaseClient['from']>);
+		const ctx = createMockContext();
 
 		await expect(
-			validateTask({ task_id: '123e4567-e89b-12d3-a456-426614174000', approved: true }, ctx)
+			validateTask({ task_id: VALID_UUID, approved: false }, ctx)
 		).rejects.toThrow('Failed to validate task');
 	});
 
-	it('should throw error when update fails on rejection', async () => {
-		const supabase = createMockSupabase({
-			selectResult: {
+	describe('PR requirement', () => {
+		it('should return error when PR is required but not present', async () => {
+			mockApiClient.validateTask.mockResolvedValue({
+				ok: false,
+				error: 'pr_required',
 				data: {
-					id: 'task-1',
-					title: 'Test Task',
-					status: 'completed',
-					validated_at: null,
-					completed_by_session_id: 'other-session',
-					project_id: 'proj-1',
-					git_branch: null,
+					message: 'This project uses git-flow workflow which requires a Pull Request before validation approval.',
+					workflow: 'git-flow',
 				},
-				error: null,
-			},
+			});
+			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'),
+			});
 		});
-		const ctx = createMockContext(supabase);
 
-		// Override update to return error
-		vi.mocked(supabase.from('').update).mockReturnValue({
-			...supabase,
-			eq: vi.fn().mockReturnValue({
-				then: (resolve: (val: unknown) => void) =>
-					Promise.resolve({ data: null, error: { message: 'Update failed' } }).then(resolve),
-			}),
-		} as unknown as ReturnType<SupabaseClient['from']>);
+		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
+			);
 
-		await expect(
-			validateTask({ task_id: '123e4567-e89b-12d3-a456-426614174000', approved: false }, ctx)
-		).rejects.toThrow('Failed to reopen task');
+			expect(mockApiClient.validateTask).toHaveBeenCalledWith(
+				VALID_UUID,
+				{ approved: true, skip_pr_check: true },
+				'validator-session'
+			);
+		});
 	});
 });