@vibescope/mcp-server 0.0.1

package/src/handlers/validation.test.ts

@@ -0,0 +1,880 @@
+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';
+
+// ============================================================================
+// Test Utilities
+// ============================================================================
+
+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(),
+	};
+}
+
+// ============================================================================
+// getTasksAwaitingValidation Tests
+// ============================================================================
+
+describe('getTasksAwaitingValidation', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(getTasksAwaitingValidation({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			getTasksAwaitingValidation({ project_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should return empty list when no tasks awaiting validation', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+		});
+		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 result = await getTasksAwaitingValidation(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			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 () => {
+		const mockTasks = [
+			{
+				id: 'task-1',
+				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,
+			},
+			{
+				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
+			},
+		];
+
+		const supabase = createMockSupabase({
+			selectResult: { data: mockTasks, error: null },
+		});
+		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 result = await getTasksAwaitingValidation(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			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).toBeGreaterThanOrEqual(4);
+		expect(tasks[1].review_minutes).toBeLessThanOrEqual(6);
+
+		// 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 },
+		});
+		const ctx = createMockContext(supabase);
+
+		await getTasksAwaitingValidation(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			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);
+	});
+
+	it('should throw error when database query fails', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: null, error: { message: 'Database error' } },
+		});
+		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']>);
+
+		await expect(
+			getTasksAwaitingValidation({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow('Failed to fetch tasks');
+	});
+});
+
+// ============================================================================
+// claimValidation Tests
+// ============================================================================
+
+describe('claimValidation', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing task_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(claimValidation({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid task_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			claimValidation({ task_id: 'not-a-uuid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error when task not found', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: null, error: { message: 'Not found' } },
+		});
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			claimValidation({ task_id: '123e4567-e89b-12d3-a456-426614174000' }, 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,
+			},
+		});
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			claimValidation({ task_id: '123e4567-e89b-12d3-a456-426614174000' }, 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,
+			},
+		});
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			claimValidation({ task_id: '123e4567-e89b-12d3-a456-426614174000' }, 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,
+			},
+		});
+		const ctx = createMockContext(supabase, { sessionId: 'session-123' });
+
+		await expect(
+			claimValidation({ task_id: '123e4567-e89b-12d3-a456-426614174000' }, 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,
+			},
+			updateResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase, { sessionId: 'session-123' });
+
+		const result = await claimValidation(
+			{ task_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			task_id: '123e4567-e89b-12d3-a456-426614174000',
+			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,
+			},
+			updateResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await claimValidation(
+			{ task_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			task_id: '123e4567-e89b-12d3-a456-426614174000',
+			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,
+			},
+			updateResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase, { sessionId: 'reviewer-session' });
+
+		await claimValidation({ task_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx);
+
+		expect(supabase.update).toHaveBeenCalledWith(
+			expect.objectContaining({
+				reviewing_by_session_id: 'reviewer-session',
+				reviewing_started_at: expect.any(String),
+			})
+		);
+	});
+
+	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,
+			},
+		});
+		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']>);
+
+		await expect(
+			claimValidation({ task_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow('Failed to claim task');
+	});
+});
+
+// ============================================================================
+// validateTask Tests
+// ============================================================================
+
+describe('validateTask', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing task_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			validateTask({ approved: true }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid task_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			validateTask({ task_id: 'invalid', approved: true }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error when task not found', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: null, error: { message: 'Not found' } },
+		});
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			validateTask({ task_id: '123e4567-e89b-12d3-a456-426614174000', 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,
+			},
+		});
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			validateTask({ task_id: '123e4567-e89b-12d3-a456-426614174000', 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,
+			},
+		});
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			validateTask({ task_id: '123e4567-e89b-12d3-a456-426614174000', 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,
+				},
+				updateResult: { data: null, error: null },
+				insertResult: { data: null, error: null },
+			});
+			const ctx = createMockContext(supabase, { sessionId: 'validator-session' });
+
+			const result = await validateTask(
+				{ task_id: '123e4567-e89b-12d3-a456-426614174000', approved: true },
+				ctx
+			);
+
+			expect(result.result).toMatchObject({
+				success: true,
+				validated_task_id: '123e4567-e89b-12d3-a456-426614174000',
+				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,
+				},
+				updateResult: { data: null, error: null },
+				insertResult: { data: null, error: null },
+			});
+			const ctx = createMockContext(supabase, { sessionId: 'session-123' });
+
+			const result = await validateTask(
+				{ task_id: '123e4567-e89b-12d3-a456-426614174000', approved: true },
+				ctx
+			);
+
+			expect(result.result).toMatchObject({
+				success: true,
+				self_validated: true,
+			});
+		});
+
+		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,
+				},
+				updateResult: { data: null, error: null },
+				insertResult: { data: null, error: null },
+			});
+			const ctx = createMockContext(supabase, { sessionId: 'validator-session' });
+
+			await validateTask(
+				{
+					task_id: '123e4567-e89b-12d3-a456-426614174000',
+					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',
+				})
+			);
+		});
+	});
+
+	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,
+				},
+				updateResult: { data: null, error: null },
+				insertResult: { data: null, error: null },
+			});
+			const ctx = createMockContext(supabase);
+
+			const result = await validateTask(
+				{ task_id: '123e4567-e89b-12d3-a456-426614174000', approved: false },
+				ctx
+			);
+
+			expect(result.result).toMatchObject({
+				success: true,
+				reopened_task_id: '123e4567-e89b-12d3-a456-426614174000',
+			});
+		});
+
+		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,
+				},
+				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,
+					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',
+				})
+			);
+		});
+
+		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 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,
+			},
+		});
+		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']>);
+
+		await expect(
+			validateTask({ task_id: '123e4567-e89b-12d3-a456-426614174000', approved: true }, ctx)
+		).rejects.toThrow('Failed to validate task');
+	});
+
+	it('should throw error when update fails on rejection', 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,
+			},
+		});
+		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']>);
+
+		await expect(
+			validateTask({ task_id: '123e4567-e89b-12d3-a456-426614174000', approved: false }, ctx)
+		).rejects.toThrow('Failed to reopen task');
+	});
+});