@vibescope/mcp-server 0.0.1 → 0.1.0

package/src/handlers/bodies-of-work.test.ts

@@ -1,6 +1,4 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { SupabaseClient } from '@supabase/supabase-js';
-import type { HandlerContext, TokenUsage } from './types.js';
 import {
 	createBodyOfWork,
 	updateBodyOfWork,
@@ -16,123 +14,8 @@ import {
 	getNextBodyOfWorkTask,
 } from './bodies-of-work.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 };
-	deleteResult?: { data: unknown; error: unknown };
-	countResult?: { count: number | null; 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(),
-		head: 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);
-			}
-			if (currentOperation === 'delete') {
-				return Promise.resolve(overrides.deleteResult ?? 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') {
-				const result = overrides.countResult ?? overrides.selectResult ?? defaultResult;
-				return Promise.resolve(result).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;
-}
-
-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(),
-	};
-}
+import { createMockContext } from './__test-utils__.js';
+import { mockApiClient } from './__test-setup__.js';
 
 const VALID_UUID = '123e4567-e89b-12d3-a456-426614174000';
 const VALID_UUID_2 = '223e4567-e89b-12d3-a456-426614174001';
@@ -146,35 +29,30 @@ describe('createBodyOfWork', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(createBodyOfWork({ title: 'Test' }, 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(
 			createBodyOfWork({ project_id: 'invalid', title: 'Test' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for missing title', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
 			createBodyOfWork({ project_id: VALID_UUID }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should create body of work with required fields', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: { id: 'bow-1' }, error: null },
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { body_of_work_id: 'bow-1' },
 		});
-		const ctx = createMockContext(supabase);
 
 		const result = await createBodyOfWork(
 			{ project_id: VALID_UUID, title: 'Sprint 1' },
@@ -187,24 +65,22 @@ describe('createBodyOfWork', () => {
 			title: 'Sprint 1',
 			status: 'draft',
 		});
-		expect(supabase.from).toHaveBeenCalledWith('bodies_of_work');
-		expect(supabase.insert).toHaveBeenCalledWith(
+		expect(mockApiClient.proxy).toHaveBeenCalledWith(
+			'create_body_of_work',
 			expect.objectContaining({
 				project_id: VALID_UUID,
 				title: 'Sprint 1',
-				auto_deploy_on_completion: false,
-				deploy_environment: 'production',
-				deploy_version_bump: 'minor',
-				deploy_trigger: 'all_completed_validated',
-			})
+			}),
+			expect.any(Object)
 		);
 	});
 
 	it('should create body of work with all optional fields', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: { id: 'bow-2' }, error: null },
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { body_of_work_id: 'bow-2' },
 		});
-		const ctx = createMockContext(supabase);
 
 		await createBodyOfWork(
 			{
@@ -219,22 +95,26 @@ describe('createBodyOfWork', () => {
 			ctx
 		);
 
-		expect(supabase.insert).toHaveBeenCalledWith(
+		expect(mockApiClient.proxy).toHaveBeenCalledWith(
+			'create_body_of_work',
 			expect.objectContaining({
+				title: 'Release 2.0',
 				description: 'Major release',
 				auto_deploy_on_completion: true,
 				deploy_environment: 'staging',
 				deploy_version_bump: 'major',
 				deploy_trigger: 'all_completed',
-			})
+			}),
+			expect.any(Object)
 		);
 	});
 
-	it('should throw error when database insert fails', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: null, error: { message: 'Insert failed' } },
+	it('should throw error when API call fails', async () => {
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: false,
+			error: 'Insert failed',
 		});
-		const ctx = createMockContext(supabase);
 
 		await expect(
 			createBodyOfWork({ project_id: VALID_UUID, title: 'Test' }, ctx)
@@ -250,30 +130,27 @@ describe('updateBodyOfWork', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing body_of_work_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(updateBodyOfWork({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should return success when no updates provided', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		const result = await updateBodyOfWork({ body_of_work_id: VALID_UUID }, ctx);
 
 		expect(result.result).toMatchObject({
 			success: true,
 			message: 'No updates provided',
 		});
-		expect(supabase.update).not.toHaveBeenCalled();
+		expect(mockApiClient.proxy).not.toHaveBeenCalled();
 	});
 
 	it('should update title', async () => {
-		const supabase = createMockSupabase({
-			updateResult: { data: null, error: null },
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { success: true },
 		});
-		const ctx = createMockContext(supabase);
 
 		const result = await updateBodyOfWork(
 			{ body_of_work_id: VALID_UUID, title: 'New Title' },
@@ -281,14 +158,18 @@ describe('updateBodyOfWork', () => {
 		);
 
 		expect(result.result).toMatchObject({ success: true, body_of_work_id: VALID_UUID });
-		expect(supabase.update).toHaveBeenCalledWith({ title: 'New Title' });
+		expect(mockApiClient.proxy).toHaveBeenCalledWith('update_body_of_work', expect.objectContaining({
+			body_of_work_id: VALID_UUID,
+			title: 'New Title',
+		}));
 	});
 
 	it('should update multiple fields', async () => {
-		const supabase = createMockSupabase({
-			updateResult: { data: null, error: null },
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { success: true },
 		});
-		const ctx = createMockContext(supabase);
 
 		await updateBodyOfWork(
 			{
@@ -300,11 +181,11 @@ describe('updateBodyOfWork', () => {
 			ctx
 		);
 
-		expect(supabase.update).toHaveBeenCalledWith({
+		expect(mockApiClient.proxy).toHaveBeenCalledWith('update_body_of_work', expect.objectContaining({
 			title: 'Updated',
 			description: 'New desc',
 			auto_deploy_on_completion: true,
-		});
+		}));
 	});
 });
 
@@ -316,76 +197,39 @@ describe('getBodyOfWork', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing body_of_work_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(getBodyOfWork({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error when body of work not found', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: { message: 'Not found' } },
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: false,
+			error: 'Not found',
 		});
-		const ctx = createMockContext(supabase);
 
 		await expect(
 			getBodyOfWork({ body_of_work_id: VALID_UUID }, ctx)
-		).rejects.toThrow('Body of work not found');
+		).rejects.toThrow('Failed to get body of work');
 	});
 
 	it('should return body of work with tasks organized by phase', async () => {
-		const mockBow = {
-			id: 'bow-1',
-			title: 'Sprint 1',
-			status: 'active',
-		};
-		const mockTaskLinks = [
-			{ phase: 'pre', order_index: 0, tasks: { id: 't1', title: 'Setup', status: 'completed', priority: 1, progress_percentage: 100 } },
-			{ phase: 'core', order_index: 0, tasks: { id: 't2', title: 'Feature A', status: 'in_progress', priority: 2, progress_percentage: 50 } },
-			{ phase: 'core', order_index: 1, tasks: { id: 't3', title: 'Feature B', status: 'pending', priority: 2, progress_percentage: 0 } },
-			{ phase: 'post', order_index: 0, tasks: { id: 't4', title: 'Cleanup', status: 'pending', priority: 3, progress_percentage: 0 } },
-		];
-
-		const supabase = createMockSupabase({
-			selectResult: { data: mockBow, error: null },
-		});
-
-		// Override for task links query
-		let queryCount = 0;
-		vi.mocked(supabase.from).mockImplementation((table: string) => {
-			queryCount++;
-			if (table === 'bodies_of_work') {
-				return {
-					...supabase,
-					select: vi.fn().mockReturnValue({
-						...supabase,
-						eq: vi.fn().mockReturnValue({
-							...supabase,
-							single: vi.fn().mockResolvedValue({ data: mockBow, error: null }),
-						}),
-					}),
-				} as unknown as ReturnType<SupabaseClient['from']>;
-			}
-			if (table === 'body_of_work_tasks') {
-				return {
-					...supabase,
-					select: vi.fn().mockReturnValue({
-						...supabase,
-						eq: vi.fn().mockReturnValue({
-							...supabase,
-							order: vi.fn().mockReturnValue({
-								then: (resolve: (val: unknown) => void) =>
-									Promise.resolve({ data: mockTaskLinks, error: null }).then(resolve),
-							}),
-						}),
-					}),
-				} as unknown as ReturnType<SupabaseClient['from']>;
-			}
-			return supabase as unknown as ReturnType<SupabaseClient['from']>;
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: {
+				id: 'bow-1',
+				title: 'Sprint 1',
+				status: 'active',
+				pre_tasks: [{ id: 't1', title: 'Setup' }],
+				core_tasks: [{ id: 't2', title: 'Feature A' }],
+				post_tasks: [{ id: 't3', title: 'Cleanup' }],
+				total_tasks: 3,
+				completed_tasks: 1,
+				progress_percentage: 33,
+			},
 		});
 
-		const ctx = createMockContext(supabase);
-
 		const result = await getBodyOfWork({ body_of_work_id: VALID_UUID }, ctx);
 
 		expect(result.result).toHaveProperty('pre_tasks');
@@ -403,30 +247,16 @@ describe('getBodiesOfWork', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(getBodiesOfWork({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should return empty array when no bodies of work exist', async () => {
-		const supabase = createMockSupabase();
-
-		vi.mocked(supabase.from).mockReturnValue({
-			...supabase,
-			select: vi.fn().mockReturnValue({
-				...supabase,
-				eq: vi.fn().mockReturnValue({
-					...supabase,
-					order: vi.fn().mockReturnValue({
-						then: (resolve: (val: unknown) => void) =>
-							Promise.resolve({ data: [], error: null }).then(resolve),
-					}),
-				}),
-			}),
-		} as unknown as ReturnType<SupabaseClient['from']>);
-
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { bodies_of_work: [], total_count: 0 },
+		});
 
 		const result = await getBodiesOfWork({ project_id: VALID_UUID }, ctx);
 
@@ -434,13 +264,18 @@ describe('getBodiesOfWork', () => {
 	});
 
 	it('should filter by status when provided', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { bodies_of_work: [], total_count: 0 },
+		});
 
 		await getBodiesOfWork({ project_id: VALID_UUID, status: 'active' }, ctx);
 
-		expect(supabase.eq).toHaveBeenCalledWith('project_id', VALID_UUID);
-		expect(supabase.eq).toHaveBeenCalledWith('status', 'active');
+		expect(mockApiClient.proxy).toHaveBeenCalledWith('get_bodies_of_work', expect.objectContaining({
+			project_id: VALID_UUID,
+			status: 'active',
+		}));
 	});
 });
 
@@ -452,17 +287,16 @@ describe('deleteBodyOfWork', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing body_of_work_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(deleteBodyOfWork({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should delete body of work successfully', async () => {
-		const supabase = createMockSupabase({
-			deleteResult: { data: null, error: null },
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { success: true },
 		});
-		const ctx = createMockContext(supabase);
 
 		const result = await deleteBodyOfWork({ body_of_work_id: VALID_UUID }, ctx);
 
@@ -470,8 +304,9 @@ describe('deleteBodyOfWork', () => {
 			success: true,
 			message: 'Body of work deleted. Tasks are preserved.',
 		});
-		expect(supabase.from).toHaveBeenCalledWith('bodies_of_work');
-		expect(supabase.delete).toHaveBeenCalled();
+		expect(mockApiClient.proxy).toHaveBeenCalledWith('delete_body_of_work', expect.objectContaining({
+			body_of_work_id: VALID_UUID,
+		}));
 	});
 });
 
@@ -483,158 +318,44 @@ describe('addTaskToBodyOfWork', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing body_of_work_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
 			addTaskToBodyOfWork({ task_id: VALID_UUID }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for missing task_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
 			addTaskToBodyOfWork({ body_of_work_id: VALID_UUID }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error when body of work not found', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: { message: 'Not found' } },
+	it('should throw error when API returns error', async () => {
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: false,
+			error: 'Body of work not found',
 		});
-		const ctx = createMockContext(supabase);
 
 		await expect(
 			addTaskToBodyOfWork({ body_of_work_id: VALID_UUID, task_id: VALID_UUID_2 }, ctx)
-		).rejects.toThrow('Body of work not found');
-	});
-
-	it('should throw error when body of work is completed', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: { status: 'completed' }, error: null },
-		});
-		const ctx = createMockContext(supabase);
-
-		await expect(
-			addTaskToBodyOfWork({ body_of_work_id: VALID_UUID, task_id: VALID_UUID_2 }, ctx)
-		).rejects.toThrow('Cannot add tasks to completed body of work');
-	});
-
-	it('should throw error when task is already in a body of work', async () => {
-		const supabase = createMockSupabase();
-		let callCount = 0;
-
-		vi.mocked(supabase.from).mockImplementation((table: string) => {
-			if (table === 'bodies_of_work') {
-				return {
-					...supabase,
-					select: vi.fn().mockReturnValue({
-						...supabase,
-						eq: vi.fn().mockReturnValue({
-							...supabase,
-							single: vi.fn().mockResolvedValue({ data: { status: 'draft' }, error: null }),
-						}),
-					}),
-				} as unknown as ReturnType<SupabaseClient['from']>;
-			}
-			if (table === 'body_of_work_tasks') {
-				callCount++;
-				if (callCount === 1) {
-					// First call - check existing link
-					return {
-						...supabase,
-						select: vi.fn().mockReturnValue({
-							...supabase,
-							eq: vi.fn().mockReturnValue({
-								...supabase,
-								single: vi.fn().mockResolvedValue({ data: { body_of_work_id: 'other-bow' }, error: null }),
-							}),
-						}),
-					} as unknown as ReturnType<SupabaseClient['from']>;
-				}
-			}
-			return supabase as unknown as ReturnType<SupabaseClient['from']>;
-		});
-
-		const ctx = createMockContext(supabase);
-
-		await expect(
-			addTaskToBodyOfWork({ body_of_work_id: VALID_UUID, task_id: VALID_UUID_2 }, ctx)
-		).rejects.toThrow('Task is already assigned to a body of work');
+		).rejects.toThrow('Failed to add task to body of work');
 	});
 
 	it('should add task with default phase "core"', async () => {
-		const supabase = createMockSupabase();
-		let bowCallCount = 0;
-		let taskLinksCallCount = 0;
-
-		vi.mocked(supabase.from).mockImplementation((table: string) => {
-			if (table === 'bodies_of_work') {
-				bowCallCount++;
-				return {
-					...supabase,
-					select: vi.fn().mockReturnValue({
-						...supabase,
-						eq: vi.fn().mockReturnValue({
-							...supabase,
-							single: vi.fn().mockResolvedValue({ data: { status: 'draft' }, error: null }),
-						}),
-					}),
-				} as unknown as ReturnType<SupabaseClient['from']>;
-			}
-			if (table === 'body_of_work_tasks') {
-				taskLinksCallCount++;
-				if (taskLinksCallCount === 1) {
-					// Check existing link - none
-					return {
-						...supabase,
-						select: vi.fn().mockReturnValue({
-							...supabase,
-							eq: vi.fn().mockReturnValue({
-								...supabase,
-								single: vi.fn().mockResolvedValue({ data: null, error: null }),
-							}),
-						}),
-					} as unknown as ReturnType<SupabaseClient['from']>;
-				}
-				if (taskLinksCallCount === 2) {
-					// Get max order - none
-					return {
-						...supabase,
-						select: vi.fn().mockReturnValue({
-							...supabase,
-							eq: vi.fn().mockReturnValue({
-								...supabase,
-								eq: vi.fn().mockReturnValue({
-									...supabase,
-									order: vi.fn().mockReturnValue({
-										...supabase,
-										limit: vi.fn().mockReturnValue({
-											...supabase,
-											single: vi.fn().mockResolvedValue({ data: null, error: null }),
-										}),
-									}),
-								}),
-							}),
-						}),
-					} as unknown as ReturnType<SupabaseClient['from']>;
-				}
-				// Insert
-				return {
-					...supabase,
-					insert: vi.fn().mockReturnValue({
-						then: (resolve: (val: unknown) => void) =>
-							Promise.resolve({ data: null, error: null }).then(resolve),
-					}),
-				} as unknown as ReturnType<SupabaseClient['from']>;
-			}
-			return supabase as unknown as ReturnType<SupabaseClient['from']>;
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				body_of_work_id: VALID_UUID,
+				task_id: VALID_UUID_2,
+				phase: 'core',
+				order_index: 0,
+			},
 		});
 
-		const ctx = createMockContext(supabase);
-
 		const result = await addTaskToBodyOfWork(
 			{ body_of_work_id: VALID_UUID, task_id: VALID_UUID_2 },
 			ctx
@@ -648,6 +369,30 @@ describe('addTaskToBodyOfWork', () => {
 			order_index: 0,
 		});
 	});
+
+	it('should add task with specified phase', async () => {
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: {
+				body_of_work_id: VALID_UUID,
+				task_id: VALID_UUID_2,
+				phase: 'pre',
+				order_index: 0,
+			},
+		});
+
+		await addTaskToBodyOfWork(
+			{ body_of_work_id: VALID_UUID, task_id: VALID_UUID_2, phase: 'pre' },
+			ctx
+		);
+
+		expect(mockApiClient.proxy).toHaveBeenCalledWith('add_task_to_body_of_work', expect.objectContaining({
+			body_of_work_id: VALID_UUID,
+			task_id: VALID_UUID_2,
+			phase: 'pre',
+		}));
+	});
 });
 
 // ============================================================================
