@vibescope/mcp-server 0.4.5 → 0.4.7

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

@@ -1,704 +1,704 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import {
-	createBodyOfWork,
-	updateBodyOfWork,
-	getBodyOfWork,
-	getBodiesOfWork,
-	deleteBodyOfWork,
-	addTaskToBodyOfWork,
-	removeTaskFromBodyOfWork,
-	activateBodyOfWork,
-	addTaskDependency,
-	removeTaskDependency,
-	getTaskDependencies,
-	getNextBodyOfWorkTask,
-} from './bodies-of-work.js';
-import { ValidationError } from '../validators.js';
-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';
-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 ctx = createMockContext();
-		await expect(createBodyOfWork({ title: 'Test' }, ctx)).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid project_id UUID', async () => {
-		const ctx = createMockContext();
-		await expect(
-			createBodyOfWork({ project_id: 'invalid', title: 'Test' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for missing title', async () => {
-		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 ctx = createMockContext();
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: { body_of_work_id: 'bow-1' },
-		});
-
-		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(mockApiClient.proxy).toHaveBeenCalledWith(
-			'create_body_of_work',
-			expect.objectContaining({
-				project_id: VALID_UUID,
-				title: 'Sprint 1',
-			}),
-			expect.any(Object)
-		);
-	});
-
-	it('should create body of work with all optional fields', async () => {
-		const ctx = createMockContext();
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: { body_of_work_id: 'bow-2' },
-		});
-
-		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(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 return error when API call fails', async () => {
-		const ctx = createMockContext();
-		mockApiClient.proxy.mockResolvedValue({
-			ok: false,
-			error: 'Insert failed',
-		});
-
-		const result = await createBodyOfWork({ project_id: VALID_UUID, title: 'Test' }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: 'Insert failed',
-		});
-	});
-});
-
-// ============================================================================
-// updateBodyOfWork Tests
-// ============================================================================
-
-describe('updateBodyOfWork', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing body_of_work_id', async () => {
-		const ctx = createMockContext();
-		await expect(updateBodyOfWork({}, ctx)).rejects.toThrow(ValidationError);
-	});
-
-	it('should return success when no updates provided', async () => {
-		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(mockApiClient.proxy).not.toHaveBeenCalled();
-	});
-
-	it('should update title', async () => {
-		const ctx = createMockContext();
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: { success: true },
-		});
-
-		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(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 ctx = createMockContext();
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: { success: true },
-		});
-
-		await updateBodyOfWork(
-			{
-				body_of_work_id: VALID_UUID,
-				title: 'Updated',
-				description: 'New desc',
-				auto_deploy_on_completion: true,
-			},
-			ctx
-		);
-
-		expect(mockApiClient.proxy).toHaveBeenCalledWith('update_body_of_work', expect.objectContaining({
-			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 ctx = createMockContext();
-		await expect(getBodyOfWork({}, ctx)).rejects.toThrow(ValidationError);
-	});
-
-	it('should return error when body of work not found', async () => {
-		const ctx = createMockContext();
-		mockApiClient.proxy.mockResolvedValue({
-			ok: false,
-			error: 'Not found',
-		});
-
-		const result = await getBodyOfWork({ body_of_work_id: VALID_UUID }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: 'Not found',
-		});
-	});
-
-	it('should return body of work with tasks organized by phase', async () => {
-		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 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 ctx = createMockContext();
-		await expect(getBodiesOfWork({}, ctx)).rejects.toThrow(ValidationError);
-	});
-
-	it('should return empty array when no bodies of work exist', async () => {
-		const ctx = createMockContext();
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: { bodies_of_work: [], total_count: 0 },
-		});
-
-		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 ctx = createMockContext();
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: { bodies_of_work: [], total_count: 0 },
-		});
-
-		await getBodiesOfWork({ project_id: VALID_UUID, status: 'active' }, ctx);
-
-		expect(mockApiClient.proxy).toHaveBeenCalledWith('get_bodies_of_work', expect.objectContaining({
-			project_id: VALID_UUID,
-			status: 'active',
-		}));
-	});
-});
-
-// ============================================================================
-// deleteBodyOfWork Tests
-// ============================================================================
-
-describe('deleteBodyOfWork', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing body_of_work_id', async () => {
-		const ctx = createMockContext();
-		await expect(deleteBodyOfWork({}, ctx)).rejects.toThrow(ValidationError);
-	});
-
-	it('should delete body of work successfully', async () => {
-		const ctx = createMockContext();
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: { success: true },
-		});
-
-		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(mockApiClient.proxy).toHaveBeenCalledWith('delete_body_of_work', expect.objectContaining({
-			body_of_work_id: VALID_UUID,
-		}));
-	});
-});
-
-// ============================================================================
-// addTaskToBodyOfWork Tests
-// ============================================================================
-
-describe('addTaskToBodyOfWork', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing body_of_work_id', async () => {
-		const ctx = createMockContext();
-		await expect(
-			addTaskToBodyOfWork({ task_id: VALID_UUID }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for missing task_id', async () => {
-		const ctx = createMockContext();
-		await expect(
-			addTaskToBodyOfWork({ body_of_work_id: VALID_UUID }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should return error when API returns error', async () => {
-		const ctx = createMockContext();
-		mockApiClient.proxy.mockResolvedValue({
-			ok: false,
-			error: 'Body of work not found',
-		});
-
-		const result = await addTaskToBodyOfWork({ body_of_work_id: VALID_UUID, task_id: VALID_UUID_2 }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: 'Body of work not found',
-		});
-	});
-
-	it('should add task with default phase "core"', async () => {
-		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 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,
-		});
-	});
-
-	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',
-		}));
-	});
-});
-
-// ============================================================================
-// removeTaskFromBodyOfWork Tests
-// ============================================================================
-
-describe('removeTaskFromBodyOfWork', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing task_id', async () => {
-		const ctx = createMockContext();
-		await expect(removeTaskFromBodyOfWork({}, ctx)).rejects.toThrow(ValidationError);
-	});
-
-	it('should remove task successfully', async () => {
-		const ctx = createMockContext();
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: { success: true },
-		});
-
-		const result = await removeTaskFromBodyOfWork({ task_id: VALID_UUID }, ctx);
-
-		expect(result.result).toMatchObject({ success: true });
-		expect(mockApiClient.proxy).toHaveBeenCalledWith('remove_task_from_body_of_work', expect.objectContaining({
-			task_id: VALID_UUID,
-		}));
-	});
-});
-
-// ============================================================================
-// activateBodyOfWork Tests
-// ============================================================================
-
-describe('activateBodyOfWork', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing body_of_work_id', async () => {
-		const ctx = createMockContext();
-		await expect(activateBodyOfWork({}, ctx)).rejects.toThrow(ValidationError);
-	});
-
-	it('should return error when API returns error', async () => {
-		const ctx = createMockContext();
-		mockApiClient.proxy.mockResolvedValue({
-			ok: false,
-			error: 'Body of work not found',
-		});
-
-		const result = await activateBodyOfWork({ body_of_work_id: VALID_UUID }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: 'Body of work not found',
-		});
-	});
-
-	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 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 ctx = createMockContext();
-		await expect(
-			addTaskDependency({ task_id: VALID_UUID, depends_on_task_id: VALID_UUID_2 }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should return error when task depends on itself', async () => {
-		const ctx = createMockContext();
-
-		const result = await addTaskDependency({
-			body_of_work_id: VALID_UUID,
-			task_id: VALID_UUID_2,
-			depends_on_task_id: VALID_UUID_2,
-		}, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: 'A task cannot depend on itself',
-		});
-	});
-
-	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,
-			},
-		});
-
-		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,
-		});
-	});
-});
-
-// ============================================================================
-// removeTaskDependency Tests
-// ============================================================================
-
-describe('removeTaskDependency', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing task_id', async () => {
-		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 ctx = createMockContext();
-		await expect(
-			removeTaskDependency({ task_id: VALID_UUID }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should remove dependency successfully', async () => {
-		const ctx = createMockContext();
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: {
-				success: true,
-				task_id: VALID_UUID,
-				depends_on_task_id: VALID_UUID_2,
-			},
-		});
-
-		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 return error when neither body_of_work_id nor task_id provided', async () => {
-		const ctx = createMockContext();
-
-		const result = await getTaskDependencies({}, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: '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 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 ctx = createMockContext();
-		mockApiClient.proxy.mockResolvedValue({
-			ok: true,
-			data: { dependencies: [] },
-		});
-
-		const result = await getTaskDependencies({ task_id: VALID_UUID }, ctx);
-
-		expect(result.result).toMatchObject({ dependencies: [] });
-		expect(mockApiClient.proxy).toHaveBeenCalledWith('get_task_dependencies', expect.objectContaining({
-			task_id: VALID_UUID,
-		}));
-	});
-});
-
-// ============================================================================
-// getNextBodyOfWorkTask Tests
-// ============================================================================
-
-describe('getNextBodyOfWorkTask', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing body_of_work_id', async () => {
-		const ctx = createMockContext();
-		await expect(getNextBodyOfWorkTask({}, ctx)).rejects.toThrow(ValidationError);
-	});
-
-	it('should return error when API returns error', async () => {
-		const ctx = createMockContext();
-		mockApiClient.proxy.mockResolvedValue({
-			ok: false,
-			error: 'Body of work not found',
-		});
-
-		const result = await getNextBodyOfWorkTask({ body_of_work_id: VALID_UUID }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({
-			error: 'Body of work not found',
-		});
-	});
-
-	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 result = await getNextBodyOfWorkTask({ body_of_work_id: VALID_UUID }, ctx);
-
-		expect(result.result).toMatchObject({
-			next_task: 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 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');
-	});
-});
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+	createBodyOfWork,
+	updateBodyOfWork,
+	getBodyOfWork,
+	getBodiesOfWork,
+	deleteBodyOfWork,
+	addTaskToBodyOfWork,
+	removeTaskFromBodyOfWork,
+	activateBodyOfWork,
+	addTaskDependency,
+	removeTaskDependency,
+	getTaskDependencies,
+	getNextBodyOfWorkTask,
+} from './bodies-of-work.js';
+import { ValidationError } from '../validators.js';
+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';
+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 ctx = createMockContext();
+		await expect(createBodyOfWork({ title: 'Test' }, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const ctx = createMockContext();
+		await expect(
+			createBodyOfWork({ project_id: 'invalid', title: 'Test' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for missing title', async () => {
+		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 ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { body_of_work_id: 'bow-1' },
+		});
+
+		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(mockApiClient.proxy).toHaveBeenCalledWith(
+			'create_body_of_work',
+			expect.objectContaining({
+				project_id: VALID_UUID,
+				title: 'Sprint 1',
+			}),
+			expect.any(Object)
+		);
+	});
+
+	it('should create body of work with all optional fields', async () => {
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { body_of_work_id: 'bow-2' },
+		});
+
+		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(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 return error when API call fails', async () => {
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: false,
+			error: 'Insert failed',
+		});
+
+		const result = await createBodyOfWork({ project_id: VALID_UUID, title: 'Test' }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Insert failed',
+		});
+	});
+});
+
+// ============================================================================
+// updateBodyOfWork Tests
+// ============================================================================
+
+describe('updateBodyOfWork', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing body_of_work_id', async () => {
+		const ctx = createMockContext();
+		await expect(updateBodyOfWork({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should return success when no updates provided', async () => {
+		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(mockApiClient.proxy).not.toHaveBeenCalled();
+	});
+
+	it('should update title', async () => {
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { success: true },
+		});
+
+		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(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 ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { success: true },
+		});
+
+		await updateBodyOfWork(
+			{
+				body_of_work_id: VALID_UUID,
+				title: 'Updated',
+				description: 'New desc',
+				auto_deploy_on_completion: true,
+			},
+			ctx
+		);
+
+		expect(mockApiClient.proxy).toHaveBeenCalledWith('update_body_of_work', expect.objectContaining({
+			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 ctx = createMockContext();
+		await expect(getBodyOfWork({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should return error when body of work not found', async () => {
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: false,
+			error: 'Not found',
+		});
+
+		const result = await getBodyOfWork({ body_of_work_id: VALID_UUID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Not found',
+		});
+	});
+
+	it('should return body of work with tasks organized by phase', async () => {
+		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 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 ctx = createMockContext();
+		await expect(getBodiesOfWork({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should return empty array when no bodies of work exist', async () => {
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { bodies_of_work: [], total_count: 0 },
+		});
+
+		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 ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { bodies_of_work: [], total_count: 0 },
+		});
+
+		await getBodiesOfWork({ project_id: VALID_UUID, status: 'active' }, ctx);
+
+		expect(mockApiClient.proxy).toHaveBeenCalledWith('get_bodies_of_work', expect.objectContaining({
+			project_id: VALID_UUID,
+			status: 'active',
+		}));
+	});
+});
+
+// ============================================================================
+// deleteBodyOfWork Tests
+// ============================================================================
+
+describe('deleteBodyOfWork', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing body_of_work_id', async () => {
+		const ctx = createMockContext();
+		await expect(deleteBodyOfWork({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should delete body of work successfully', async () => {
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { success: true },
+		});
+
+		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(mockApiClient.proxy).toHaveBeenCalledWith('delete_body_of_work', expect.objectContaining({
+			body_of_work_id: VALID_UUID,
+		}));
+	});
+});
+
+// ============================================================================
+// addTaskToBodyOfWork Tests
+// ============================================================================
+
+describe('addTaskToBodyOfWork', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing body_of_work_id', async () => {
+		const ctx = createMockContext();
+		await expect(
+			addTaskToBodyOfWork({ task_id: VALID_UUID }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for missing task_id', async () => {
+		const ctx = createMockContext();
+		await expect(
+			addTaskToBodyOfWork({ body_of_work_id: VALID_UUID }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should return error when API returns error', async () => {
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: false,
+			error: 'Body of work not found',
+		});
+
+		const result = await addTaskToBodyOfWork({ body_of_work_id: VALID_UUID, task_id: VALID_UUID_2 }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Body of work not found',
+		});
+	});
+
+	it('should add task with default phase "core"', async () => {
+		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 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,
+		});
+	});
+
+	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',
+		}));
+	});
+});
+
+// ============================================================================
+// removeTaskFromBodyOfWork Tests
+// ============================================================================
+
+describe('removeTaskFromBodyOfWork', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing task_id', async () => {
+		const ctx = createMockContext();
+		await expect(removeTaskFromBodyOfWork({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should remove task successfully', async () => {
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { success: true },
+		});
+
+		const result = await removeTaskFromBodyOfWork({ task_id: VALID_UUID }, ctx);
+
+		expect(result.result).toMatchObject({ success: true });
+		expect(mockApiClient.proxy).toHaveBeenCalledWith('remove_task_from_body_of_work', expect.objectContaining({
+			task_id: VALID_UUID,
+		}));
+	});
+});
+
+// ============================================================================
+// activateBodyOfWork Tests
+// ============================================================================
+
+describe('activateBodyOfWork', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing body_of_work_id', async () => {
+		const ctx = createMockContext();
+		await expect(activateBodyOfWork({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should return error when API returns error', async () => {
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: false,
+			error: 'Body of work not found',
+		});
+
+		const result = await activateBodyOfWork({ body_of_work_id: VALID_UUID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Body of work not found',
+		});
+	});
+
+	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 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 ctx = createMockContext();
+		await expect(
+			addTaskDependency({ task_id: VALID_UUID, depends_on_task_id: VALID_UUID_2 }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should return error when task depends on itself', async () => {
+		const ctx = createMockContext();
+
+		const result = await addTaskDependency({
+			body_of_work_id: VALID_UUID,
+			task_id: VALID_UUID_2,
+			depends_on_task_id: VALID_UUID_2,
+		}, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'A task cannot depend on itself',
+		});
+	});
+
+	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,
+			},
+		});
+
+		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,
+		});
+	});
+});
+
+// ============================================================================
+// removeTaskDependency Tests
+// ============================================================================
+
+describe('removeTaskDependency', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing task_id', async () => {
+		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 ctx = createMockContext();
+		await expect(
+			removeTaskDependency({ task_id: VALID_UUID }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should remove dependency successfully', async () => {
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				task_id: VALID_UUID,
+				depends_on_task_id: VALID_UUID_2,
+			},
+		});
+
+		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 return error when neither body_of_work_id nor task_id provided', async () => {
+		const ctx = createMockContext();
+
+		const result = await getTaskDependencies({}, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: '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 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 ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { dependencies: [] },
+		});
+
+		const result = await getTaskDependencies({ task_id: VALID_UUID }, ctx);
+
+		expect(result.result).toMatchObject({ dependencies: [] });
+		expect(mockApiClient.proxy).toHaveBeenCalledWith('get_task_dependencies', expect.objectContaining({
+			task_id: VALID_UUID,
+		}));
+	});
+});
+
+// ============================================================================
+// getNextBodyOfWorkTask Tests
+// ============================================================================
+
+describe('getNextBodyOfWorkTask', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing body_of_work_id', async () => {
+		const ctx = createMockContext();
+		await expect(getNextBodyOfWorkTask({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should return error when API returns error', async () => {
+		const ctx = createMockContext();
+		mockApiClient.proxy.mockResolvedValue({
+			ok: false,
+			error: 'Body of work not found',
+		});
+
+		const result = await getNextBodyOfWorkTask({ body_of_work_id: VALID_UUID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Body of work not found',
+		});
+	});
+
+	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 result = await getNextBodyOfWorkTask({ body_of_work_id: VALID_UUID }, ctx);
+
+		expect(result.result).toMatchObject({
+			next_task: 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 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');
+	});
+});