@vibescope/mcp-server 0.0.1 → 0.1.0

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

@@ -14,10 +14,13 @@
  * - 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 { validateRequired, validateUUID } from '../validators.js';
+import { getApiClient } from '../api-client.js';
 
 type BodyOfWorkStatus = 'draft' | 'active' | 'completed' | 'cancelled';
 type TaskPhase = 'pre' | 'core' | 'post';
@@ -48,30 +51,34 @@ export const createBodyOfWork: Handler = async (args, ctx) => {
 	validateUUID(project_id, 'project_id');
 	validateRequired(title, 'title');
 
-	const { supabase, session } = ctx;
+	const { session } = ctx;
+	const apiClient = getApiClient();
 
-	const { data, error } = await supabase
-		.from('bodies_of_work')
-		.insert({
-			project_id,
-			title,
-			description: description || null,
-			auto_deploy_on_completion: auto_deploy_on_completion || false,
-			deploy_environment: deploy_environment || 'production',
-			deploy_version_bump: deploy_version_bump || 'minor',
-			deploy_trigger: deploy_trigger || 'all_completed_validated',
-			created_by: 'agent',
-			created_by_session_id: session.currentSessionId,
-		})
-		.select('id')
-		.single();
-
-	if (error) throw new Error(`Failed to create body of work: ${error.message}`);
+	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) {
+		throw new Error(`Failed to create body of work: ${response.error}`);
+	}
 
 	return {
 		result: {
 			success: true,
-			body_of_work_id: data.id,
+			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.',
@@ -101,27 +108,27 @@ export const updateBodyOfWork: Handler = async (args, ctx) => {
 	validateRequired(body_of_work_id, 'body_of_work_id');
 	validateUUID(body_of_work_id, 'body_of_work_id');
 
-	const { supabase } = ctx;
-
-	// Build update object
-	const updates: Record<string, unknown> = {};
-	if (title !== undefined) updates.title = title;
-	if (description !== undefined) updates.description = description;
-	if (auto_deploy_on_completion !== undefined) updates.auto_deploy_on_completion = auto_deploy_on_completion;
-	if (deploy_environment !== undefined) updates.deploy_environment = deploy_environment;
-	if (deploy_version_bump !== undefined) updates.deploy_version_bump = deploy_version_bump;
-	if (deploy_trigger !== undefined) updates.deploy_trigger = deploy_trigger;
-
-	if (Object.keys(updates).length === 0) {
+	// 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 { error } = await supabase
-		.from('bodies_of_work')
-		.update(updates)
-		.eq('id', body_of_work_id);
+	const apiClient = getApiClient();
 
-	if (error) throw new Error(`Failed to update body of work: ${error.message}`);
+	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) {
+		throw new Error(`Failed to update body of work: ${response.error}`);
+	}
 
 	return { result: { success: true, body_of_work_id } };
 };
@@ -132,154 +139,69 @@ export const getBodyOfWork: Handler = async (args, ctx) => {
 	validateRequired(body_of_work_id, 'body_of_work_id');
 	validateUUID(body_of_work_id, 'body_of_work_id');
 
-	const { supabase } = ctx;
-
-	// Get body of work
-	const { data: bow, error: bowError } = await supabase
-		.from('bodies_of_work')
-		.select('*')
-		.eq('id', body_of_work_id)
-		.single();
-
-	if (bowError || !bow) {
-		throw new Error(`Body of work not found: ${body_of_work_id}`);
-	}
+	const apiClient = getApiClient();
 
-	// Get tasks with their phases
-	const { data: taskLinks, error: taskError } = await supabase
-		.from('body_of_work_tasks')
-		.select(`
-			phase,
-			order_index,
-			tasks (
-				id,
-				title,
-				status,
-				priority,
-				progress_percentage
-			)
-		`)
-		.eq('body_of_work_id', body_of_work_id)
-		.order('order_index');
-
-	if (taskError) throw new Error(`Failed to fetch tasks: ${taskError.message}`);
-
-	// Organize tasks by phase
-	const preTasks: unknown[] = [];
-	const coreTasks: unknown[] = [];
-	const postTasks: unknown[] = [];
-
-	for (const link of taskLinks || []) {
-		const task = link.tasks;
-		if (!task) continue;
-
-		const taskWithPhase = { ...task, order_index: link.order_index };
-
-		switch (link.phase) {
-			case 'pre':
-				preTasks.push(taskWithPhase);
-				break;
-			case 'core':
-				coreTasks.push(taskWithPhase);
-				break;
-			case 'post':
-				postTasks.push(taskWithPhase);
-				break;
-		}
+	const response = await apiClient.proxy<{
+		id: string;
+		title: string;
+		description?: string;
+		status: string;
+		progress_percentage: number;
+		pre_tasks: unknown[];
+		core_tasks: unknown[];
+		post_tasks: unknown[];
+		total_tasks: number;
+	}>('get_body_of_work', { body_of_work_id });
+
+	if (!response.ok) {
+		throw new Error(`Failed to get body of work: ${response.error}`);
 	}
 
-	return {
-		result: {
-			...bow,
-			pre_tasks: preTasks,
-			core_tasks: coreTasks,
-			post_tasks: postTasks,
-			total_tasks: preTasks.length + coreTasks.length + postTasks.length,
-		},
-	};
+	return { result: response.data };
 };
 
 export const getBodiesOfWork: Handler = async (args, ctx) => {
-	const { project_id, status } = args as {
+	const { project_id, status, limit = 50, offset = 0, search_query } = args as {
 		project_id: string;
 		status?: BodyOfWorkStatus;
+		limit?: number;
+		offset?: number;
+		search_query?: string;
 	};
 
 	validateRequired(project_id, 'project_id');
 	validateUUID(project_id, 'project_id');
 
-	const { supabase } = ctx;
-
-	let query = supabase
-		.from('bodies_of_work')
-		.select(`
-			id,
-			title,
-			description,
-			status,
-			progress_percentage,
-			auto_deploy_on_completion,
-			deploy_environment,
-			deploy_version_bump,
-			created_at,
-			activated_at,
-			completed_at
-		`)
-		.eq('project_id', project_id);
-
-	if (status) {
-		query = query.eq('status', status);
-	}
-
-	const { data, error } = await query.order('created_at', { ascending: false });
-
-	if (error) throw new Error(`Failed to fetch bodies of work: ${error.message}`);
-
-	const bodies = data || [];
-	if (bodies.length === 0) {
-		return { result: { bodies_of_work: [] } };
-	}
+	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, 100),
+		offset,
+		search_query
+	});
 
-	// Batch query: get all task links for all bodies of work in a single query
-	const bodyIds = bodies.map((b) => b.id);
-	const { data: allTaskLinks } = await supabase
-		.from('body_of_work_tasks')
-		.select('body_of_work_id, phase, tasks!inner(status)')
-		.in('body_of_work_id', bodyIds);
-
-	// Group task links by body_of_work_id
-	const taskLinksByBody = new Map<string, typeof allTaskLinks>();
-	for (const link of allTaskLinks || []) {
-		const existing = taskLinksByBody.get(link.body_of_work_id) || [];
-		existing.push(link);
-		taskLinksByBody.set(link.body_of_work_id, existing);
+	if (!response.ok) {
+		throw new Error(`Failed to fetch bodies of work: ${response.error}`);
 	}
 
-	// Build response with task counts
-	const bodiesWithCounts = bodies.map((bow) => {
-		const taskLinks = taskLinksByBody.get(bow.id) || [];
-		const taskCounts = {
-			pre: { total: 0, completed: 0 },
-			core: { total: 0, completed: 0 },
-			post: { total: 0, completed: 0 },
-		};
-
-		for (const link of taskLinks) {
-			const phase = link.phase as TaskPhase;
-			taskCounts[phase].total++;
-			const taskData = link.tasks as unknown as { status: string } | null;
-			if (taskData?.status === 'completed') {
-				taskCounts[phase].completed++;
-			}
-		}
-
-		return {
-			...bow,
-			task_counts: taskCounts,
-		};
-	});
-
-	return { result: { bodies_of_work: bodiesWithCounts } };
+	return { result: response.data };
 };
 
 export const deleteBodyOfWork: Handler = async (args, ctx) => {
@@ -288,12 +210,15 @@ export const deleteBodyOfWork: Handler = async (args, ctx) => {
 	validateRequired(body_of_work_id, 'body_of_work_id');
 	validateUUID(body_of_work_id, 'body_of_work_id');
 
-	const { error } = await ctx.supabase
-		.from('bodies_of_work')
-		.delete()
-		.eq('id', body_of_work_id);
+	const apiClient = getApiClient();
+
+	const response = await apiClient.proxy<{ success: boolean }>('delete_body_of_work', {
+		body_of_work_id
+	});
 
-	if (error) throw new Error(`Failed to delete body of work: ${error.message}`);
+	if (!response.ok) {
+		throw new Error(`Failed to delete body of work: ${response.error}`);
+	}
 
 	return { result: { success: true, message: 'Body of work deleted. Tasks are preserved.' } };
 };
@@ -311,70 +236,26 @@ export const addTaskToBodyOfWork: Handler = async (args, ctx) => {
 	validateRequired(task_id, 'task_id');
 	validateUUID(task_id, 'task_id');
 
-	const { supabase } = ctx;
-	const taskPhase = phase || 'core';
+	const apiClient = getApiClient();
 
-	// Check if body of work exists and is in draft/active status
-	const { data: bow, error: bowError } = await supabase
-		.from('bodies_of_work')
-		.select('status')
-		.eq('id', body_of_work_id)
-		.single();
-
-	if (bowError || !bow) {
-		throw new Error(`Body of work not found: ${body_of_work_id}`);
-	}
-
-	if (bow.status === 'completed' || bow.status === 'cancelled') {
-		throw new Error(`Cannot add tasks to ${bow.status} body of work`);
-	}
-
-	// Check if task is already in a body of work
-	const { data: existingLink } = await supabase
-		.from('body_of_work_tasks')
-		.select('body_of_work_id')
-		.eq('task_id', task_id)
-		.single();
-
-	if (existingLink) {
-		throw new Error('Task is already assigned to a body of work. Remove it first.');
-	}
+	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
+	});
 
-	// Get the next order index if not provided
-	let finalOrderIndex = order_index;
-	if (finalOrderIndex === undefined) {
-		const { data: maxOrder } = await supabase
-			.from('body_of_work_tasks')
-			.select('order_index')
-			.eq('body_of_work_id', body_of_work_id)
-			.eq('phase', taskPhase)
-			.order('order_index', { ascending: false })
-			.limit(1)
-			.single();
-
-		finalOrderIndex = maxOrder ? maxOrder.order_index + 1 : 0;
+	if (!response.ok) {
+		throw new Error(`Failed to add task to body of work: ${response.error}`);
 	}
 
-	const { error } = await supabase
-		.from('body_of_work_tasks')
-		.insert({
-			body_of_work_id,
-			task_id,
-			phase: taskPhase,
-			order_index: finalOrderIndex,
-		});
-
-	if (error) throw new Error(`Failed to add task to body of work: ${error.message}`);
-
-	return {
-		result: {
-			success: true,
-			body_of_work_id,
-			task_id,
-			phase: taskPhase,
-			order_index: finalOrderIndex,
-		},
-	};
+	return { result: response.data };
 };
 
 export const removeTaskFromBodyOfWork: Handler = async (args, ctx) => {
@@ -383,38 +264,19 @@ export const removeTaskFromBodyOfWork: Handler = async (args, ctx) => {
 	validateRequired(task_id, 'task_id');
 	validateUUID(task_id, 'task_id');
 
-	const { supabase } = ctx;
-
-	// Check if link exists
-	const { data: link } = await supabase
-		.from('body_of_work_tasks')
-		.select('body_of_work_id')
-		.eq('task_id', task_id)
-		.single();
-
-	if (!link) {
-		return { result: { success: true, message: 'Task is not in any body of work' } };
-	}
+	const apiClient = getApiClient();
 
-	// Check if body of work is completed
-	const { data: bow } = await supabase
-		.from('bodies_of_work')
-		.select('status')
-		.eq('id', link.body_of_work_id)
-		.single();
+	const response = await apiClient.proxy<{
+		success: boolean;
+		body_of_work_id?: string;
+		message?: string;
+	}>('remove_task_from_body_of_work', { task_id });
 
-	if (bow?.status === 'completed') {
-		throw new Error('Cannot remove tasks from a completed body of work');
+	if (!response.ok) {
+		throw new Error(`Failed to remove task from body of work: ${response.error}`);
 	}
 
-	const { error } = await supabase
-		.from('body_of_work_tasks')
-		.delete()
-		.eq('task_id', task_id);
-
-	if (error) throw new Error(`Failed to remove task from body of work: ${error.message}`);
-
-	return { result: { success: true, body_of_work_id: link.body_of_work_id } };
+	return { result: response.data };
 };
 
 export const activateBodyOfWork: Handler = async (args, ctx) => {
@@ -423,52 +285,21 @@ export const activateBodyOfWork: Handler = async (args, ctx) => {
 	validateRequired(body_of_work_id, 'body_of_work_id');
 	validateUUID(body_of_work_id, 'body_of_work_id');
 
-	const { supabase } = ctx;
-
-	// Check current status
-	const { data: bow, error: bowError } = await supabase
-		.from('bodies_of_work')
-		.select('status, title')
-		.eq('id', body_of_work_id)
-		.single();
+	const apiClient = getApiClient();
 
-	if (bowError || !bow) {
-		throw new Error(`Body of work not found: ${body_of_work_id}`);
-	}
-
-	if (bow.status !== 'draft') {
-		throw new Error(`Can only activate draft bodies of work. Current status: ${bow.status}`);
-	}
-
-	// Check if there are any tasks
-	const { count } = await supabase
-		.from('body_of_work_tasks')
-		.select('id', { count: 'exact', head: true })
-		.eq('body_of_work_id', body_of_work_id);
+	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 (!count || count === 0) {
-		throw new Error('Cannot activate body of work with no tasks. Add tasks first.');
+	if (!response.ok) {
+		throw new Error(`Failed to activate body of work: ${response.error}`);
 	}
 
-	const { error } = await supabase
-		.from('bodies_of_work')
-		.update({
-			status: 'active',
-			activated_at: new Date().toISOString(),
-		})
-		.eq('id', body_of_work_id);
-
-	if (error) throw new Error(`Failed to activate body of work: ${error.message}`);
-
-	return {
-		result: {
-			success: true,
-			body_of_work_id,
-			title: bow.title,
-			status: 'active',
-			message: 'Body of work activated. Tasks can now be worked on following phase order.',
-		},
-	};
+	return { result: response.data };
 };
 
 export const addTaskDependency: Handler = async (args, ctx) => {
@@ -489,70 +320,25 @@ export const addTaskDependency: Handler = async (args, ctx) => {
 		throw new Error('A task cannot depend on itself');
 	}
 
-	const { supabase } = ctx;
-
-	// Verify both tasks belong to the same body of work
-	const { data: taskLinks, error: taskError } = await supabase
-		.from('body_of_work_tasks')
-		.select('task_id')
-		.eq('body_of_work_id', body_of_work_id)
-		.in('task_id', [task_id, depends_on_task_id]);
-
-	if (taskError) throw new Error(`Failed to verify tasks: ${taskError.message}`);
-
-	if (!taskLinks || taskLinks.length !== 2) {
-		throw new Error('Both tasks must belong to the specified body of work');
-	}
-
-	// Check for circular dependencies by traversing the dependency graph
-	const visited = new Set<string>();
-	const checkCircular = async (currentTaskId: string): Promise<boolean> => {
-		if (currentTaskId === task_id) return true; // Found cycle
-		if (visited.has(currentTaskId)) return false;
-		visited.add(currentTaskId);
-
-		const { data: deps } = await supabase
-			.from('body_of_work_task_dependencies')
-			.select('depends_on_task_id')
-			.eq('task_id', currentTaskId)
-			.eq('body_of_work_id', body_of_work_id);
-
-		for (const dep of deps || []) {
-			if (await checkCircular(dep.depends_on_task_id)) {
-				return true;
-			}
-		}
-		return false;
-	};
+	const apiClient = getApiClient();
 
-	if (await checkCircular(depends_on_task_id)) {
-		throw new Error('Cannot add dependency: would create a circular dependency');
-	}
+	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
+	});
 
-	const { error } = await supabase
-		.from('body_of_work_task_dependencies')
-		.insert({
-			body_of_work_id,
-			task_id,
-			depends_on_task_id,
-		});
-
-	if (error) {
-		if (error.message.includes('duplicate')) {
-			throw new Error('This dependency already exists');
-		}
-		throw new Error(`Failed to add dependency: ${error.message}`);
+	if (!response.ok) {
+		throw new Error(`Failed to add task dependency: ${response.error}`);
 	}
 
-	return {
-		result: {
-			success: true,
-			body_of_work_id,
-			task_id,
-			depends_on_task_id,
-			message: `Task now depends on completion of the specified task`,
-		},
-	};
+	return { result: response.data };
 };
 
 export const removeTaskDependency: Handler = async (args, ctx) => {
@@ -566,17 +352,22 @@ export const removeTaskDependency: Handler = async (args, ctx) => {
 	validateRequired(depends_on_task_id, 'depends_on_task_id');
 	validateUUID(depends_on_task_id, 'depends_on_task_id');
 
-	const { supabase } = ctx;
+	const apiClient = getApiClient();
 
-	const { error } = await supabase
-		.from('body_of_work_task_dependencies')
-		.delete()
-		.eq('task_id', task_id)
-		.eq('depends_on_task_id', depends_on_task_id);
+	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 (error) throw new Error(`Failed to remove dependency: ${error.message}`);
+	if (!response.ok) {
+		throw new Error(`Failed to remove task dependency: ${response.error}`);
+	}
 
-	return { result: { success: true, task_id, depends_on_task_id } };
+	return { result: response.data };
 };
 
 export const getTaskDependencies: Handler = async (args, ctx) => {
@@ -592,29 +383,25 @@ export const getTaskDependencies: Handler = async (args, ctx) => {
 	if (body_of_work_id) validateUUID(body_of_work_id, 'body_of_work_id');
 	if (task_id) validateUUID(task_id, 'task_id');
 
-	const { supabase } = ctx;
+	const apiClient = getApiClient();
 
-	let query = supabase
-		.from('body_of_work_task_dependencies')
-		.select(`
-			id,
-			task_id,
-			depends_on_task_id,
-			created_at
-		`);
+	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 (body_of_work_id) {
-		query = query.eq('body_of_work_id', body_of_work_id);
-	}
-	if (task_id) {
-		query = query.eq('task_id', task_id);
+	if (!response.ok) {
+		throw new Error(`Failed to fetch task dependencies: ${response.error}`);
 	}
 
-	const { data, error } = await query;
-
-	if (error) throw new Error(`Failed to fetch dependencies: ${error.message}`);
-
-	return { result: { dependencies: data || [] } };
+	return { result: response.data };
 };
 
 export const getNextBodyOfWorkTask: Handler = async (args, ctx) => {
@@ -623,145 +410,27 @@ export const getNextBodyOfWorkTask: Handler = async (args, ctx) => {
 	validateRequired(body_of_work_id, 'body_of_work_id');
 	validateUUID(body_of_work_id, 'body_of_work_id');
 
-	const { supabase } = ctx;
-
-	// Get body of work status
-	const { data: bow, error: bowError } = await supabase
-		.from('bodies_of_work')
-		.select('status, title')
-		.eq('id', body_of_work_id)
-		.single();
-
-	if (bowError || !bow) {
-		throw new Error(`Body of work not found: ${body_of_work_id}`);
-	}
-
-	if (bow.status !== 'active') {
-		return {
-			result: {
-				next_task: null,
-				message: `Body of work is ${bow.status}, not active`,
-			},
+	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;
 		};
-	}
-
-	// Get all tasks with their status and phase
-	const { data: taskLinks, error: taskError } = await supabase
-		.from('body_of_work_tasks')
-		.select(`
-			task_id,
-			phase,
-			order_index,
-			tasks (
-				id,
-				title,
-				status,
-				priority,
-				claimed_by_session_id
-			)
-		`)
-		.eq('body_of_work_id', body_of_work_id)
-		.order('order_index');
-
-	if (taskError) throw new Error(`Failed to fetch tasks: ${taskError.message}`);
-
-	// Get all dependencies
-	const { data: dependencies } = await supabase
-		.from('body_of_work_task_dependencies')
-		.select('task_id, depends_on_task_id')
-		.eq('body_of_work_id', body_of_work_id);
-
-	const depMap = new Map<string, string[]>();
-	for (const dep of dependencies || []) {
-		const existing = depMap.get(dep.task_id) || [];
-		existing.push(dep.depends_on_task_id);
-		depMap.set(dep.task_id, existing);
-	}
-
-	// Build task status map
-	const taskStatusMap = new Map<string, string>();
-	for (const link of taskLinks || []) {
-		const task = link.tasks as unknown as { id: string; status: string } | null;
-		if (task) {
-			taskStatusMap.set(task.id, task.status);
-		}
-	}
-
-	// Check if all dependencies are completed
-	const areDependenciesComplete = (taskId: string): boolean => {
-		const deps = depMap.get(taskId) || [];
-		return deps.every((depId) => taskStatusMap.get(depId) === 'completed');
-	};
-
-	// Phase order: pre -> core -> post
-	const phaseOrder = ['pre', 'core', 'post'];
-
-	// Check if all tasks in a phase are completed
-	const isPhaseComplete = (phase: string): boolean => {
-		return (taskLinks || [])
-			.filter((link) => link.phase === phase)
-			.every((link) => {
-				const task = link.tasks as unknown as { status: string } | null;
-				return task?.status === 'completed';
-			});
-	};
+		message?: string;
+	}>('get_next_body_of_work_task', { body_of_work_id });
 
-	// Find the next available task
-	for (const phase of phaseOrder) {
-		// Check if we can work on this phase
-		const prevPhaseIndex = phaseOrder.indexOf(phase) - 1;
-		if (prevPhaseIndex >= 0 && !isPhaseComplete(phaseOrder[prevPhaseIndex])) {
-			continue; // Previous phase not complete, skip this phase
-		}
-
-		const phaseTasks = (taskLinks || [])
-			.filter((link) => link.phase === phase)
-			.sort((a, b) => a.order_index - b.order_index);
-
-		for (const link of phaseTasks) {
-			const task = link.tasks as unknown as {
-				id: string;
-				title: string;
-				status: string;
-				priority: number;
-				claimed_by_session_id: string | null;
-			} | null;
-
-			if (!task) continue;
-
-			// Skip completed, cancelled, or in-progress tasks
-			if (task.status !== 'pending') continue;
-
-			// Skip tasks claimed by another session
-			if (task.claimed_by_session_id) continue;
-
-			// Check dependencies
-			if (!areDependenciesComplete(task.id)) continue;
-
-			return {
-				result: {
-					next_task: {
-						id: task.id,
-						title: task.title,
-						phase: link.phase,
-						priority: task.priority,
-					},
-					body_of_work: {
-						id: body_of_work_id,
-						title: bow.title,
-					},
-				},
-			};
-		}
+	if (!response.ok) {
+		throw new Error(`Failed to get next body of work task: ${response.error}`);
 	}
 
-	// No available tasks
-	return {
-		result: {
-			next_task: null,
-			message: 'No available tasks - all are completed, in progress, or blocked by dependencies',
-		},
-	};
+	return { result: response.data };
 };
 
 /**