@vibescope/mcp-server 0.2.3 → 0.2.5

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

@@ -1,468 +1,526 @@
-/**
- * Bodies of Work Handlers
- *
- * Handles grouping tasks into bodies of work with phases:
- * - create_body_of_work
- * - update_body_of_work
- * - get_body_of_work
- * - get_bodies_of_work
- * - delete_body_of_work
- * - add_task_to_body_of_work
- * - remove_task_from_body_of_work
- * - activate_body_of_work
- * - add_task_dependency
- * - remove_task_dependency
- * - get_task_dependencies
- * - get_next_body_of_work_task
- *
- * MIGRATED: Uses Vibescope API client instead of direct Supabase
- */
-
-import type { Handler, HandlerRegistry } from './types.js';
-import { parseArgs, uuidValidator, createEnumValidator } from '../validators.js';
-import { getApiClient } from '../api-client.js';
-
-const BODY_OF_WORK_STATUSES = ['draft', 'active', 'completed', 'cancelled'] as const;
-const TASK_PHASES = ['pre', 'core', 'post'] as const;
-const DEPLOY_ENVIRONMENTS = ['development', 'staging', 'production'] as const;
-const VERSION_BUMPS = ['patch', 'minor', 'major'] as const;
-const DEPLOY_TRIGGERS = ['all_completed', 'all_completed_validated'] as const;
-
-type BodyOfWorkStatus = typeof BODY_OF_WORK_STATUSES[number];
-type TaskPhase = typeof TASK_PHASES[number];
-type DeployEnvironment = typeof DEPLOY_ENVIRONMENTS[number];
-type VersionBump = typeof VERSION_BUMPS[number];
-type DeployTrigger = typeof DEPLOY_TRIGGERS[number];
-
-// ============================================================================
-// Argument Schemas
-// ============================================================================
-
-const createBodyOfWorkSchema = {
-	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
-	title: { type: 'string' as const, required: true as const },
-	description: { type: 'string' as const },
-	auto_deploy_on_completion: { type: 'boolean' as const },
-	deploy_environment: { type: 'string' as const, validate: createEnumValidator(DEPLOY_ENVIRONMENTS) },
-	deploy_version_bump: { type: 'string' as const, validate: createEnumValidator(VERSION_BUMPS) },
-	deploy_trigger: { type: 'string' as const, validate: createEnumValidator(DEPLOY_TRIGGERS) },
-};
-
-const updateBodyOfWorkSchema = {
-	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
-	title: { type: 'string' as const },
-	description: { type: 'string' as const },
-	auto_deploy_on_completion: { type: 'boolean' as const },
-	deploy_environment: { type: 'string' as const, validate: createEnumValidator(DEPLOY_ENVIRONMENTS) },
-	deploy_version_bump: { type: 'string' as const, validate: createEnumValidator(VERSION_BUMPS) },
-	deploy_trigger: { type: 'string' as const, validate: createEnumValidator(DEPLOY_TRIGGERS) },
-};
-
-const getBodyOfWorkSchema = {
-	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
-	summary_only: { type: 'boolean' as const, default: false },
-};
-
-const getBodiesOfWorkSchema = {
-	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
-	status: { type: 'string' as const, validate: createEnumValidator(BODY_OF_WORK_STATUSES) },
-	limit: { type: 'number' as const, default: 50 },
-	offset: { type: 'number' as const, default: 0 },
-	search_query: { type: 'string' as const },
-};
-
-const deleteBodyOfWorkSchema = {
-	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
-};
-
-const addTaskToBodyOfWorkSchema = {
-	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
-	task_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
-	phase: { type: 'string' as const, validate: createEnumValidator(TASK_PHASES) },
-	order_index: { type: 'number' as const },
-};
-
-const removeTaskFromBodyOfWorkSchema = {
-	task_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
-};
-
-const activateBodyOfWorkSchema = {
-	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
-};
-
-const addTaskDependencySchema = {
-	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
-	task_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
-	depends_on_task_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
-};
-
-const removeTaskDependencySchema = {
-	task_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
-	depends_on_task_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
-};
-
-const getTaskDependenciesSchema = {
-	body_of_work_id: { type: 'string' as const, validate: uuidValidator },
-	task_id: { type: 'string' as const, validate: uuidValidator },
-};
-
-const getNextBodyOfWorkTaskSchema = {
-	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
-};
-
-export const createBodyOfWork: Handler = async (args, ctx) => {
-	const {
-		project_id,
-		title,
-		description,
-		auto_deploy_on_completion,
-		deploy_environment,
-		deploy_version_bump,
-		deploy_trigger,
-	} = parseArgs(args, createBodyOfWorkSchema);
-
-	const { session } = ctx;
-	const apiClient = getApiClient();
-
-	const response = await apiClient.proxy<{
-		success: boolean;
-		body_of_work_id: string;
-	}>('create_body_of_work', {
-		project_id,
-		title,
-		description,
-		auto_deploy_on_completion,
-		deploy_environment,
-		deploy_version_bump,
-		deploy_trigger
-	}, {
-		session_id: session.currentSessionId,
-		persona: session.currentPersona,
-		instance_id: session.instanceId
-	});
-
-	if (!response.ok) {
-		return { result: { error: response.error || 'Failed to create body of work' }, isError: true };
-	}
-
-	return {
-		result: {
-			success: true,
-			body_of_work_id: response.data?.body_of_work_id,
-			title,
-			status: 'draft',
-			message: 'Body of work created. Add tasks with add_task_to_body_of_work, then activate with activate_body_of_work.',
-		},
-	};
-};
-
-export const updateBodyOfWork: Handler = async (args, ctx) => {
-	const {
-		body_of_work_id,
-		title,
-		description,
-		auto_deploy_on_completion,
-		deploy_environment,
-		deploy_version_bump,
-		deploy_trigger,
-	} = parseArgs(args, updateBodyOfWorkSchema);
-
-	// Check if any updates provided
-	if (title === undefined && description === undefined && auto_deploy_on_completion === undefined &&
-		deploy_environment === undefined && deploy_version_bump === undefined && deploy_trigger === undefined) {
-		return { result: { success: true, message: 'No updates provided' } };
-	}
-
-	const apiClient = getApiClient();
-
-	const response = await apiClient.proxy<{ success: boolean }>('update_body_of_work', {
-		body_of_work_id,
-		title,
-		description,
-		auto_deploy_on_completion,
-		deploy_environment,
-		deploy_version_bump,
-		deploy_trigger
-	});
-
-	if (!response.ok) {
-		return { result: { error: response.error || 'Failed to update body of work' }, isError: true };
-	}
-
-	return { result: { success: true, body_of_work_id } };
-};
-
-export const getBodyOfWork: Handler = async (args, ctx) => {
-	const { body_of_work_id, summary_only } = parseArgs(args, getBodyOfWorkSchema);
-
-	const apiClient = getApiClient();
-
-	// Response type varies based on summary_only
-	const response = await apiClient.proxy<{
-		body_of_work: {
-			id: string;
-			title: string;
-			description?: string;
-			status: string;
-			progress_percentage: number;
-		};
-		// Full response includes tasks grouped by phase
-		tasks?: {
-			pre: unknown[];
-			core: unknown[];
-			post: unknown[];
-		};
-		// Summary response includes counts and next task
-		task_counts?: {
-			pre: { total: number; completed: number };
-			core: { total: number; completed: number };
-			post: { total: number; completed: number };
-			total: number;
-			completed: number;
-			in_progress: number;
-		};
-		current_task?: { id: string; title: string } | null;
-		next_task?: { id: string; title: string; priority: number } | null;
-	}>('get_body_of_work', { body_of_work_id, summary_only });
-
-	if (!response.ok) {
-		return { result: { error: response.error || 'Failed to get body of work' }, isError: true };
-	}
-
-	return { result: response.data };
-};
-
-export const getBodiesOfWork: Handler = async (args, ctx) => {
-	const { project_id, status, limit, offset, search_query } = parseArgs(args, getBodiesOfWorkSchema);
-
-	const apiClient = getApiClient();
-
-	const response = await apiClient.proxy<{
-		bodies_of_work: Array<{
-			id: string;
-			title: string;
-			description?: string;
-			status: string;
-			progress_percentage: number;
-			task_counts: {
-				pre: { total: number; completed: number };
-				core: { total: number; completed: number };
-				post: { total: number; completed: number };
-			};
-		}>;
-		total_count: number;
-		has_more: boolean;
-	}>('get_bodies_of_work', {
-		project_id,
-		status,
-		limit: Math.min(limit ?? 50, 100),
-		offset,
-		search_query
-	});
-
-	if (!response.ok) {
-		return { result: { error: response.error || 'Failed to fetch bodies of work' }, isError: true };
-	}
-
-	return { result: response.data };
-};
-
-export const deleteBodyOfWork: Handler = async (args, ctx) => {
-	const { body_of_work_id } = parseArgs(args, deleteBodyOfWorkSchema);
-
-	const apiClient = getApiClient();
-
-	const response = await apiClient.proxy<{ success: boolean }>('delete_body_of_work', {
-		body_of_work_id
-	});
-
-	if (!response.ok) {
-		return { result: { error: response.error || 'Failed to delete body of work' }, isError: true };
-	}
-
-	return { result: { success: true, message: 'Body of work deleted. Tasks are preserved.' } };
-};
-
-export const addTaskToBodyOfWork: Handler = async (args, ctx) => {
-	const { body_of_work_id, task_id, phase, order_index } = parseArgs(args, addTaskToBodyOfWorkSchema);
-
-	const apiClient = getApiClient();
-
-	const response = await apiClient.proxy<{
-		success: boolean;
-		body_of_work_id: string;
-		task_id: string;
-		phase: string;
-		order_index: number;
-	}>('add_task_to_body_of_work', {
-		body_of_work_id,
-		task_id,
-		phase: phase || 'core',
-		order_index
-	});
-
-	if (!response.ok) {
-		return { result: { error: response.error || 'Failed to add task to body of work' }, isError: true };
-	}
-
-	return { result: response.data };
-};
-
-export const removeTaskFromBodyOfWork: Handler = async (args, ctx) => {
-	const { task_id } = parseArgs(args, removeTaskFromBodyOfWorkSchema);
-
-	const apiClient = getApiClient();
-
-	const response = await apiClient.proxy<{
-		success: boolean;
-		body_of_work_id?: string;
-		message?: string;
-	}>('remove_task_from_body_of_work', { task_id });
-
-	if (!response.ok) {
-		return { result: { error: response.error || 'Failed to remove task from body of work' }, isError: true };
-	}
-
-	return { result: response.data };
-};
-
-export const activateBodyOfWork: Handler = async (args, ctx) => {
-	const { body_of_work_id } = parseArgs(args, activateBodyOfWorkSchema);
-
-	const apiClient = getApiClient();
-
-	const response = await apiClient.proxy<{
-		success: boolean;
-		body_of_work_id: string;
-		title: string;
-		status: string;
-		message: string;
-	}>('activate_body_of_work', { body_of_work_id });
-
-	if (!response.ok) {
-		return { result: { error: response.error || 'Failed to activate body of work' }, isError: true };
-	}
-
-	return { result: response.data };
-};
-
-export const addTaskDependency: Handler = async (args, ctx) => {
-	const { body_of_work_id, task_id, depends_on_task_id } = parseArgs(args, addTaskDependencySchema);
-
-	if (task_id === depends_on_task_id) {
-		return { result: { error: 'A task cannot depend on itself' }, isError: true };
-	}
-
-	const apiClient = getApiClient();
-
-	const response = await apiClient.proxy<{
-		success: boolean;
-		body_of_work_id: string;
-		task_id: string;
-		depends_on_task_id: string;
-		message: string;
-	}>('add_task_dependency', {
-		body_of_work_id,
-		task_id,
-		depends_on_task_id
-	});
-
-	if (!response.ok) {
-		return { result: { error: response.error || 'Failed to add task dependency' }, isError: true };
-	}
-
-	return { result: response.data };
-};
-
-export const removeTaskDependency: Handler = async (args, ctx) => {
-	const { task_id, depends_on_task_id } = parseArgs(args, removeTaskDependencySchema);
-
-	const apiClient = getApiClient();
-
-	const response = await apiClient.proxy<{
-		success: boolean;
-		task_id: string;
-		depends_on_task_id: string;
-	}>('remove_task_dependency', {
-		task_id,
-		depends_on_task_id
-	});
-
-	if (!response.ok) {
-		return { result: { error: response.error || 'Failed to remove task dependency' }, isError: true };
-	}
-
-	return { result: response.data };
-};
-
-export const getTaskDependencies: Handler = async (args, ctx) => {
-	const { body_of_work_id, task_id } = parseArgs(args, getTaskDependenciesSchema);
-
-	if (!body_of_work_id && !task_id) {
-		return { result: { error: 'Either body_of_work_id or task_id is required' }, isError: true };
-	}
-
-	const apiClient = getApiClient();
-
-	const response = await apiClient.proxy<{
-		dependencies: Array<{
-			id: string;
-			task_id: string;
-			depends_on_task_id: string;
-			created_at: string;
-		}>;
-	}>('get_task_dependencies', {
-		body_of_work_id,
-		task_id
-	});
-
-	if (!response.ok) {
-		return { result: { error: response.error || 'Failed to fetch task dependencies' }, isError: true };
-	}
-
-	return { result: response.data };
-};
-
-export const getNextBodyOfWorkTask: Handler = async (args, ctx) => {
-	const { body_of_work_id } = parseArgs(args, getNextBodyOfWorkTaskSchema);
-
-	const apiClient = getApiClient();
-
-	const response = await apiClient.proxy<{
-		next_task: {
-			id: string;
-			title: string;
-			phase: string;
-			priority: number;
-		} | null;
-		body_of_work?: {
-			id: string;
-			title: string;
-		};
-		message?: string;
-	}>('get_next_body_of_work_task', { body_of_work_id });
-
-	if (!response.ok) {
-		return { result: { error: response.error || 'Failed to get next body of work task' }, isError: true };
-	}
-
-	return { result: response.data };
-};
-
-/**
- * Bodies of Work handlers registry
- */
-export const bodiesOfWorkHandlers: HandlerRegistry = {
-	create_body_of_work: createBodyOfWork,
-	update_body_of_work: updateBodyOfWork,
-	get_body_of_work: getBodyOfWork,
-	get_bodies_of_work: getBodiesOfWork,
-	delete_body_of_work: deleteBodyOfWork,
-	add_task_to_body_of_work: addTaskToBodyOfWork,
-	remove_task_from_body_of_work: removeTaskFromBodyOfWork,
-	activate_body_of_work: activateBodyOfWork,
-	add_task_dependency: addTaskDependency,
-	remove_task_dependency: removeTaskDependency,
-	get_task_dependencies: getTaskDependencies,
-	get_next_body_of_work_task: getNextBodyOfWorkTask,
-};
+/**
+ * Bodies of Work Handlers
+ *
+ * Handles grouping tasks into bodies of work with phases:
+ * - create_body_of_work
+ * - update_body_of_work
+ * - get_body_of_work
+ * - get_bodies_of_work
+ * - delete_body_of_work
+ * - add_task_to_body_of_work
+ * - remove_task_from_body_of_work
+ * - activate_body_of_work
+ * - add_task_dependency
+ * - remove_task_dependency
+ * - get_task_dependencies
+ * - get_next_body_of_work_task
+ *
+ * MIGRATED: Uses Vibescope API client instead of direct Supabase
+ */
+
+import type { Handler, HandlerRegistry } from './types.js';
+import { parseArgs, uuidValidator, createEnumValidator } from '../validators.js';
+import { getApiClient } from '../api-client.js';
+
+const BODY_OF_WORK_STATUSES = ['draft', 'active', 'completed', 'cancelled', 'archived'] as const;
+const TASK_PHASES = ['pre', 'core', 'post'] as const;
+const DEPLOY_ENVIRONMENTS = ['development', 'staging', 'production'] as const;
+const VERSION_BUMPS = ['patch', 'minor', 'major'] as const;
+const DEPLOY_TRIGGERS = ['all_completed', 'all_completed_validated'] as const;
+
+type BodyOfWorkStatus = typeof BODY_OF_WORK_STATUSES[number];
+type TaskPhase = typeof TASK_PHASES[number];
+type DeployEnvironment = typeof DEPLOY_ENVIRONMENTS[number];
+type VersionBump = typeof VERSION_BUMPS[number];
+type DeployTrigger = typeof DEPLOY_TRIGGERS[number];
+
+// ============================================================================
+// Argument Schemas
+// ============================================================================
+
+const createBodyOfWorkSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	title: { type: 'string' as const, required: true as const },
+	description: { type: 'string' as const },
+	auto_deploy_on_completion: { type: 'boolean' as const },
+	deploy_environment: { type: 'string' as const, validate: createEnumValidator(DEPLOY_ENVIRONMENTS) },
+	deploy_version_bump: { type: 'string' as const, validate: createEnumValidator(VERSION_BUMPS) },
+	deploy_trigger: { type: 'string' as const, validate: createEnumValidator(DEPLOY_TRIGGERS) },
+};
+
+const updateBodyOfWorkSchema = {
+	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	title: { type: 'string' as const },
+	description: { type: 'string' as const },
+	auto_deploy_on_completion: { type: 'boolean' as const },
+	deploy_environment: { type: 'string' as const, validate: createEnumValidator(DEPLOY_ENVIRONMENTS) },
+	deploy_version_bump: { type: 'string' as const, validate: createEnumValidator(VERSION_BUMPS) },
+	deploy_trigger: { type: 'string' as const, validate: createEnumValidator(DEPLOY_TRIGGERS) },
+};
+
+const getBodyOfWorkSchema = {
+	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	summary_only: { type: 'boolean' as const, default: false },
+};
+
+const getBodiesOfWorkSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	status: { type: 'string' as const, validate: createEnumValidator(BODY_OF_WORK_STATUSES) },
+	limit: { type: 'number' as const, default: 50 },
+	offset: { type: 'number' as const, default: 0 },
+	search_query: { type: 'string' as const },
+};
+
+const deleteBodyOfWorkSchema = {
+	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const addTaskToBodyOfWorkSchema = {
+	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	task_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	phase: { type: 'string' as const, validate: createEnumValidator(TASK_PHASES) },
+	order_index: { type: 'number' as const },
+};
+
+const removeTaskFromBodyOfWorkSchema = {
+	task_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const activateBodyOfWorkSchema = {
+	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const addTaskDependencySchema = {
+	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	task_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	depends_on_task_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const removeTaskDependencySchema = {
+	task_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	depends_on_task_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const getTaskDependenciesSchema = {
+	body_of_work_id: { type: 'string' as const, validate: uuidValidator },
+	task_id: { type: 'string' as const, validate: uuidValidator },
+};
+
+const getNextBodyOfWorkTaskSchema = {
+	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+export const createBodyOfWork: Handler = async (args, ctx) => {
+	const {
+		project_id,
+		title,
+		description,
+		auto_deploy_on_completion,
+		deploy_environment,
+		deploy_version_bump,
+		deploy_trigger,
+	} = parseArgs(args, createBodyOfWorkSchema);
+
+	const { session } = ctx;
+	const apiClient = getApiClient();
+
+	const response = await apiClient.proxy<{
+		success: boolean;
+		body_of_work_id: string;
+	}>('create_body_of_work', {
+		project_id,
+		title,
+		description,
+		auto_deploy_on_completion,
+		deploy_environment,
+		deploy_version_bump,
+		deploy_trigger
+	}, {
+		session_id: session.currentSessionId,
+		persona: session.currentPersona,
+		instance_id: session.instanceId
+	});
+
+	if (!response.ok) {
+		return { result: { error: response.error || 'Failed to create body of work' }, isError: true };
+	}
+
+	return {
+		result: {
+			success: true,
+			body_of_work_id: response.data?.body_of_work_id,
+			title,
+			status: 'draft',
+			message: 'Body of work created. Add tasks with add_task_to_body_of_work, then activate with activate_body_of_work.',
+		},
+	};
+};
+
+export const updateBodyOfWork: Handler = async (args, ctx) => {
+	const {
+		body_of_work_id,
+		title,
+		description,
+		auto_deploy_on_completion,
+		deploy_environment,
+		deploy_version_bump,
+		deploy_trigger,
+	} = parseArgs(args, updateBodyOfWorkSchema);
+
+	// Check if any updates provided
+	if (title === undefined && description === undefined && auto_deploy_on_completion === undefined &&
+		deploy_environment === undefined && deploy_version_bump === undefined && deploy_trigger === undefined) {
+		return { result: { success: true, message: 'No updates provided' } };
+	}
+
+	const apiClient = getApiClient();
+
+	const response = await apiClient.proxy<{ success: boolean }>('update_body_of_work', {
+		body_of_work_id,
+		title,
+		description,
+		auto_deploy_on_completion,
+		deploy_environment,
+		deploy_version_bump,
+		deploy_trigger
+	});
+
+	if (!response.ok) {
+		return { result: { error: response.error || 'Failed to update body of work' }, isError: true };
+	}
+
+	return { result: { success: true, body_of_work_id } };
+};
+
+export const getBodyOfWork: Handler = async (args, ctx) => {
+	const { body_of_work_id, summary_only } = parseArgs(args, getBodyOfWorkSchema);
+
+	const apiClient = getApiClient();
+
+	// Response type varies based on summary_only
+	const response = await apiClient.proxy<{
+		body_of_work: {
+			id: string;
+			title: string;
+			description?: string;
+			status: string;
+			progress_percentage: number;
+			total_estimated_minutes?: number;
+			completed_estimated_minutes?: number;
+		};
+		// Full response includes tasks grouped by phase
+		tasks?: {
+			pre: unknown[];
+			core: unknown[];
+			post: unknown[];
+		};
+		// Summary response includes counts and next task
+		task_counts?: {
+			pre: { total: number; completed: number };
+			core: { total: number; completed: number };
+			post: { total: number; completed: number };
+			total: number;
+			completed: number;
+			in_progress: number;
+		};
+		current_task?: { id: string; title: string } | null;
+		next_task?: { id: string; title: string; priority: number } | null;
+	}>('get_body_of_work', { body_of_work_id, summary_only });
+
+	if (!response.ok) {
+		return { result: { error: response.error || 'Failed to get body of work' }, isError: true };
+	}
+
+	return { result: response.data };
+};
+
+export const getBodiesOfWork: Handler = async (args, ctx) => {
+	const { project_id, status, limit, offset, search_query } = parseArgs(args, getBodiesOfWorkSchema);
+
+	const apiClient = getApiClient();
+
+	const response = await apiClient.proxy<{
+		bodies_of_work: Array<{
+			id: string;
+			title: string;
+			description?: string;
+			status: string;
+			progress_percentage: number;
+			total_estimated_minutes?: number;
+			completed_estimated_minutes?: number;
+			task_counts: {
+				pre: { total: number; completed: number };
+				core: { total: number; completed: number };
+				post: { total: number; completed: number };
+			};
+		}>;
+		total_count: number;
+		has_more: boolean;
+	}>('get_bodies_of_work', {
+		project_id,
+		status,
+		limit: Math.min(limit ?? 50, 100),
+		offset,
+		search_query
+	});
+
+	if (!response.ok) {
+		return { result: { error: response.error || 'Failed to fetch bodies of work' }, isError: true };
+	}
+
+	return { result: response.data };
+};
+
+export const deleteBodyOfWork: Handler = async (args, ctx) => {
+	const { body_of_work_id } = parseArgs(args, deleteBodyOfWorkSchema);
+
+	const apiClient = getApiClient();
+
+	const response = await apiClient.proxy<{ success: boolean }>('delete_body_of_work', {
+		body_of_work_id
+	});
+
+	if (!response.ok) {
+		return { result: { error: response.error || 'Failed to delete body of work' }, isError: true };
+	}
+
+	return { result: { success: true, message: 'Body of work deleted. Tasks are preserved.' } };
+};
+
+export const addTaskToBodyOfWork: Handler = async (args, ctx) => {
+	const { body_of_work_id, task_id, phase, order_index } = parseArgs(args, addTaskToBodyOfWorkSchema);
+
+	const apiClient = getApiClient();
+
+	const response = await apiClient.proxy<{
+		success: boolean;
+		body_of_work_id: string;
+		task_id: string;
+		phase: string;
+		order_index: number;
+	}>('add_task_to_body_of_work', {
+		body_of_work_id,
+		task_id,
+		phase: phase || 'core',
+		order_index
+	});
+
+	if (!response.ok) {
+		return { result: { error: response.error || 'Failed to add task to body of work' }, isError: true };
+	}
+
+	return { result: response.data };
+};
+
+export const removeTaskFromBodyOfWork: Handler = async (args, ctx) => {
+	const { task_id } = parseArgs(args, removeTaskFromBodyOfWorkSchema);
+
+	const apiClient = getApiClient();
+
+	const response = await apiClient.proxy<{
+		success: boolean;
+		body_of_work_id?: string;
+		message?: string;
+	}>('remove_task_from_body_of_work', { task_id });
+
+	if (!response.ok) {
+		return { result: { error: response.error || 'Failed to remove task from body of work' }, isError: true };
+	}
+
+	return { result: response.data };
+};
+
+export const activateBodyOfWork: Handler = async (args, ctx) => {
+	const { body_of_work_id } = parseArgs(args, activateBodyOfWorkSchema);
+
+	const apiClient = getApiClient();
+
+	const response = await apiClient.proxy<{
+		success: boolean;
+		body_of_work_id: string;
+		title: string;
+		status: string;
+		message: string;
+	}>('activate_body_of_work', { body_of_work_id });
+
+	if (!response.ok) {
+		return { result: { error: response.error || 'Failed to activate body of work' }, isError: true };
+	}
+
+	return { result: response.data };
+};
+
+export const addTaskDependency: Handler = async (args, ctx) => {
+	const { body_of_work_id, task_id, depends_on_task_id } = parseArgs(args, addTaskDependencySchema);
+
+	if (task_id === depends_on_task_id) {
+		return { result: { error: 'A task cannot depend on itself' }, isError: true };
+	}
+
+	const apiClient = getApiClient();
+
+	const response = await apiClient.proxy<{
+		success: boolean;
+		body_of_work_id: string;
+		task_id: string;
+		depends_on_task_id: string;
+		message: string;
+	}>('add_task_dependency', {
+		body_of_work_id,
+		task_id,
+		depends_on_task_id
+	});
+
+	if (!response.ok) {
+		return { result: { error: response.error || 'Failed to add task dependency' }, isError: true };
+	}
+
+	return { result: response.data };
+};
+
+export const removeTaskDependency: Handler = async (args, ctx) => {
+	const { task_id, depends_on_task_id } = parseArgs(args, removeTaskDependencySchema);
+
+	const apiClient = getApiClient();
+
+	const response = await apiClient.proxy<{
+		success: boolean;
+		task_id: string;
+		depends_on_task_id: string;
+	}>('remove_task_dependency', {
+		task_id,
+		depends_on_task_id
+	});
+
+	if (!response.ok) {
+		return { result: { error: response.error || 'Failed to remove task dependency' }, isError: true };
+	}
+
+	return { result: response.data };
+};
+
+export const getTaskDependencies: Handler = async (args, ctx) => {
+	const { body_of_work_id, task_id } = parseArgs(args, getTaskDependenciesSchema);
+
+	if (!body_of_work_id && !task_id) {
+		return { result: { error: 'Either body_of_work_id or task_id is required' }, isError: true };
+	}
+
+	const apiClient = getApiClient();
+
+	const response = await apiClient.proxy<{
+		dependencies: Array<{
+			id: string;
+			task_id: string;
+			depends_on_task_id: string;
+			created_at: string;
+		}>;
+	}>('get_task_dependencies', {
+		body_of_work_id,
+		task_id
+	});
+
+	if (!response.ok) {
+		return { result: { error: response.error || 'Failed to fetch task dependencies' }, isError: true };
+	}
+
+	return { result: response.data };
+};
+
+export const getNextBodyOfWorkTask: Handler = async (args, ctx) => {
+	const { body_of_work_id } = parseArgs(args, getNextBodyOfWorkTaskSchema);
+
+	const apiClient = getApiClient();
+
+	const response = await apiClient.proxy<{
+		next_task: {
+			id: string;
+			title: string;
+			phase: string;
+			priority: number;
+		} | null;
+		body_of_work?: {
+			id: string;
+			title: string;
+		};
+		message?: string;
+	}>('get_next_body_of_work_task', { body_of_work_id });
+
+	if (!response.ok) {
+		return { result: { error: response.error || 'Failed to get next body of work task' }, isError: true };
+	}
+
+	return { result: response.data };
+};
+
+// ============================================================================
+// Archive / Unarchive Handlers
+// ============================================================================
+
+const archiveBodyOfWorkSchema = {
+	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const unarchiveBodyOfWorkSchema = {
+	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+export const archiveBodyOfWork: Handler = async (args, ctx) => {
+	const { body_of_work_id } = parseArgs(args, archiveBodyOfWorkSchema);
+
+	const apiClient = getApiClient();
+
+	const response = await apiClient.proxy<{
+		success: boolean;
+		body_of_work_id: string;
+		title: string;
+		previous_status: string;
+		new_status: string;
+	}>('archive_body_of_work', { body_of_work_id });
+
+	if (!response.ok) {
+		return { result: { error: response.error || 'Failed to archive body of work' }, isError: true };
+	}
+
+	return { result: response.data };
+};
+
+export const unarchiveBodyOfWork: Handler = async (args, ctx) => {
+	const { body_of_work_id } = parseArgs(args, unarchiveBodyOfWorkSchema);
+
+	const apiClient = getApiClient();
+
+	const response = await apiClient.proxy<{
+		success: boolean;
+		body_of_work_id: string;
+		title: string;
+		previous_status: string;
+		new_status: string;
+	}>('unarchive_body_of_work', { body_of_work_id });
+
+	if (!response.ok) {
+		return { result: { error: response.error || 'Failed to unarchive body of work' }, isError: true };
+	}
+
+	return { result: response.data };
+};
+
+/**
+ * Bodies of Work handlers registry
+ */
+export const bodiesOfWorkHandlers: HandlerRegistry = {
+	create_body_of_work: createBodyOfWork,
+	update_body_of_work: updateBodyOfWork,
+	get_body_of_work: getBodyOfWork,
+	get_bodies_of_work: getBodiesOfWork,
+	delete_body_of_work: deleteBodyOfWork,
+	add_task_to_body_of_work: addTaskToBodyOfWork,
+	remove_task_from_body_of_work: removeTaskFromBodyOfWork,
+	activate_body_of_work: activateBodyOfWork,
+	add_task_dependency: addTaskDependency,
+	remove_task_dependency: removeTaskDependency,
+	get_task_dependencies: getTaskDependencies,
+	get_next_body_of_work_task: getNextBodyOfWorkTask,
+	archive_body_of_work: archiveBodyOfWork,
+	unarchive_body_of_work: unarchiveBodyOfWork,
+};