@vibescope/mcp-server 0.0.1

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

@@ -0,0 +1,1276 @@
+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,
+	getBodyOfWork,
+	getBodiesOfWork,
+	deleteBodyOfWork,
+	addTaskToBodyOfWork,
+	removeTaskFromBodyOfWork,
+	activateBodyOfWork,
+	addTaskDependency,
+	removeTaskDependency,
+	getTaskDependencies,
+	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(),
+	};
+}
+
+const VALID_UUID = '123e4567-e89b-12d3-a456-426614174000';
+const VALID_UUID_2 = '223e4567-e89b-12d3-a456-426614174001';
+const VALID_UUID_3 = '323e4567-e89b-12d3-a456-426614174002';
+
+// ============================================================================
+// createBodyOfWork Tests
+// ============================================================================
+
+describe('createBodyOfWork', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		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);
+
+		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);
+
+		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(supabase);
+
+		const result = await createBodyOfWork(
+			{ project_id: VALID_UUID, title: 'Sprint 1' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			body_of_work_id: 'bow-1',
+			title: 'Sprint 1',
+			status: 'draft',
+		});
+		expect(supabase.from).toHaveBeenCalledWith('bodies_of_work');
+		expect(supabase.insert).toHaveBeenCalledWith(
+			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',
+			})
+		);
+	});
+
+	it('should create body of work with all optional fields', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: { id: 'bow-2' }, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await createBodyOfWork(
+			{
+				project_id: VALID_UUID,
+				title: 'Release 2.0',
+				description: 'Major release',
+				auto_deploy_on_completion: true,
+				deploy_environment: 'staging',
+				deploy_version_bump: 'major',
+				deploy_trigger: 'all_completed',
+			},
+			ctx
+		);
+
+		expect(supabase.insert).toHaveBeenCalledWith(
+			expect.objectContaining({
+				description: 'Major release',
+				auto_deploy_on_completion: true,
+				deploy_environment: 'staging',
+				deploy_version_bump: 'major',
+				deploy_trigger: 'all_completed',
+			})
+		);
+	});
+
+	it('should throw error when database insert fails', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: null, error: { message: 'Insert failed' } },
+		});
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			createBodyOfWork({ project_id: VALID_UUID, title: 'Test' }, ctx)
+		).rejects.toThrow('Failed to create body of work');
+	});
+});
+
+// ============================================================================
+// updateBodyOfWork Tests
+// ============================================================================
+
+describe('updateBodyOfWork', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing body_of_work_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(updateBodyOfWork({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should return success when no updates provided', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		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();
+	});
+
+	it('should update title', async () => {
+		const supabase = createMockSupabase({
+			updateResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await updateBodyOfWork(
+			{ body_of_work_id: VALID_UUID, title: 'New Title' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({ success: true, body_of_work_id: VALID_UUID });
+		expect(supabase.update).toHaveBeenCalledWith({ title: 'New Title' });
+	});
+
+	it('should update multiple fields', async () => {
+		const supabase = createMockSupabase({
+			updateResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await updateBodyOfWork(
+			{
+				body_of_work_id: VALID_UUID,
+				title: 'Updated',
+				description: 'New desc',
+				auto_deploy_on_completion: true,
+			},
+			ctx
+		);
+
+		expect(supabase.update).toHaveBeenCalledWith({
+			title: 'Updated',
+			description: 'New desc',
+			auto_deploy_on_completion: true,
+		});
+	});
+});
+
+// ============================================================================
+// getBodyOfWork Tests
+// ============================================================================
+
+describe('getBodyOfWork', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing body_of_work_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		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(supabase);
+
+		await expect(
+			getBodyOfWork({ body_of_work_id: VALID_UUID }, ctx)
+		).rejects.toThrow('Body of work not found');
+	});
+
+	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(supabase);
+
+		const result = await getBodyOfWork({ body_of_work_id: VALID_UUID }, ctx);
+
+		expect(result.result).toHaveProperty('pre_tasks');
+		expect(result.result).toHaveProperty('core_tasks');
+		expect(result.result).toHaveProperty('post_tasks');
+		expect(result.result).toHaveProperty('total_tasks');
+	});
+});
+
+// ============================================================================
+// getBodiesOfWork Tests
+// ============================================================================
+
+describe('getBodiesOfWork', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		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 result = await getBodiesOfWork({ project_id: VALID_UUID }, ctx);
+
+		expect(result.result).toMatchObject({ bodies_of_work: [] });
+	});
+
+	it('should filter by status when provided', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await getBodiesOfWork({ project_id: VALID_UUID, status: 'active' }, ctx);
+
+		expect(supabase.eq).toHaveBeenCalledWith('project_id', VALID_UUID);
+		expect(supabase.eq).toHaveBeenCalledWith('status', 'active');
+	});
+});
+
+// ============================================================================
+// deleteBodyOfWork Tests
+// ============================================================================
+
+describe('deleteBodyOfWork', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing body_of_work_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		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(supabase);
+
+		const result = await deleteBodyOfWork({ body_of_work_id: VALID_UUID }, ctx);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			message: 'Body of work deleted. Tasks are preserved.',
+		});
+		expect(supabase.from).toHaveBeenCalledWith('bodies_of_work');
+		expect(supabase.delete).toHaveBeenCalled();
+	});
+});
+
+// ============================================================================
+// addTaskToBodyOfWork Tests
+// ============================================================================
+
+describe('addTaskToBodyOfWork', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing body_of_work_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		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);
+
+		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' } },
+		});
+		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');
+	});
+
+	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(supabase);
+
+		const result = await addTaskToBodyOfWork(
+			{ body_of_work_id: VALID_UUID, task_id: VALID_UUID_2 },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			body_of_work_id: VALID_UUID,
+			task_id: VALID_UUID_2,
+			phase: 'core',
+			order_index: 0,
+		});
+	});
+});
+
+// ============================================================================
+// removeTaskFromBodyOfWork Tests
+// ============================================================================
+
+describe('removeTaskFromBodyOfWork', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing task_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		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 },
+		});
+		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');
+	});
+});
+
+// ============================================================================
+// activateBodyOfWork Tests
+// ============================================================================
+
+describe('activateBodyOfWork', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing body_of_work_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		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']>;
+		});
+
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			activateBodyOfWork({ body_of_work_id: VALID_UUID }, ctx)
+		).rejects.toThrow('Cannot activate body of work with no tasks');
+	});
+
+	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']>;
+		});
+
+		const ctx = createMockContext(supabase);
+
+		const result = await activateBodyOfWork({ body_of_work_id: VALID_UUID }, ctx);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			body_of_work_id: VALID_UUID,
+			title: 'Sprint 1',
+			status: 'active',
+		});
+	});
+});
+
+// ============================================================================
+// addTaskDependency Tests
+// ============================================================================
+
+describe('addTaskDependency', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing body_of_work_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		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);
+
+		await expect(
+			addTaskDependency({
+				body_of_work_id: VALID_UUID,
+				task_id: VALID_UUID_2,
+				depends_on_task_id: VALID_UUID_2,
+			}, ctx)
+		).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,
+				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');
+	});
+});
+
+// ============================================================================
+// removeTaskDependency Tests
+// ============================================================================
+
+describe('removeTaskDependency', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing task_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		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);
+
+		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(supabase);
+
+		const result = await removeTaskDependency(
+			{ task_id: VALID_UUID, depends_on_task_id: VALID_UUID_2 },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			task_id: VALID_UUID,
+			depends_on_task_id: VALID_UUID_2,
+		});
+	});
+});
+
+// ============================================================================
+// getTaskDependencies Tests
+// ============================================================================
+
+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);
+
+		await expect(getTaskDependencies({}, ctx)).rejects.toThrow(
+			'Either body_of_work_id or task_id is required'
+		);
+	});
+
+	it('should return dependencies filtered by body_of_work_id', async () => {
+		const mockDeps = [
+			{ 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 result = await getTaskDependencies({ body_of_work_id: VALID_UUID }, ctx);
+
+		expect(result.result).toMatchObject({ dependencies: mockDeps });
+	});
+
+	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 result = await getTaskDependencies({ task_id: VALID_UUID }, ctx);
+
+		expect(result.result).toMatchObject({ dependencies: [] });
+		expect(supabase.from).toHaveBeenCalledWith('body_of_work_task_dependencies');
+	});
+});
+
+// ============================================================================
+// getNextBodyOfWorkTask Tests
+// ============================================================================
+
+describe('getNextBodyOfWorkTask', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing body_of_work_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		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' } },
+		});
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			getNextBodyOfWorkTask({ body_of_work_id: VALID_UUID }, ctx)
+		).rejects.toThrow('Body of work not found');
+	});
+
+	it('should return null when body of work is not active', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: { status: 'draft', title: 'Test' }, error: null },
+		});
+		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 },
+			},
+		];
+
+		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');
+		const nextTask = (result.result as { next_task: { id: string; phase: string } }).next_task;
+		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'),
+		});
+	});
+});