@@ -658,64 +403,23 @@ describe('removeTaskFromBodyOfWork', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing task_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(removeTaskFromBodyOfWork({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
-	it('should return success when task is not in any body of work', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: null },
+	it('should remove task successfully', async () => {
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { success: true },
 		});
-		const ctx = createMockContext(supabase);
 
 		const result = await removeTaskFromBodyOfWork({ task_id: VALID_UUID }, ctx);
 
-		expect(result.result).toMatchObject({
-			success: true,
-			message: 'Task is not in any body of work',
-		});
-	});
-
-	it('should throw error when body of work is completed', async () => {
-		const supabase = createMockSupabase();
-		let callCount = 0;
-
-		vi.mocked(supabase.from).mockImplementation((table: string) => {
-			callCount++;
-			if (table === 'body_of_work_tasks' && callCount === 1) {
-				return {
-					...supabase,
-					select: vi.fn().mockReturnValue({
-						...supabase,
-						eq: vi.fn().mockReturnValue({
-							...supabase,
-							single: vi.fn().mockResolvedValue({ data: { body_of_work_id: 'bow-1' }, error: null }),
-						}),
-					}),
-				} as unknown as ReturnType<SupabaseClient['from']>;
-			}
-			if (table === 'bodies_of_work') {
-				return {
-					...supabase,
-					select: vi.fn().mockReturnValue({
-						...supabase,
-						eq: vi.fn().mockReturnValue({
-							...supabase,
-							single: vi.fn().mockResolvedValue({ data: { status: 'completed' }, error: null }),
-						}),
-					}),
-				} as unknown as ReturnType<SupabaseClient['from']>;
-			}
-			return supabase as unknown as ReturnType<SupabaseClient['from']>;
-		});
-
-		const ctx = createMockContext(supabase);
-
-		await expect(
-			removeTaskFromBodyOfWork({ task_id: VALID_UUID }, ctx)
-		).rejects.toThrow('Cannot remove tasks from a completed body of work');
+		expect(result.result).toMatchObject({ success: true });
+		expect(mockApiClient.proxy).toHaveBeenCalledWith('remove_task_from_body_of_work', expect.objectContaining({
+			task_id: VALID_UUID,
+		}));
 	});
 });
 
