@vibescope/mcp-server 0.0.1 → 0.2.0

package/src/handlers/tasks.test.ts

@@ -1,209 +1,158 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { SupabaseClient } from '@supabase/supabase-js';
-import type { HandlerContext } from './types.js';
 import {
 	getTasks,
+	getNextTask,
 	addTask,
 	updateTask,
 	completeTask,
 	deleteTask,
 	addTaskReference,
 	removeTaskReference,
-	getProjectGitConfig,
+	batchUpdateTasks,
+	batchCompleteTasks,
+	addSubtask,
+	getSubtasks,
+	getValidationApprovedGitInstructions,
 } from './tasks.js';
 import { ValidationError } from '../validators.js';
-
-// ============================================================================
-// Test Utilities
-// ============================================================================
-
-/**
- * Creates a mock Supabase client with chainable methods
- */
-function createMockSupabase(overrides: {
-	selectResult?: { data: unknown; error: unknown };
-	insertResult?: { data: unknown; error: unknown };
-	updateResult?: { data: unknown; error: unknown };
-	deleteResult?: { data: unknown; error: unknown };
-} = {}) {
-	const defaultResult = { data: null, error: null };
-
-	// Track both the operation type AND if insert has been followed by select
-	let currentOperation = 'select';
-	let insertThenSelect = false;
-
-	const mock = {
-		from: vi.fn().mockReturnThis(),
-		select: vi.fn(() => {
-			// If we just did an insert and now calling select, it's insert().select() chain
-			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(),
-		lt: vi.fn().mockReturnThis(),
-		order: vi.fn().mockReturnThis(),
-		limit: vi.fn().mockReturnThis(),
-		single: vi.fn(() => {
-			// Handle insert().select().single() pattern
-			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);
-			}
-			if (currentOperation === 'delete') {
-				return Promise.resolve(overrides.deleteResult ?? defaultResult).then(resolve);
-			}
-			return Promise.resolve(defaultResult).then(resolve);
-		}),
-	};
-
-	return mock as unknown as SupabaseClient;
-}
-
-/**
- * Creates a mock handler context
- */
-function createMockContext(supabase: SupabaseClient, sessionId: string | null = 'session-123'): HandlerContext {
-	return {
-		supabase,
-		auth: {
-			userId: 'user-123',
-			apiKeyId: 'api-key-123',
-		},
-		session: {
-			currentSessionId: sessionId,
-		},
-	};
-}
+import { createMockContext } from './__test-utils__.js';
+import { mockApiClient } from './__test-setup__.js';
 
 // ============================================================================
 // getTasks Tests
 // ============================================================================
 
 describe('getTasks', () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const ctx = createMockContext();
+		await expect(getTasks({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
-	it('should return tasks for a valid project', async () => {
-		const mockTasks = [
-			{ id: 'task-1', title: 'Task 1', status: 'pending', priority: 1 },
-			{ id: 'task-2', title: 'Task 2', status: 'in_progress', priority: 2 },
-		];
+	it('should throw error for invalid project_id UUID', async () => {
+		const ctx = createMockContext();
+		await expect(getTasks({ project_id: 'invalid' }, ctx)).rejects.toThrow(ValidationError);
+	});
 
-		const supabase = createMockSupabase({
-			selectResult: { data: mockTasks, error: null },
+	it('should throw error for invalid status', async () => {
+		const ctx = createMockContext();
+		await expect(
+			getTasks({ project_id: '123e4567-e89b-12d3-a456-426614174000', status: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should return tasks successfully', async () => {
+		mockApiClient.getTasks.mockResolvedValue({
+			ok: true,
+			data: {
+				tasks: [
+					{ id: 'task-1', title: 'Test task', status: 'pending', priority: 1 },
+				],
+				total_count: 1,
+				has_more: false,
+			},
 		});
-		const ctx = createMockContext(supabase);
 
+		const ctx = createMockContext();
 		const result = await getTasks(
 			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
 			ctx
 		);
 
-		expect(result.result.tasks).toEqual(mockTasks);
-		expect(supabase.from).toHaveBeenCalledWith('tasks');
+		expect(result.result).toMatchObject({
+			tasks: expect.any(Array),
+			total_count: 1,
+			has_more: false,
+		});
+		expect(mockApiClient.getTasks).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			expect.any(Object)
+		);
 	});
 
-	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+	it('should pass status filter to API', async () => {
+		mockApiClient.getTasks.mockResolvedValue({
+			ok: true,
+			data: { tasks: [], total_count: 0, has_more: false },
+		});
 
-		await expect(getTasks({}, ctx)).rejects.toThrow(ValidationError);
+		const ctx = createMockContext();
+		await getTasks(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000', status: 'pending' },
+			ctx
+		);
+
+		expect(mockApiClient.getTasks).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			expect.objectContaining({ status: 'pending' })
+		);
 	});
+});
 
-	it('should throw error for invalid project_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+// ============================================================================
+// getNextTask Tests
+// ============================================================================
 
-		await expect(getTasks({ project_id: 'not-a-uuid' }, ctx)).rejects.toThrow(ValidationError);
+describe('getNextTask', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const ctx = createMockContext();
+		await expect(getNextTask({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
-	it('should filter by status when provided', async () => {
-		const mockTasks = [{ id: 'task-1', title: 'Task 1', status: 'pending', priority: 1 }];
+	it('should throw error for invalid project_id', async () => {
+		const ctx = createMockContext();
+		await expect(getNextTask({ project_id: 'invalid' }, ctx)).rejects.toThrow(ValidationError);
+	});
 
-		const supabase = createMockSupabase({
-			selectResult: { data: mockTasks, error: null },
+	it('should return next task when available', async () => {
+		mockApiClient.getNextTask.mockResolvedValue({
+			ok: true,
+			data: {
+				task: { id: 'task-1', title: 'Next task', priority: 1 },
+				directive: 'Start working',
+			},
 		});
-		const ctx = createMockContext(supabase);
 
-		await getTasks(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000', status: 'pending' },
+		const ctx = createMockContext();
+		const result = await getNextTask(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
 			ctx
 		);
 
-		expect(supabase.eq).toHaveBeenCalledWith('status', 'pending');
+		expect(result.result.task).toMatchObject({ id: 'task-1' });
 	});
 
-	it('should throw error for invalid status', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+	it('should return null when no tasks available', async () => {
+		mockApiClient.getNextTask.mockResolvedValue({
+			ok: true,
+			data: { task: null, message: 'No tasks available' },
+		});
 
-		await expect(
-			getTasks({ project_id: '123e4567-e89b-12d3-a456-426614174000', status: 'invalid' }, ctx)
-		).rejects.toThrow(ValidationError);
+		const ctx = createMockContext();
+		const result = await getNextTask(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result.task).toBeNull();
 	});
 
-	it('should handle database errors', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: { message: 'Database error' } },
+	it('should pass session_id to API', async () => {
+		mockApiClient.getNextTask.mockResolvedValue({
+			ok: true,
+			data: { task: null },
 		});
-		const ctx = createMockContext(supabase);
 
-		// The handler uses .then() pattern, so we need to adjust the mock
-		vi.mocked(supabase.from('tasks').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({ sessionId: 'my-session' });
+		await getNextTask({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx);
 
-		await expect(
-			getTasks({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow('Failed to fetch tasks');
+		expect(mockApiClient.getNextTask).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			'my-session'
+		);
 	});
 });
 
@@ -212,224 +161,436 @@ describe('getTasks', () => {
 // ============================================================================
 
 describe('addTask', () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const ctx = createMockContext();
+		await expect(addTask({ title: 'Test task' }, ctx)).rejects.toThrow(ValidationError);
 	});
 
-	it('should add a task successfully', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: { id: 'new-task-123', blocking: false }, error: null },
+	it('should throw error for invalid project_id', async () => {
+		const ctx = createMockContext();
+		await expect(
+			addTask({ project_id: 'invalid', title: 'Test task' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for missing title', async () => {
+		const ctx = createMockContext();
+		await expect(
+			addTask({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid priority', async () => {
+		const ctx = createMockContext();
+		await expect(
+			addTask({
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				title: 'Test',
+				priority: 10,
+			}, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should add task successfully', async () => {
+		mockApiClient.createTask.mockResolvedValue({
+			ok: true,
+			data: { task_id: 'new-task-id', title: 'Test task' },
 		});
-		const ctx = createMockContext(supabase);
 
+		const ctx = createMockContext();
 		const result = await addTask(
 			{
 				project_id: '123e4567-e89b-12d3-a456-426614174000',
-				title: 'New Task',
-				description: 'Task description',
+				title: 'Test task',
+			},
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			task_id: 'new-task-id',
+		});
+	});
+
+	it('should include optional fields in API call', async () => {
+		mockApiClient.createTask.mockResolvedValue({
+			ok: true,
+			data: { task_id: 'new-task-id' },
+		});
+
+		const ctx = createMockContext();
+		await addTask(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				title: 'Test task',
+				description: 'A description',
 				priority: 2,
+				estimated_minutes: 30,
+				blocking: true,
 			},
 			ctx
 		);
 
-		expect(result.result.success).toBe(true);
-		expect(result.result.task_id).toBe('new-task-123');
-		expect(result.result.title).toBe('New Task');
-		expect(supabase.from).toHaveBeenCalledWith('tasks');
-		expect(supabase.insert).toHaveBeenCalled();
+		expect(mockApiClient.createTask).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			expect.objectContaining({
+				title: 'Test task',
+				description: 'A description',
+				priority: 2,
+				estimated_minutes: 30,
+				blocking: true,
+			})
+		);
 	});
+});
 
-	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+// ============================================================================
+// updateTask Tests
+// ============================================================================
+
+describe('updateTask', () => {
+	beforeEach(() => vi.clearAllMocks());
 
-		await expect(addTask({ title: 'Test' }, ctx)).rejects.toThrow(ValidationError);
+	it('should throw error for missing task_id', async () => {
+		const ctx = createMockContext();
+		await expect(updateTask({ status: 'in_progress' }, ctx)).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error for missing title', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+	it('should throw error for invalid task_id', async () => {
+		const ctx = createMockContext();
+		await expect(
+			updateTask({ task_id: 'invalid', status: 'in_progress' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
 
+	it('should throw error for invalid status', async () => {
+		const ctx = createMockContext();
 		await expect(
-			addTask({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+			updateTask({
+				task_id: '123e4567-e89b-12d3-a456-426614174000',
+				status: 'invalid',
+			}, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid priority', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
-			addTask({
-				project_id: '123e4567-e89b-12d3-a456-426614174000',
-				title: 'Test',
-				priority: 10, // Invalid: should be 1-5
+			updateTask({
+				task_id: '123e4567-e89b-12d3-a456-426614174000',
+				priority: 0,
 			}, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error for invalid estimated_minutes', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+	it('should throw error for invalid progress_percentage', async () => {
+		const ctx = createMockContext();
 		await expect(
-			addTask({
-				project_id: '123e4567-e89b-12d3-a456-426614174000',
-				title: 'Test',
-				estimated_minutes: 0, // Invalid: must be positive
+			updateTask({
+				task_id: '123e4567-e89b-12d3-a456-426614174000',
+				progress_percentage: 150,
 			}, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
-	it('should include blocking message for blocking tasks', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: { id: 'blocking-task', blocking: true }, error: null },
+	it('should update task successfully', async () => {
+		mockApiClient.updateTask.mockResolvedValue({
+			ok: true,
+			data: { success: true },
 		});
-		const ctx = createMockContext(supabase);
 
-		const result = await addTask(
+		const ctx = createMockContext();
+		const result = await updateTask(
 			{
-				project_id: '123e4567-e89b-12d3-a456-426614174000',
-				title: 'Blocking Task',
-				blocking: true,
+				task_id: '123e4567-e89b-12d3-a456-426614174000',
+				status: 'in_progress',
 			},
 			ctx
 		);
 
-		expect(result.result.blocking).toBe(true);
-		expect(result.result.message).toContain('BLOCKING TASK');
+		expect(result.result).toMatchObject({ success: true });
 	});
 
-	it('should use default priority when not provided', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: { id: 'task-1', blocking: false }, error: null },
+	it('should handle agent_task_limit error', async () => {
+		mockApiClient.updateTask.mockResolvedValue({
+			ok: false,
+			error: 'agent_task_limit: Agent already has a task in progress',
 		});
-		const ctx = createMockContext(supabase);
 
-		await addTask(
+		const ctx = createMockContext();
+		const result = await updateTask(
 			{
-				project_id: '123e4567-e89b-12d3-a456-426614174000',
-				title: 'Test',
+				task_id: '123e4567-e89b-12d3-a456-426614174000',
+				status: 'in_progress',
+			},
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			error: 'agent_task_limit',
+		});
+	});
+
+	it('should handle task_claimed error', async () => {
+		mockApiClient.updateTask.mockResolvedValue({
+			ok: false,
+			error: 'task_claimed: Task is being worked on by another agent',
+		});
+
+		const ctx = createMockContext();
+		const result = await updateTask(
+			{
+				task_id: '123e4567-e89b-12d3-a456-426614174000',
+				status: 'in_progress',
 			},
 			ctx
 		);
 
-		// Check that insert was called with priority: 3 (default)
-		expect(supabase.insert).toHaveBeenCalledWith(
-			expect.objectContaining({ priority: 3 })
+		expect(result.result).toMatchObject({
+			error: 'task_claimed',
+		});
+	});
+
+	it('should warn when setting in_progress without git_branch', async () => {
+		mockApiClient.updateTask.mockResolvedValue({
+			ok: true,
+			data: { success: true },
+		});
+
+		const ctx = createMockContext();
+		const result = await updateTask(
+			{
+				task_id: '123e4567-e89b-12d3-a456-426614174000',
+				status: 'in_progress',
+			},
+			ctx
 		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			warning: expect.stringContaining('git_branch not set'),
+			hint: expect.stringContaining('update_task again'),
+		});
+	});
+
+	it('should not warn when setting in_progress with git_branch', async () => {
+		mockApiClient.updateTask.mockResolvedValue({
+			ok: true,
+			data: { success: true },
+		});
+
+		const ctx = createMockContext();
+		const result = await updateTask(
+			{
+				task_id: '123e4567-e89b-12d3-a456-426614174000',
+				status: 'in_progress',
+				git_branch: 'feature/my-task',
+			},
+			ctx
+		);
+
+		expect(result.result).toMatchObject({ success: true });
+		expect(result.result).not.toHaveProperty('warning');
+	});
+
+	it('should not warn when updating status other than in_progress', async () => {
+		mockApiClient.updateTask.mockResolvedValue({
+			ok: true,
+			data: { success: true },
+		});
+
+		const ctx = createMockContext();
+		const result = await updateTask(
+			{
+				task_id: '123e4567-e89b-12d3-a456-426614174000',
+				status: 'completed',
+			},
+			ctx
+		);
+
+		expect(result.result).toMatchObject({ success: true });
+		expect(result.result).not.toHaveProperty('warning');
 	});
 });
 
 // ============================================================================
-// deleteTask Tests
+// completeTask Tests
 // ============================================================================
 
-describe('deleteTask', () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
+describe('completeTask', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing task_id', async () => {
+		const ctx = createMockContext();
+		await expect(completeTask({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
-	it('should delete a task successfully', async () => {
-		const supabase = createMockSupabase({
-			deleteResult: { data: null, error: null },
+	it('should throw error for invalid task_id', async () => {
+		const ctx = createMockContext();
+		await expect(
+			completeTask({ task_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should complete task successfully', async () => {
+		mockApiClient.completeTask.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				directive: 'Start next task',
+				auto_continue: true,
+				completed_task_id: '123e4567-e89b-12d3-a456-426614174000',
+				next_task: { id: 'task-2', title: 'Next task' },
+			},
 		});
-		const ctx = createMockContext(supabase);
 
-		const result = await deleteTask(
+		const ctx = createMockContext();
+		const result = await completeTask(
 			{ task_id: '123e4567-e89b-12d3-a456-426614174000' },
 			ctx
 		);
 
-		expect(result.result.success).toBe(true);
-		expect(result.result.deleted_id).toBe('123e4567-e89b-12d3-a456-426614174000');
-		expect(supabase.from).toHaveBeenCalledWith('tasks');
-		expect(supabase.delete).toHaveBeenCalled();
+		expect(result.result).toMatchObject({
+			success: true,
+			auto_continue: true,
+			next_task: expect.any(Object),
+		});
 	});
 
-	it('should throw error for missing task_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+	it('should include summary in API call', async () => {
+		mockApiClient.completeTask.mockResolvedValue({
+			ok: true,
+			data: { success: true },
+		});
 
-		await expect(deleteTask({}, ctx)).rejects.toThrow(ValidationError);
+		const ctx = createMockContext();
+		await completeTask(
+			{
+				task_id: '123e4567-e89b-12d3-a456-426614174000',
+				summary: 'Completed the feature',
+			},
+			ctx
+		);
+
+		expect(mockApiClient.completeTask).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			expect.objectContaining({ summary: 'Completed the feature' })
+		);
 	});
 
-	it('should throw error for invalid task_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+	it('should throw error when API returns error', async () => {
+		mockApiClient.completeTask.mockResolvedValue({
+			ok: false,
+			error: 'Task not found',
+		});
 
-		await expect(deleteTask({ task_id: 'invalid' }, ctx)).rejects.toThrow(ValidationError);
+		const ctx = createMockContext();
+		await expect(
+			completeTask({ task_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow('Failed to complete task: Task not found');
 	});
 });
 
 // ============================================================================
-// addTaskReference Tests
+// deleteTask Tests
 // ============================================================================
 
-describe('addTaskReference', () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
+describe('deleteTask', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing task_id', async () => {
+		const ctx = createMockContext();
+		await expect(deleteTask({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid task_id', async () => {
+		const ctx = createMockContext();
+		await expect(deleteTask({ task_id: 'invalid' }, ctx)).rejects.toThrow(ValidationError);
 	});
 
-	it('should add a reference successfully', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: { references: [] }, error: null },
-			updateResult: { data: null, error: null },
+	it('should delete task successfully', async () => {
+		mockApiClient.deleteTask.mockResolvedValue({
+			ok: true,
+			data: { success: true },
 		});
-		const ctx = createMockContext(supabase);
 
-		const result = await addTaskReference(
-			{
-				task_id: '123e4567-e89b-12d3-a456-426614174000',
-				url: 'https://github.com/user/repo/pull/123',
-				label: 'PR #123',
-			},
+		const ctx = createMockContext();
+		const result = await deleteTask(
+			{ task_id: '123e4567-e89b-12d3-a456-426614174000' },
 			ctx
 		);
 
-		expect(result.result.success).toBe(true);
-		expect(result.result.reference).toEqual({
-			url: 'https://github.com/user/repo/pull/123',
-			label: 'PR #123',
+		expect(result.result).toMatchObject({
+			success: true,
+			deleted_id: '123e4567-e89b-12d3-a456-426614174000',
 		});
-		expect(result.result.total_references).toBe(1);
 	});
+});
 
-	it('should throw error for missing task_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+// ============================================================================
+// addTaskReference Tests
+// ============================================================================
+
+describe('addTaskReference', () => {
+	beforeEach(() => vi.clearAllMocks());
 
+	it('should throw error for missing task_id', async () => {
+		const ctx = createMockContext();
 		await expect(
 			addTaskReference({ url: 'https://example.com' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for missing url', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
 			addTaskReference({ task_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
-	it('should reject duplicate URL', async () => {
-		const existingRef = { url: 'https://example.com', label: 'Existing' };
-		const supabase = createMockSupabase({
-			selectResult: { data: { references: [existingRef] }, error: null },
+	it('should add reference successfully', async () => {
+		mockApiClient.addTaskReference.mockResolvedValue({
+			ok: true,
+			data: { reference: { url: 'https://example.com', label: 'Test' } },
 		});
-		const ctx = createMockContext(supabase);
 
+		const ctx = createMockContext();
 		const result = await addTaskReference(
 			{
 				task_id: '123e4567-e89b-12d3-a456-426614174000',
 				url: 'https://example.com',
+				label: 'Test',
 			},
 			ctx
 		);
 
-		expect(result.result.success).toBe(false);
-		expect(result.result.error).toContain('already exists');
+		expect(result.result).toMatchObject({
+			success: true,
+			reference: expect.any(Object),
+		});
+	});
+
+	it('should handle duplicate reference error', async () => {
+		mockApiClient.addTaskReference.mockResolvedValue({
+			ok: false,
+			error: 'Reference already exists',
+		});
+
+		const ctx = createMockContext();
+		const result = await addTaskReference(
+			{
+				task_id: '123e4567-e89b-12d3-a456-426614174000',
+				url: 'https://example.com',
+			},
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: false,
+			error: expect.stringContaining('already exists'),
+		});
 	});
 });
 
@@ -438,18 +599,29 @@ describe('addTaskReference', () => {
 // ============================================================================
 
 describe('removeTaskReference', () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing task_id', async () => {
+		const ctx = createMockContext();
+		await expect(
+			removeTaskReference({ url: 'https://example.com' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for missing url', async () => {
+		const ctx = createMockContext();
+		await expect(
+			removeTaskReference({ task_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow(ValidationError);
 	});
 
-	it('should remove a reference successfully', async () => {
-		const existingRef = { url: 'https://example.com', label: 'Test' };
-		const supabase = createMockSupabase({
-			selectResult: { data: { references: [existingRef] }, error: null },
-			updateResult: { data: null, error: null },
+	it('should remove reference successfully', async () => {
+		mockApiClient.removeTaskReference.mockResolvedValue({
+			ok: true,
+			data: { success: true },
 		});
-		const ctx = createMockContext(supabase);
 
+		const ctx = createMockContext();
 		const result = await removeTaskReference(
 			{
 				task_id: '123e4567-e89b-12d3-a456-426614174000',
@@ -458,145 +630,289 @@ describe('removeTaskReference', () => {
 			ctx
 		);
 
-		expect(result.result.success).toBe(true);
-		expect(result.result.remaining_references).toBe(0);
+		expect(result.result).toMatchObject({ success: true });
 	});
 
-	it('should return error when URL not found', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: { references: [] }, error: null },
+	it('should handle not found error', async () => {
+		mockApiClient.removeTaskReference.mockResolvedValue({
+			ok: false,
+			error: 'Reference not found',
 		});
-		const ctx = createMockContext(supabase);
 
+		const ctx = createMockContext();
 		const result = await removeTaskReference(
 			{
 				task_id: '123e4567-e89b-12d3-a456-426614174000',
-				url: 'https://nonexistent.com',
+				url: 'https://example.com',
 			},
 			ctx
 		);
 
-		expect(result.result.success).toBe(false);
-		expect(result.result.error).toContain('not found');
+		expect(result.result).toMatchObject({
+			success: false,
+			error: expect.stringContaining('not found'),
+		});
 	});
 });
 
 // ============================================================================
-// getProjectGitConfig Tests
+// batchUpdateTasks Tests
 // ============================================================================
 
-describe('getProjectGitConfig', () => {
-	it('should return git config for a project', async () => {
-		const mockConfig = {
-			git_workflow: 'github-flow',
-			git_main_branch: 'main',
-			git_develop_branch: null,
-			git_auto_branch: true,
-		};
+describe('batchUpdateTasks', () => {
+	beforeEach(() => vi.clearAllMocks());
 
-		const supabase = createMockSupabase({
-			selectResult: { data: mockConfig, error: null },
-		});
+	it('should throw error for missing updates array', async () => {
+		const ctx = createMockContext();
+		await expect(batchUpdateTasks({}, ctx)).rejects.toThrow(ValidationError);
+	});
 
-		const result = await getProjectGitConfig(supabase, '123e4567-e89b-12d3-a456-426614174000');
+	it('should throw error for empty updates array', async () => {
+		const ctx = createMockContext();
+		await expect(batchUpdateTasks({ updates: [] }, ctx)).rejects.toThrow(ValidationError);
+	});
 
-		expect(result).toEqual(mockConfig);
-		expect(supabase.from).toHaveBeenCalledWith('projects');
+	it('should throw error for too many updates', async () => {
+		const ctx = createMockContext();
+		const updates = Array(51).fill({
+			task_id: '123e4567-e89b-12d3-a456-426614174000',
+		});
+		await expect(batchUpdateTasks({ updates }, ctx)).rejects.toThrow(ValidationError);
 	});
 
-	it('should return null when project not found', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: { message: 'Not found' } },
+	it('should batch update tasks successfully', async () => {
+		mockApiClient.batchUpdateTasks.mockResolvedValue({
+			ok: true,
+			data: { success: true, updated_count: 2 },
 		});
 
-		const result = await getProjectGitConfig(supabase, '123e4567-e89b-12d3-a456-426614174000');
+		const ctx = createMockContext();
+		const result = await batchUpdateTasks(
+			{
+				updates: [
+					{ task_id: '123e4567-e89b-12d3-a456-426614174000', status: 'in_progress' },
+					{ task_id: '123e4567-e89b-12d3-a456-426614174001', status: 'completed' },
+				],
+			},
+			ctx
+		);
 
-		expect(result).toBeNull();
+		expect(result.result).toMatchObject({
+			success: true,
+			total: 2,
+			succeeded: 2,
+		});
 	});
 });
 
 // ============================================================================
-// completeTask Tests
+// batchCompleteTasks Tests
 // ============================================================================
 
-describe('completeTask', () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
+describe('batchCompleteTasks', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing completions array', async () => {
+		const ctx = createMockContext();
+		await expect(batchCompleteTasks({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error for missing task_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+	it('should throw error for empty completions array', async () => {
+		const ctx = createMockContext();
+		await expect(batchCompleteTasks({ completions: [] }, ctx)).rejects.toThrow(ValidationError);
+	});
 
-		await expect(completeTask({}, ctx)).rejects.toThrow(ValidationError);
+	it('should batch complete tasks successfully', async () => {
+		mockApiClient.batchCompleteTasks.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				completed_count: 2,
+				next_task: { id: 'task-3', title: 'Next' },
+			},
+		});
+
+		const ctx = createMockContext();
+		const result = await batchCompleteTasks(
+			{
+				completions: [
+					{ task_id: '123e4567-e89b-12d3-a456-426614174000' },
+					{ task_id: '123e4567-e89b-12d3-a456-426614174001', summary: 'Done' },
+				],
+			},
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			total: 2,
+			succeeded: 2,
+			next_task: expect.any(Object),
+		});
 	});
+});
 
-	it('should throw error for invalid task_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+// ============================================================================
+// addSubtask Tests
+// ============================================================================
+
+describe('addSubtask', () => {
+	beforeEach(() => vi.clearAllMocks());
 
-		await expect(completeTask({ task_id: 'invalid' }, ctx)).rejects.toThrow(ValidationError);
+	it('should throw error for missing parent_task_id', async () => {
+		const ctx = createMockContext();
+		await expect(addSubtask({ title: 'Subtask' }, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for missing title', async () => {
+		const ctx = createMockContext();
+		await expect(
+			addSubtask({ parent_task_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error when task not found', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: { message: 'Not found' } },
+	it('should add subtask successfully', async () => {
+		mockApiClient.addSubtask.mockResolvedValue({
+			ok: true,
+			data: {
+				subtask_id: 'subtask-1',
+				parent_task_id: '123e4567-e89b-12d3-a456-426614174000',
+			},
 		});
-		const ctx = createMockContext(supabase);
 
-		await expect(
-			completeTask({ task_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow('Task not found');
+		const ctx = createMockContext();
+		const result = await addSubtask(
+			{
+				parent_task_id: '123e4567-e89b-12d3-a456-426614174000',
+				title: 'Subtask 1',
+			},
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			subtask_id: 'subtask-1',
+		});
+	});
+
+	it('should handle nested subtask error', async () => {
+		mockApiClient.addSubtask.mockResolvedValue({
+			ok: false,
+			error: 'Cannot create subtask of a subtask',
+		});
+
+		const ctx = createMockContext();
+		const result = await addSubtask(
+			{
+				parent_task_id: '123e4567-e89b-12d3-a456-426614174000',
+				title: 'Nested subtask',
+			},
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: false,
+			error: 'Cannot create subtask of a subtask',
+		});
 	});
 });
 
 // ============================================================================
-// updateTask Tests
+// getSubtasks Tests
 // ============================================================================
 
-describe('updateTask', () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
+describe('getSubtasks', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing parent_task_id', async () => {
+		const ctx = createMockContext();
+		await expect(getSubtasks({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error for missing task_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+	it('should throw error for invalid parent_task_id', async () => {
+		const ctx = createMockContext();
+		await expect(
+			getSubtasks({ parent_task_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should return subtasks successfully', async () => {
+		mockApiClient.getSubtasks.mockResolvedValue({
+			ok: true,
+			data: {
+				subtasks: [
+					{ id: 'sub-1', title: 'Subtask 1', status: 'pending' },
+					{ id: 'sub-2', title: 'Subtask 2', status: 'completed' },
+				],
+				stats: { total: 2, completed: 1, progress_percentage: 50 },
+			},
+		});
 
-		await expect(updateTask({}, ctx)).rejects.toThrow(ValidationError);
+		const ctx = createMockContext();
+		const result = await getSubtasks(
+			{ parent_task_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			subtasks: expect.any(Array),
+			stats: expect.objectContaining({ total: 2 }),
+		});
 	});
+});
 
-	it('should throw error for invalid task_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+// ============================================================================
+// getValidationApprovedGitInstructions Tests
+// ============================================================================
 
-		await expect(updateTask({ task_id: 'invalid' }, ctx)).rejects.toThrow(ValidationError);
+describe('getValidationApprovedGitInstructions', () => {
+	it('should return undefined for none workflow', () => {
+		const result = getValidationApprovedGitInstructions(
+			{ git_workflow: 'none', git_main_branch: 'main' },
+			'feature/test'
+		);
+		expect(result).toBeUndefined();
 	});
 
-	it('should throw error for invalid status', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+	it('should return undefined for trunk-based workflow', () => {
+		const result = getValidationApprovedGitInstructions(
+			{ git_workflow: 'trunk-based', git_main_branch: 'main' },
+			'feature/test'
+		);
+		expect(result).toBeUndefined();
+	});
 
-		await expect(
-			updateTask({ task_id: '123e4567-e89b-12d3-a456-426614174000', status: 'invalid' }, ctx)
-		).rejects.toThrow(ValidationError);
+	it('should return undefined when no task branch', () => {
+		const result = getValidationApprovedGitInstructions(
+			{ git_workflow: 'github-flow', git_main_branch: 'main' },
+			undefined
+		);
+		expect(result).toBeUndefined();
 	});
 
-	it('should throw error for invalid priority', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+	it('should return merge instructions for github-flow', () => {
+		const result = getValidationApprovedGitInstructions(
+			{ git_workflow: 'github-flow', git_main_branch: 'main' },
+			'feature/test'
+		);
 
-		await expect(
-			updateTask({ task_id: '123e4567-e89b-12d3-a456-426614174000', priority: 0 }, ctx)
-		).rejects.toThrow(ValidationError);
+		expect(result).toMatchObject({
+			target_branch: 'main',
+			feature_branch: 'feature/test',
+			steps: expect.any(Array),
+			cleanup: expect.any(Array),
+		});
 	});
 
-	it('should throw error for invalid progress_percentage', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+	it('should return merge instructions for git-flow with develop', () => {
+		const result = getValidationApprovedGitInstructions(
+			{ git_workflow: 'git-flow', git_main_branch: 'main', git_develop_branch: 'develop' },
+			'feature/test'
+		);
 
-		await expect(
-			updateTask({ task_id: '123e4567-e89b-12d3-a456-426614174000', progress_percentage: 150 }, ctx)
-		).rejects.toThrow(ValidationError);
+		expect(result).toMatchObject({
+			target_branch: 'develop',
+			feature_branch: 'feature/test',
+		});
 	});
 });