@@ -727,121 +431,34 @@ describe('activateBodyOfWork', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing body_of_work_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(activateBodyOfWork({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error when body of work not found', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: { message: 'Not found' } },
-		});
-		const ctx = createMockContext(supabase);
-
-		await expect(
-			activateBodyOfWork({ body_of_work_id: VALID_UUID }, ctx)
-		).rejects.toThrow('Body of work not found');
-	});
-
-	it('should throw error when body of work is not draft', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: { status: 'active', title: 'Test' }, error: null },
-		});
-		const ctx = createMockContext(supabase);
-
-		await expect(
-			activateBodyOfWork({ body_of_work_id: VALID_UUID }, ctx)
-		).rejects.toThrow('Can only activate draft bodies of work');
-	});
-
-	it('should throw error when body of work has no tasks', async () => {
-		const supabase = createMockSupabase();
-		let callCount = 0;
-
-		vi.mocked(supabase.from).mockImplementation((table: string) => {
-			callCount++;
-			if (table === 'bodies_of_work' && callCount === 1) {
-				return {
-					...supabase,
-					select: vi.fn().mockReturnValue({
-						...supabase,
-						eq: vi.fn().mockReturnValue({
-							...supabase,
-							single: vi.fn().mockResolvedValue({ data: { status: 'draft', title: 'Test' }, error: null }),
-						}),
-					}),
-				} as unknown as ReturnType<SupabaseClient['from']>;
-			}
-			if (table === 'body_of_work_tasks') {
-				return {
-					...supabase,
-					select: vi.fn().mockReturnValue({
-						...supabase,
-						eq: vi.fn().mockReturnValue({
-							then: (resolve: (val: unknown) => void) =>
-								Promise.resolve({ count: 0, error: null }).then(resolve),
-						}),
-					}),
-				} as unknown as ReturnType<SupabaseClient['from']>;
-			}
-			return supabase as unknown as ReturnType<SupabaseClient['from']>;
+	it('should throw error when API returns error', async () => {
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: false,
+			error: 'Body of work not found',
 		});
 
-		const ctx = createMockContext(supabase);
-
 		await expect(
 			activateBodyOfWork({ body_of_work_id: VALID_UUID }, ctx)
-		).rejects.toThrow('Cannot activate body of work with no tasks');
+		).rejects.toThrow('Failed to activate body of work');
 	});
 
-	it('should activate body of work with tasks', async () => {
-		const supabase = createMockSupabase();
-		let callCount = 0;
-
-		vi.mocked(supabase.from).mockImplementation((table: string) => {
-			callCount++;
-			if (table === 'bodies_of_work' && callCount === 1) {
-				return {
-					...supabase,
-					select: vi.fn().mockReturnValue({
-						...supabase,
-						eq: vi.fn().mockReturnValue({
-							...supabase,
-							single: vi.fn().mockResolvedValue({ data: { status: 'draft', title: 'Sprint 1' }, error: null }),
-						}),
-					}),
-				} as unknown as ReturnType<SupabaseClient['from']>;
-			}
-			if (table === 'body_of_work_tasks') {
-				return {
-					...supabase,
-					select: vi.fn().mockReturnValue({
-						...supabase,
-						eq: vi.fn().mockReturnValue({
-							then: (resolve: (val: unknown) => void) =>
-								Promise.resolve({ count: 3, error: null }).then(resolve),
-						}),
-					}),
-				} as unknown as ReturnType<SupabaseClient['from']>;
-			}
-			if (table === 'bodies_of_work' && callCount > 2) {
-				return {
-					...supabase,
-					update: vi.fn().mockReturnValue({
-						...supabase,
-						eq: vi.fn().mockReturnValue({
-							then: (resolve: (val: unknown) => void) =>
-								Promise.resolve({ data: null, error: null }).then(resolve),
-						}),
-					}),
-				} as unknown as ReturnType<SupabaseClient['from']>;
-			}
-			return supabase as unknown as ReturnType<SupabaseClient['from']>;
+	it('should activate body of work successfully', async () => {
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				body_of_work_id: VALID_UUID,
+				title: 'Sprint 1',
+				status: 'active',
+			},
 		});
 
-		const ctx = createMockContext(supabase);
-
 		const result = await activateBodyOfWork({ body_of_work_id: VALID_UUID }, ctx);
 
 		expect(result.result).toMatchObject({
@@ -861,18 +478,14 @@ describe('addTaskDependency', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing body_of_work_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
 			addTaskDependency({ task_id: VALID_UUID, depends_on_task_id: VALID_UUID_2 }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error when task depends on itself', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
 			addTaskDependency({
 				body_of_work_id: VALID_UUID,
@@ -882,32 +495,28 @@ describe('addTaskDependency', () => {
 		).rejects.toThrow('A task cannot depend on itself');
 	});
 
-	it('should throw error when tasks do not belong to body of work', async () => {
-		const supabase = createMockSupabase();
-
-		vi.mocked(supabase.from).mockReturnValue({
-			...supabase,
-			select: vi.fn().mockReturnValue({
-				...supabase,
-				eq: vi.fn().mockReturnValue({
-					...supabase,
-					in: vi.fn().mockReturnValue({
-						then: (resolve: (val: unknown) => void) =>
-							Promise.resolve({ data: [{ task_id: VALID_UUID_2 }], error: null }).then(resolve),
-					}),
-				}),
-			}),
-		} as unknown as ReturnType<SupabaseClient['from']>);
-
-		const ctx = createMockContext(supabase);
-
-		await expect(
-			addTaskDependency({
-				body_of_work_id: VALID_UUID,
+	it('should add dependency successfully', async () => {
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
 				task_id: VALID_UUID_2,
 				depends_on_task_id: VALID_UUID_3,
-			}, ctx)
-		).rejects.toThrow('Both tasks must belong to the specified body of work');
+			},
+		});
+
+		const result = await addTaskDependency({
+			body_of_work_id: VALID_UUID,
+			task_id: VALID_UUID_2,
+			depends_on_task_id: VALID_UUID_3,
+		}, ctx);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			task_id: VALID_UUID_2,
+			depends_on_task_id: VALID_UUID_3,
+		});
 	});
 });
 
@@ -919,28 +528,29 @@ describe('removeTaskDependency', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing task_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
 			removeTaskDependency({ depends_on_task_id: VALID_UUID }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for missing depends_on_task_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(
 			removeTaskDependency({ task_id: VALID_UUID }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should remove dependency successfully', async () => {
-		const supabase = createMockSupabase({
-			deleteResult: { data: null, error: null },
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				task_id: VALID_UUID,
+				depends_on_task_id: VALID_UUID_2,
+			},
 		});
-		const ctx = createMockContext(supabase);
 
 		const result = await removeTaskDependency(
 			{ task_id: VALID_UUID, depends_on_task_id: VALID_UUID_2 },
@@ -963,9 +573,7 @@ describe('getTaskDependencies', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error when neither body_of_work_id nor task_id provided', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(getTaskDependencies({}, ctx)).rejects.toThrow(
 			'Either body_of_work_id or task_id is required'
 		);
@@ -976,46 +584,33 @@ describe('getTaskDependencies', () => {
 			{ id: 'd1', task_id: 't1', depends_on_task_id: 't2', created_at: '2026-01-14' },
 		];
 
-		const supabase = createMockSupabase();
-
-		vi.mocked(supabase.from).mockReturnValue({
-			...supabase,
-			select: vi.fn().mockReturnValue({
-				...supabase,
-				eq: vi.fn().mockReturnValue({
-					then: (resolve: (val: unknown) => void) =>
-						Promise.resolve({ data: mockDeps, error: null }).then(resolve),
-				}),
-			}),
-		} as unknown as ReturnType<SupabaseClient['from']>);
-
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { dependencies: mockDeps },
+		});
 
 		const result = await getTaskDependencies({ body_of_work_id: VALID_UUID }, ctx);
 
 		expect(result.result).toMatchObject({ dependencies: mockDeps });
+		expect(mockApiClient.proxy).toHaveBeenCalledWith('get_task_dependencies', expect.objectContaining({
+			body_of_work_id: VALID_UUID,
+		}));
 	});
 
 	it('should return dependencies filtered by task_id', async () => {
-		const supabase = createMockSupabase();
-
-		vi.mocked(supabase.from).mockReturnValue({
-			...supabase,
-			select: vi.fn().mockReturnValue({
-				...supabase,
-				eq: vi.fn().mockReturnValue({
-					then: (resolve: (val: unknown) => void) =>
-						Promise.resolve({ data: [], error: null }).then(resolve),
-				}),
-			}),
-		} as unknown as ReturnType<SupabaseClient['from']>);
-
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { dependencies: [] },
+		});
 
 		const result = await getTaskDependencies({ task_id: VALID_UUID }, ctx);
 
 		expect(result.result).toMatchObject({ dependencies: [] });
-		expect(supabase.from).toHaveBeenCalledWith('body_of_work_task_dependencies');
+		expect(mockApiClient.proxy).toHaveBeenCalledWith('get_task_dependencies', expect.objectContaining({
+			task_id: VALID_UUID,
+		}));
 	});
 });
 
@@ -1027,103 +622,55 @@ describe('getNextBodyOfWorkTask', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing body_of_work_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
+		const ctx = createMockContext();
 		await expect(getNextBodyOfWorkTask({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error when body of work not found', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: { message: 'Not found' } },
+	it('should throw error when API returns error', async () => {
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: false,
+			error: 'Body of work not found',
 		});
-		const ctx = createMockContext(supabase);
 
 		await expect(
 			getNextBodyOfWorkTask({ body_of_work_id: VALID_UUID }, ctx)
-		).rejects.toThrow('Body of work not found');
+		).rejects.toThrow('Failed to get next body of work task');
 	});
 
-	it('should return null when body of work is not active', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: { status: 'draft', title: 'Test' }, error: null },
+	it('should return null when no tasks available', async () => {
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: {
+				next_task: null,
+				message: 'No available tasks',
+			},
 		});
-		const ctx = createMockContext(supabase);
 
 		const result = await getNextBodyOfWorkTask({ body_of_work_id: VALID_UUID }, ctx);
 
 		expect(result.result).toMatchObject({
 			next_task: null,
-			message: 'Body of work is draft, not active',
-		});
-	});
-
-	it('should return next pending task from pre phase first', async () => {
-		const mockBow = { status: 'active', title: 'Sprint' };
-		const mockTaskLinks = [
-			{
-				task_id: 't1',
-				phase: 'pre',
-				order_index: 0,
-				tasks: { id: 't1', title: 'Setup', status: 'pending', priority: 1, claimed_by_session_id: null },
-			},
-			{
-				task_id: 't2',
-				phase: 'core',
-				order_index: 0,
-				tasks: { id: 't2', title: 'Feature', status: 'pending', priority: 2, claimed_by_session_id: null },
+			message: 'No available tasks',
+		});
+	});
+
+	it('should return next pending task', async () => {
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: {
+				next_task: {
+					id: 't1',
+					title: 'Setup',
+					phase: 'pre',
+					status: 'pending',
+				},
+				message: 'Task available',
 			},
-		];
-
-		const supabase = createMockSupabase();
-		let callCount = 0;
-
-		vi.mocked(supabase.from).mockImplementation((table: string) => {
-			callCount++;
-			if (table === 'bodies_of_work') {
-				return {
-					...supabase,
-					select: vi.fn().mockReturnValue({
-						...supabase,
-						eq: vi.fn().mockReturnValue({
-							...supabase,
-							single: vi.fn().mockResolvedValue({ data: mockBow, error: null }),
-						}),
-					}),
-				} as unknown as ReturnType<SupabaseClient['from']>;
-			}
-			if (table === 'body_of_work_tasks') {
-				return {
-					...supabase,
-					select: vi.fn().mockReturnValue({
-						...supabase,
-						eq: vi.fn().mockReturnValue({
-							...supabase,
-							order: vi.fn().mockReturnValue({
-								then: (resolve: (val: unknown) => void) =>
-									Promise.resolve({ data: mockTaskLinks, error: null }).then(resolve),
-							}),
-						}),
-					}),
-				} as unknown as ReturnType<SupabaseClient['from']>;
-			}
-			if (table === 'body_of_work_task_dependencies') {
-				return {
-					...supabase,
-					select: vi.fn().mockReturnValue({
-						...supabase,
-						eq: vi.fn().mockReturnValue({
-							then: (resolve: (val: unknown) => void) =>
-								Promise.resolve({ data: [], error: null }).then(resolve),
-						}),
-					}),
-				} as unknown as ReturnType<SupabaseClient['from']>;
-			}
-			return supabase as unknown as ReturnType<SupabaseClient['from']>;
 		});
 
-		const ctx = createMockContext(supabase);
-
 		const result = await getNextBodyOfWorkTask({ body_of_work_id: VALID_UUID }, ctx);
 
 		expect(result.result).toHaveProperty('next_task');
@@ -1131,146 +678,4 @@ describe('getNextBodyOfWorkTask', () => {
 		expect(nextTask.id).toBe('t1');
 		expect(nextTask.phase).toBe('pre');
 	});
-
-	it('should skip tasks claimed by other sessions', async () => {
-		const mockBow = { status: 'active', title: 'Sprint' };
-		const mockTaskLinks = [
-			{
-				task_id: 't1',
-				phase: 'pre',
-				order_index: 0,
-				tasks: { id: 't1', title: 'Claimed', status: 'pending', priority: 1, claimed_by_session_id: 'other-session' },
-			},
-			{
-				task_id: 't2',
-				phase: 'pre',
-				order_index: 1,
-				tasks: { id: 't2', title: 'Available', status: 'pending', priority: 2, claimed_by_session_id: null },
-			},
-		];
-
-		const supabase = createMockSupabase();
-
-		vi.mocked(supabase.from).mockImplementation((table: string) => {
-			if (table === 'bodies_of_work') {
-				return {
-					...supabase,
-					select: vi.fn().mockReturnValue({
-						...supabase,
-						eq: vi.fn().mockReturnValue({
-							...supabase,
-							single: vi.fn().mockResolvedValue({ data: mockBow, error: null }),
-						}),
-					}),
-				} as unknown as ReturnType<SupabaseClient['from']>;
-			}
-			if (table === 'body_of_work_tasks') {
-				return {
-					...supabase,
-					select: vi.fn().mockReturnValue({
-						...supabase,
-						eq: vi.fn().mockReturnValue({
-							...supabase,
-							order: vi.fn().mockReturnValue({
-								then: (resolve: (val: unknown) => void) =>
-									Promise.resolve({ data: mockTaskLinks, error: null }).then(resolve),
-							}),
-						}),
-					}),
-				} as unknown as ReturnType<SupabaseClient['from']>;
-			}
-			if (table === 'body_of_work_task_dependencies') {
-				return {
-					...supabase,
-					select: vi.fn().mockReturnValue({
-						...supabase,
-						eq: vi.fn().mockReturnValue({
-							then: (resolve: (val: unknown) => void) =>
-								Promise.resolve({ data: [], error: null }).then(resolve),
-						}),
-					}),
-				} as unknown as ReturnType<SupabaseClient['from']>;
-			}
-			return supabase as unknown as ReturnType<SupabaseClient['from']>;
-		});
-
-		const ctx = createMockContext(supabase);
-
-		const result = await getNextBodyOfWorkTask({ body_of_work_id: VALID_UUID }, ctx);
-
-		const nextTask = (result.result as { next_task: { id: string } }).next_task;
-		expect(nextTask.id).toBe('t2');
-	});
-
-	it('should return null when all tasks are completed or in progress', async () => {
-		const mockBow = { status: 'active', title: 'Sprint' };
-		const mockTaskLinks = [
-			{
-				task_id: 't1',
-				phase: 'core',
-				order_index: 0,
-				tasks: { id: 't1', title: 'Done', status: 'completed', priority: 1, claimed_by_session_id: null },
-			},
-			{
-				task_id: 't2',
-				phase: 'core',
-				order_index: 1,
-				tasks: { id: 't2', title: 'Working', status: 'in_progress', priority: 2, claimed_by_session_id: null },
-			},
-		];
-
-		const supabase = createMockSupabase();
-
-		vi.mocked(supabase.from).mockImplementation((table: string) => {
-			if (table === 'bodies_of_work') {
-				return {
-					...supabase,
-					select: vi.fn().mockReturnValue({
-						...supabase,
-						eq: vi.fn().mockReturnValue({
-							...supabase,
-							single: vi.fn().mockResolvedValue({ data: mockBow, error: null }),
-						}),
-					}),
-				} as unknown as ReturnType<SupabaseClient['from']>;
-			}
-			if (table === 'body_of_work_tasks') {
-				return {
-					...supabase,
-					select: vi.fn().mockReturnValue({
-						...supabase,
-						eq: vi.fn().mockReturnValue({
-							...supabase,
-							order: vi.fn().mockReturnValue({
-								then: (resolve: (val: unknown) => void) =>
-									Promise.resolve({ data: mockTaskLinks, error: null }).then(resolve),
-							}),
-						}),
-					}),
-				} as unknown as ReturnType<SupabaseClient['from']>;
-			}
-			if (table === 'body_of_work_task_dependencies') {
-				return {
-					...supabase,
-					select: vi.fn().mockReturnValue({
-						...supabase,
-						eq: vi.fn().mockReturnValue({
-							then: (resolve: (val: unknown) => void) =>
-								Promise.resolve({ data: [], error: null }).then(resolve),
-						}),
-					}),
-				} as unknown as ReturnType<SupabaseClient['from']>;
-			}
-			return supabase as unknown as ReturnType<SupabaseClient['from']>;
-		});
-
-		const ctx = createMockContext(supabase);
-
-		const result = await getNextBodyOfWorkTask({ body_of_work_id: VALID_UUID }, ctx);
-
-		expect(result.result).toMatchObject({
-			next_task: null,
-			message: expect.stringContaining('No available tasks'),
-		});
-	});
 });