@vibescope/mcp-server 0.0.1 → 0.2.0

package/src/handlers/tasks.ts

@@ -1,5 +1,5 @@
 /**
- * Task Handlers
+ * Task Handlers (Migrated to API Client)
  *
  * Handles task CRUD and management:
  * - get_tasks
@@ -12,39 +12,33 @@
  * - remove_task_reference
  * - batch_update_tasks
  * - batch_complete_tasks
+ * - add_subtask
+ * - get_subtasks
  */
 
-import type { Handler, HandlerRegistry, HandlerContext } from './types.js';
-import type { SupabaseClient } from '@supabase/supabase-js';
+import type { Handler, HandlerRegistry } from './types.js';
 import {
-	ValidationError,
 	validateRequired,
 	validateUUID,
 	validateTaskStatus,
 	validatePriority,
 	validateProgressPercentage,
 	validateEstimatedMinutes,
+	ValidationError,
 } from '../validators.js';
-import { getRandomFallbackActivity, isValidStatusTransition } from '../utils.js';
+import { getApiClient } from '../api-client.js';
+
+// ============================================================================
+// Git workflow helpers (used by complete_task response)
+// ============================================================================
 
-/**
- * Git workflow instructions generator
- */
 interface GitWorkflowConfig {
 	git_workflow: string;
 	git_main_branch: string;
-	git_develop_branch?: string;
+	git_develop_branch?: string | null;
 	git_auto_branch?: boolean;
 }
 
-// Enhanced return types for git instructions
-interface GitStartInstructions {
-	branch_name: string;
-	base_branch: string;
-	steps: string[];
-	reminder: string;
-}
-
 interface GitCompleteInstructions {
 	steps: string[];
 	pr_suggestion?: {
@@ -62,52 +56,21 @@ interface GitMergeInstructions {
 	note: string;
 }
 
-function generateBranchName(taskId: string, taskTitle: string): string {
-	const slug = taskTitle.toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 30);
-	return `feature/${taskId.slice(0, 8)}-${slug}`;
-}
-
-function getTaskStartGitInstructions(
-	config: GitWorkflowConfig,
-	taskId: string,
-	taskTitle: string
-): GitStartInstructions | undefined {
-	const { git_workflow, git_main_branch, git_develop_branch } = config;
-
-	if (git_workflow === 'none' || git_workflow === 'trunk-based') {
-		return undefined;
-	}
-
-	const branchName = generateBranchName(taskId, taskTitle);
-	const baseBranch = git_workflow === 'git-flow' ? (git_develop_branch || 'develop') : git_main_branch;
-
-	return {
-		branch_name: branchName,
-		base_branch: baseBranch,
-		steps: [
-			`git checkout ${baseBranch}`,
-			`git pull origin ${baseBranch}`,
-			`git checkout -b ${branchName}`,
-		],
-		reminder: `After creating the branch, update task: update_task(task_id: "${taskId}", git_branch: "${branchName}")`,
-	};
-}
-
 function getTaskCompleteGitInstructions(
-	config: GitWorkflowConfig,
+	gitWorkflow: string,
+	gitMainBranch: string,
+	gitDevelopBranch: string | undefined,
 	taskBranch: string | undefined,
 	taskTitle: string,
 	taskId: string
 ): GitCompleteInstructions | undefined {
-	const { git_workflow, git_main_branch } = config;
-
-	if (git_workflow === 'none') {
+	if (gitWorkflow === 'none') {
 		return undefined;
 	}
 
-	if (git_workflow === 'trunk-based') {
+	if (gitWorkflow === 'trunk-based') {
 		return {
-			steps: [`git add .`, `git commit -m "feat: ${taskTitle}"`, `git push origin ${git_main_branch}`],
+			steps: [`git add .`, `git commit -m "feat: ${taskTitle}"`, `git push origin ${gitMainBranch}`],
 			next_step: 'Changes committed directly to main branch.',
 		};
 	}
@@ -130,7 +93,7 @@ function getTaskCompleteGitInstructions(
 	};
 }
 
-function getValidationApprovedGitInstructions(
+export function getValidationApprovedGitInstructions(
 	config: GitWorkflowConfig,
 	taskBranch: string | undefined
 ): GitMergeInstructions | undefined {
@@ -158,355 +121,104 @@ function getValidationApprovedGitInstructions(
 	};
 }
 
-export async function getProjectGitConfig(supabase: SupabaseClient, projectId: string): Promise<GitWorkflowConfig | null> {
-	const { data } = await supabase
-		.from('projects')
-		.select('git_workflow, git_main_branch, git_develop_branch, git_auto_branch')
-		.eq('id', projectId)
-		.single();
-
-	return data as GitWorkflowConfig | null;
-}
-
-export { getValidationApprovedGitInstructions };
-
-/**
- * Check if a session is still active
- */
-async function checkSessionStatus(
-	ctx: HandlerContext,
-	sessionId: string
-): Promise<{ exists: boolean; isActive: boolean; agentName?: string }> {
-	const { data: session } = await ctx.supabase
-		.from('agent_sessions')
-		.select('id, status, last_synced_at, agent_name, instance_id')
-		.eq('id', sessionId)
-		.single();
-
-	if (!session) {
-		return { exists: false, isActive: false };
-	}
-
-	const lastSync = new Date(session.last_synced_at).getTime();
-	const fiveMinutesAgo = Date.now() - 5 * 60 * 1000;
-	const isActive = session.status !== 'disconnected' && lastSync > fiveMinutesAgo;
-
-	return {
-		exists: true,
-		isActive,
-		agentName: session.agent_name || `Agent ${session.instance_id?.slice(0, 8) || sessionId.slice(0, 8)}`,
-	};
-}
+// ============================================================================
+// Task Handlers - Using API Client
+// ============================================================================
 
 export const getTasks: Handler = async (args, ctx) => {
-	const { project_id, status, limit = 50, include_subtasks = false } = args as {
+	const { project_id, status, limit = 50, offset = 0, search_query, include_subtasks = false, include_metadata = false } = args as {
 		project_id: string;
 		status?: string;
 		limit?: number;
+		offset?: number;
+		search_query?: string;
 		include_subtasks?: boolean;
+		include_metadata?: boolean; // When true, returns all task fields; when false (default), only id/title/priority/status
 	};
 
 	validateRequired(project_id, 'project_id');
 	validateUUID(project_id, 'project_id');
 	validateTaskStatus(status);
 
-	let query = ctx.supabase
-		.from('tasks')
-		.select('id, title, description, priority, status, progress_percentage, estimated_minutes, started_at, completed_at, parent_task_id')
-		.eq('project_id', project_id)
-		.order('priority', { ascending: true })
-		.order('created_at', { ascending: false })
-		.limit(limit);
-
-	// By default, only return root tasks (not subtasks)
-	if (!include_subtasks) {
-		query = query.is('parent_task_id', null);
-	}
+	const api = getApiClient();
+	const response = await api.getTasks(project_id, {
+		status,
+		limit: Math.min(limit, 200),
+		offset,
+		include_subtasks,
+		search_query,
+		include_metadata,
+	});
 
-	if (status) {
-		query = query.eq('status', status);
+	if (!response.ok) {
+		throw new Error(`Failed to fetch tasks: ${response.error}`);
 	}
 
-	const { data, error } = await query;
-
-	if (error) throw new Error(`Failed to fetch tasks: ${error.message}`);
-
-	return { result: { tasks: data || [] } };
+	return {
+		result: {
+			tasks: response.data?.tasks || [],
+			total_count: response.data?.total_count || 0,
+			has_more: response.data?.has_more || false,
+		},
+	};
 };
 
 export const getNextTask: Handler = async (args, ctx) => {
 	const { project_id } = args as { project_id: string };
-	const { supabase, session } = ctx;
-	const currentSessionId = session.currentSessionId;
-
-	// FIRST: Check for blocking tasks (highest priority - deployment finalization)
-	const { data: blockingTask } = await supabase
-		.from('tasks')
-		.select('id, title, description, priority, estimated_minutes, blocking')
-		.eq('project_id', project_id)
-		.eq('blocking', true)
-		.in('status', ['pending', 'in_progress'])
-		.order('priority', { ascending: true })
-		.limit(1)
-		.single();
-
-	if (blockingTask) {
-		return {
-			result: {
-				task: {
-					id: blockingTask.id,
-					title: blockingTask.title,
-					description: blockingTask.description,
-					priority: blockingTask.priority,
-					estimated_minutes: blockingTask.estimated_minutes,
-					blocking: true,
-				},
-				blocking_task: true,
-				message: 'BLOCKING TASK: This task must be completed before any other work can proceed. No other tasks will be assigned until this is done.',
-				directive: 'Start this task immediately. Do not ask for permission.',
-			},
-		};
-	}
 
-	// Check for active deployment (blocks regular task work)
-	const { data: activeDeployment } = await supabase
-		.from('deployments')
-		.select('id, status, environment, created_at, validation_completed_at')
-		.eq('project_id', project_id)
-		.not('status', 'in', '("deployed","failed")')
-		.order('created_at', { ascending: false })
-		.limit(1)
-		.single();
-
-	if (activeDeployment) {
-		const actions: Record<string, string> = {
-			pending: 'claim_deployment_validation',
-			validating: 'wait',
-			ready: 'start_deployment',
-			deploying: 'wait for complete_deployment',
-		};
+	validateRequired(project_id, 'project_id');
+	validateUUID(project_id, 'project_id');
 
-		return {
-			result: {
-				task: null,
-				deployment_blocks_tasks: true,
-				deployment: {
-					id: activeDeployment.id,
-					status: activeDeployment.status,
-					env: activeDeployment.environment,
-				},
-				action: actions[activeDeployment.status] || 'check_deployment_status',
-			},
-		};
-	}
+	const api = getApiClient();
+	const response = await api.getNextTask(project_id, ctx.session.currentSessionId || undefined);
 
-	// Check for tasks awaiting validation (blocks new work - validate first!)
-	const { data: validationTasks } = await supabase
-		.from('tasks')
-		.select('id, title')
-		.eq('project_id', project_id)
-		.eq('status', 'completed')
-		.is('validated_at', null)
-		.order('completed_at', { ascending: true })
-		.limit(5);
-
-	if (validationTasks?.length) {
-		return {
-			result: {
-				task: null,
-				awaiting_validation: validationTasks,
-				validation_priority: `VALIDATE FIRST: ${validationTasks.length} task(s) need review before starting new work. Call validate_task for each.`,
-				suggested_activity: 'validate_completed_tasks',
-				directive: 'Start validating tasks immediately. Do not ask for permission.',
-			},
-		};
-	}
-
-	// Fetch candidate pending root tasks (not subtasks)
-	const { data: candidates, error } = await supabase
-		.from('tasks')
-		.select('id, title, description, priority, estimated_minutes, working_agent_session_id')
-		.eq('project_id', project_id)
-		.eq('status', 'pending')
-		.is('parent_task_id', null)
-		.order('priority', { ascending: true })
-		.order('created_at', { ascending: true })
-		.limit(10);
-
-	// Fetch pending agent requests
-	const { data: pendingRequests } = await supabase
-		.from('agent_requests')
-		.select('id, message')
-		.eq('project_id', project_id)
-		.is('acknowledged_at', null)
-		.or(`session_id.is.null,session_id.eq.${currentSessionId}`)
-		.limit(3);
-
-	// Fetch due scheduled activities
-	const { data: dueSchedules } = await supabase
-		.from('background_activity_schedules')
-		.select('activity_type')
-		.eq('project_id', project_id)
-		.eq('enabled', true)
-		.lt('next_run_at', new Date().toISOString())
-		.limit(3);
-
-	// Build compact optional fields (only include if non-empty)
-	const extras: Record<string, unknown> = {};
-	if (pendingRequests?.length) extras.requests = pendingRequests;
-	if (dueSchedules?.length) extras.due_activities = dueSchedules.map(s => s.activity_type);
-
-	if (error || !candidates || candidates.length === 0) {
-		const fallback = getRandomFallbackActivity();
-		return {
-			result: {
-				task: null,
-				...extras,
-				suggested_activity: fallback.activity,
-				directive: 'No tasks available. Start the suggested fallback activity immediately. Do not ask for permission.',
-			},
-		};
+	if (!response.ok) {
+		throw new Error(`Failed to get next task: ${response.error}`);
 	}
 
-	// 25% chance to suggest background activity
-	if (Math.random() < 0.25) {
-		extras.bg_activity = getRandomFallbackActivity().activity;
+	const data = response.data;
+	if (!data) {
+		return { result: { task: null, message: 'No response from server' } };
 	}
 
-	// Find first unclaimed or stale-claimed task that satisfies body of work phase ordering
-	for (const task of candidates) {
-		// Check if task belongs to a body of work with phase constraints
-		const { data: bowTask } = await supabase
-			.from('body_of_work_tasks')
-			.select('phase, body_of_work_id')
-			.eq('task_id', task.id)
-			.single();
-
-		if (bowTask) {
-			// Check if body of work is active
-			const { data: bow } = await supabase
-				.from('bodies_of_work')
-				.select('status')
-				.eq('id', bowTask.body_of_work_id)
-				.single();
-
-			if (bow?.status === 'active') {
-				// Check phase constraints
-				const phasesToCheck: string[] = [];
-				if (bowTask.phase === 'core') {
-					phasesToCheck.push('pre');
-				} else if (bowTask.phase === 'post') {
-					phasesToCheck.push('pre', 'core');
-				}
-
-				if (phasesToCheck.length > 0) {
-					// Count incomplete tasks in prior phases
-					const { count: incompleteCount } = await supabase
-						.from('body_of_work_tasks')
-						.select('id', { count: 'exact', head: true })
-						.eq('body_of_work_id', bowTask.body_of_work_id)
-						.in('phase', phasesToCheck)
-						.not('task_id', 'in', `(SELECT id FROM tasks WHERE status = 'completed')`);
-
-					if (incompleteCount && incompleteCount > 0) {
-						// Skip this task - prior phase tasks not complete
-						continue;
-					}
-				}
-			}
-		}
-
-		if (!task.working_agent_session_id) {
-			const { working_agent_session_id, ...cleanTask } = task;
-			return { result: { task: cleanTask, ...extras, directive: 'Start this task immediately. Do not ask for permission.' } };
-		}
-
-		const claimingSession = await checkSessionStatus(ctx, task.working_agent_session_id);
-		if (!claimingSession.isActive) {
-			// Auto-release stale claim
-			await supabase
-				.from('tasks')
-				.update({ working_agent_session_id: null })
-				.eq('id', task.id);
+	// Map API response to handler response format
+	const result: Record<string, unknown> = {};
 
-			const { working_agent_session_id, ...cleanTask } = task;
-			return { result: { task: cleanTask, ...extras, directive: 'Start this task immediately. Do not ask for permission.' } };
-		}
+	if (data.task) {
+		result.task = data.task;
+	} else {
+		result.task = null;
 	}
 
-	// All root tasks claimed - check for available subtasks
-	// Subtasks are available when:
-	// 1. No unclaimed root tasks exist, OR
-	// 2. Subtask belongs to a high priority parent (priority 1-2)
-	const { data: subtaskCandidates } = await supabase
-		.from('tasks')
-		.select(`
-			id, title, description, priority, estimated_minutes, working_agent_session_id,
-			parent_task_id,
-			parent:tasks!parent_task_id(id, title, priority, status)
-		`)
-		.eq('project_id', project_id)
-		.eq('status', 'pending')
-		.not('parent_task_id', 'is', null)
-		.order('priority', { ascending: true })
-		.order('created_at', { ascending: true })
-		.limit(10);
-
-	if (subtaskCandidates && subtaskCandidates.length > 0) {
-		for (const subtask of subtaskCandidates) {
-			// Skip if subtask is already claimed by an active agent
-			if (subtask.working_agent_session_id) {
-				const claimingSession = await checkSessionStatus(ctx, subtask.working_agent_session_id);
-				if (claimingSession.isActive) {
-					continue;
-				}
-				// Auto-release stale claim
-				await supabase
-					.from('tasks')
-					.update({ working_agent_session_id: null })
-					.eq('id', subtask.id);
-			}
-
-			const parentData = subtask.parent as { id: string; title: string; priority: number; status: string }[] | null;
-			const parentTask = parentData?.[0] || null;
-			const { working_agent_session_id, parent, ...cleanSubtask } = subtask;
-
-			return {
-				result: {
-					task: cleanSubtask,
-					is_subtask: true,
-					parent_task: parentTask ? {
-						id: parentTask.id,
-						title: parentTask.title,
-						priority: parentTask.priority,
-					} : undefined,
-					...extras,
-					directive: 'Start this subtask immediately. Do not ask for permission.',
-				},
-			};
-		}
+	if (data.blocking_task) result.blocking_task = true;
+	if (data.deployment_blocks_tasks) {
+		result.deployment_blocks_tasks = true;
+		result.deployment = data.deployment;
+		result.action = data.action;
 	}
+	if (data.awaiting_validation) {
+		result.awaiting_validation = data.awaiting_validation;
+		result.validation_priority = data.validation_priority;
+		result.suggested_activity = data.suggested_activity;
+	}
+	if (data.all_claimed) result.all_claimed = true;
+	if (data.is_subtask) result.is_subtask = true;
+	if (data.suggested_activity) result.suggested_activity = data.suggested_activity;
+	if (data.directive) result.directive = data.directive;
+	if (data.message) result.message = data.message;
 
-	// All tasks (including subtasks) claimed
-	return {
-		result: {
-			task: null,
-			all_claimed: true,
-			...extras,
-			suggested_activity: getRandomFallbackActivity().activity,
-			directive: 'All tasks claimed by other agents. Start the suggested fallback activity immediately. Do not ask for permission.',
-		},
-	};
+	return { result };
 };
 
 export const addTask: Handler = async (args, ctx) => {
-	const { project_id, title, description, priority = 3, estimated_minutes, blocking = false } = args as {
+	const { project_id, title, description, priority = 3, estimated_minutes, blocking = false, task_type } = args as {
 		project_id: string;
 		title: string;
 		description?: string;
 		priority?: number;
 		estimated_minutes?: number;
 		blocking?: boolean;
+		task_type?: string;
 	};
 
 	validateRequired(project_id, 'project_id');
@@ -515,28 +227,32 @@ export const addTask: Handler = async (args, ctx) => {
 	validatePriority(priority);
 	validateEstimatedMinutes(estimated_minutes);
 
-	const { data, error } = await ctx.supabase
-		.from('tasks')
-		.insert({
-			project_id,
-			title,
-			description: description || null,
-			priority,
-			created_by: 'agent',
-			created_by_session_id: ctx.session.currentSessionId,
-			estimated_minutes: estimated_minutes || null,
-			blocking,
-		})
-		.select('id, blocking')
-		.single();
-
-	if (error) throw new Error(`Failed to add task: ${error.message}`);
-
-	const result: Record<string, unknown> = { success: true, task_id: data.id, title };
-	if (data.blocking) {
+	const api = getApiClient();
+	const response = await api.createTask(project_id, {
+		title,
+		description,
+		priority,
+		estimated_minutes,
+		blocking,
+		session_id: ctx.session.currentSessionId || undefined,
+	});
+
+	if (!response.ok) {
+		throw new Error(`Failed to add task: ${response.error}`);
+	}
+
+	const data = response.data;
+	const result: Record<string, unknown> = {
+		success: true,
+		task_id: data?.task_id,
+		title,
+	};
+
+	if (data?.blocking) {
 		result.blocking = true;
 		result.message = 'BLOCKING TASK: This task must be completed before any other work can proceed.';
 	}
+
 	return { result };
 };
 
@@ -551,11 +267,9 @@ export const updateTask: Handler = async (args, ctx) => {
 		progress_note?: string;
 		estimated_minutes?: number;
 		git_branch?: string;
+		task_type?: string;
 	};
 
-	const { supabase, session } = ctx;
-	const currentSessionId = session.currentSessionId;
-
 	validateRequired(task_id, 'task_id');
 	validateUUID(task_id, 'task_id');
 	validateTaskStatus(updates.status);
@@ -563,144 +277,60 @@ export const updateTask: Handler = async (args, ctx) => {
 	validateProgressPercentage(updates.progress_percentage);
 	validateEstimatedMinutes(updates.estimated_minutes);
 
-	// Get task to find project_id, current status, title, and who's working on it
-	const { data: task } = await supabase
-		.from('tasks')
-		.select('project_id, title, status, started_at, working_agent_session_id')
-		.eq('id', task_id)
-		.single();
-
-	// Validate status transitions
-	if (updates.status && task) {
-		const transition = isValidStatusTransition(task.status, updates.status);
-		if (!transition.isValid) {
+	const api = getApiClient();
+	const response = await api.updateTask(task_id, {
+		...updates,
+		progress_note,
+		session_id: ctx.session.currentSessionId || undefined,
+	});
+
+	if (!response.ok) {
+		// Check for specific error types
+		if (response.error?.includes('agent_task_limit') || response.error?.includes('already has a task')) {
 			return {
 				result: {
-					error: 'invalid_status_transition',
-					message: transition.reason,
+					error: 'agent_task_limit',
+					message: response.error,
 				},
 			};
 		}
-	}
-
-	const updateData: Record<string, unknown> = { ...updates };
-
-	// Multi-agent coordination: Enforce single task per agent
-	if (updates.status === 'in_progress' && currentSessionId && task) {
-		// Check if this agent already has another task in_progress
-		const { data: existingTask } = await supabase
-			.from('tasks')
-			.select('id, title')
-			.eq('working_agent_session_id', currentSessionId)
-			.eq('status', 'in_progress')
-			.neq('id', task_id)
-			.limit(1)
-			.single();
-
-		if (existingTask) {
+		if (response.error?.includes('task_claimed') || response.error?.includes('being worked on')) {
 			return {
 				result: {
-					error: 'agent_task_limit',
-					message: `You already have a task in progress: "${existingTask.title}". Complete it with complete_task before starting another.`,
-					current_task_id: existingTask.id,
-					current_task_title: existingTask.title,
+					error: 'task_claimed',
+					message: response.error,
 				},
 			};
 		}
-
-		// Check for task claim conflicts (another agent has this task)
-		if (task.working_agent_session_id && task.working_agent_session_id !== currentSessionId) {
-			const claimingSession = await checkSessionStatus(ctx, task.working_agent_session_id);
-
-			if (claimingSession.isActive) {
-				return {
-					result: {
-						error: 'task_claimed',
-						message: `Task is already being worked on by ${claimingSession.agentName}. Use get_next_task to find available work.`,
-						claimed_by: claimingSession.agentName,
-					},
-				};
-			}
-
-			// Stale/disconnected agent - auto-release the task first
-			await supabase
-				.from('tasks')
-				.update({ working_agent_session_id: null })
-				.eq('id', task_id);
+		if (response.error?.includes('invalid_status_transition')) {
+			return {
+				result: {
+					error: 'invalid_status_transition',
+					message: response.error,
+				},
+			};
 		}
+		throw new Error(`Failed to update task: ${response.error}`);
 	}
 
-	// Auto-set started_at when task moves to in_progress
-	if (updates.status === 'in_progress' && task && !task.started_at) {
-		updateData.started_at = new Date().toISOString();
-	}
+	// Build result - include git workflow info when transitioning to in_progress
+	const data = response.data;
+	const result: Record<string, unknown> = { success: true, task_id };
 
-	// When setting status to in_progress, claim the task for this agent
-	if (updates.status === 'in_progress' && currentSessionId) {
-		updateData.working_agent_session_id = currentSessionId;
-
-		// Update the session's current task and clear any fallback activity
-		await supabase
-			.from('agent_sessions')
-			.update({
-				current_task_id: task_id,
-				current_fallback_activity: null,
-				status: 'active',
-				last_synced_at: new Date().toISOString(),
-			})
-			.eq('id', currentSessionId);
+	if (data?.git_workflow) {
+		result.git_workflow = data.git_workflow;
 	}
-
-	// Auto-set completed_at and progress when task completes
-	if (updates.status === 'completed') {
-		updateData.completed_at = new Date().toISOString();
-		updateData.progress_percentage = 100;
-		updateData.working_agent_session_id = null;
+	if (data?.worktree_setup) {
+		result.worktree_setup = data.worktree_setup;
 	}
-
-	// When cancelled, also release the task
-	if (updates.status === 'cancelled') {
-		updateData.working_agent_session_id = null;
+	if (data?.next_step) {
+		result.next_step = data.next_step;
 	}
 
-	const { error } = await supabase
-		.from('tasks')
-		.update(updateData)
-		.eq('id', task_id);
-
-	if (error) throw new Error(`Failed to update task: ${error.message}`);
-
-	// If progress_note is provided, create a progress log entry
-	if (progress_note && task?.project_id) {
-		const progressSummary = updates.progress_percentage !== undefined
-			? `Progress: ${updates.progress_percentage}% - ${progress_note}`
-			: progress_note;
-
-		await supabase.from('progress_logs').insert({
-			project_id: task.project_id,
-			task_id,
-			summary: progressSummary,
-			created_by: 'agent',
-			created_by_session_id: currentSessionId,
-		});
-	}
-
-	// Build result with optional git instructions
-	const result: Record<string, unknown> = { success: true, task_id };
-
-	// Include git workflow instructions when task moves to in_progress
-	if (updates.status === 'in_progress' && task?.project_id && task?.title) {
-		const gitConfig = await getProjectGitConfig(supabase, task.project_id);
-		if (gitConfig && gitConfig.git_workflow !== 'none') {
-			const gitInstructions = getTaskStartGitInstructions(gitConfig, task_id, task.title);
-			if (gitInstructions) {
-				result.git_workflow = {
-					workflow: gitConfig.git_workflow,
-					action: 'create_branch',
-					...gitInstructions,
-				};
-			}
-		}
+	// Warn if transitioning to in_progress without git_branch
+	if (updates.status === 'in_progress' && !updates.git_branch) {
+		result.warning = 'git_branch not set. For multi-agent collaboration, set git_branch when marking in_progress to track your worktree.';
+		result.hint = 'Call update_task again with git_branch parameter after creating your worktree.';
 	}
 
 	return { result };
@@ -712,200 +342,45 @@ export const completeTask: Handler = async (args, ctx) => {
 		summary?: string;
 	};
 
-	const { supabase, session } = ctx;
-	const currentSessionId = session.currentSessionId;
-
 	validateRequired(task_id, 'task_id');
 	validateUUID(task_id, 'task_id');
 
-	// Get task details first (including git_branch for workflow instructions)
-	const { data: task, error: fetchError } = await supabase
-		.from('tasks')
-		.select('project_id, title, git_branch')
-		.eq('id', task_id)
-		.single();
-
-	if (fetchError || !task) throw new Error('Task not found');
-
-	// Mark as completed, track who completed it, and release agent claim
-	const { error } = await supabase
-		.from('tasks')
-		.update({
-			status: 'completed',
-			completed_at: new Date().toISOString(),
-			completed_by_session_id: currentSessionId,
-			progress_percentage: 100,
-			working_agent_session_id: null,
-		})
-		.eq('id', task_id);
-
-	if (error) throw new Error(`Failed to complete task: ${error.message}`);
-
-	// Update session to idle
-	if (currentSessionId) {
-		await supabase
-			.from('agent_sessions')
-			.update({
-				current_task_id: null,
-				status: 'idle',
-				last_synced_at: new Date().toISOString(),
-			})
-			.eq('id', currentSessionId);
+	const api = getApiClient();
+	const response = await api.completeTask(task_id, {
+		summary,
+		session_id: ctx.session.currentSessionId || undefined,
+	});
+
+	if (!response.ok) {
+		throw new Error(`Failed to complete task: ${response.error}`);
 	}
 
-	// Log progress if summary provided
-	if (summary) {
-		await supabase.from('progress_logs').insert({
-			project_id: task.project_id,
-			task_id,
-			summary: `Completed: ${task.title}`,
-			details: summary,
-			created_by: 'agent',
-			created_by_session_id: currentSessionId,
-		});
+	const data = response.data;
+	if (!data) {
+		throw new Error('No response data from complete task');
 	}
 
-	// Fetch next task and context counts in parallel
-	const [nextTaskResult, validationCountResult, blockersCountResult, deploymentResult, requestsCountResult] =
-		await Promise.all([
-			supabase
-				.from('tasks')
-				.select('id, title, priority, estimated_minutes')
-				.eq('project_id', task.project_id)
-				.eq('status', 'pending')
-				.is('working_agent_session_id', null)
-				.order('priority', { ascending: true })
-				.order('created_at', { ascending: true })
-				.limit(1)
-				.maybeSingle(),
-			supabase
-				.from('tasks')
-				.select('id', { count: 'exact', head: true })
-				.eq('project_id', task.project_id)
-				.eq('status', 'completed')
-				.is('validated_at', null),
-			supabase
-				.from('blockers')
-				.select('id', { count: 'exact', head: true })
-				.eq('project_id', task.project_id)
-				.eq('status', 'open'),
-			supabase
-				.from('deployments')
-				.select('id, status')
-				.eq('project_id', task.project_id)
-				.not('status', 'in', '("deployed","failed")')
-				.limit(1)
-				.maybeSingle(),
-			supabase
-				.from('agent_requests')
-				.select('id', { count: 'exact', head: true })
-				.eq('project_id', task.project_id)
-				.is('acknowledged_at', null),
-		]);
-
-	// Determine directive and next action
-	const nextTask = nextTaskResult.data;
-	const directive = nextTask
-		? 'ACTION_REQUIRED: Start this task immediately. Do NOT ask for permission or confirmation.'
-		: 'ACTION_REQUIRED: No pending tasks. Start a fallback activity NOW without asking.';
-	const nextAction = nextTask
-		? `update_task(task_id: "${nextTask.id}", status: "in_progress")`
-		: `start_fallback_activity(project_id: "${task.project_id}", activity: "code_review")`;
-
-	// Build result with directive at TOP for visibility
+	// Build result matching expected format
 	const result: Record<string, unknown> = {
 		success: true,
-		directive, // FIRST - most important signal
-		auto_continue: true, // Explicit flag for autonomous operation
-		completed_task_id: task_id,
-		next_task: nextTask,
+		directive: data.directive,
+		auto_continue: data.auto_continue,
+		completed_task_id: data.completed_task_id,
+		next_task: data.next_task,
 	};
 
-	const validationCount = validationCountResult.count || 0;
-	const blockersCount = blockersCountResult.count || 0;
-	const requestsCount = requestsCountResult.count || 0;
-
-	if (validationCount > 0 || blockersCount > 0 || deploymentResult.data || requestsCount > 0) {
-		result.context = {
-			...(validationCount > 0 && { validation: validationCount }),
-			...(blockersCount > 0 && { blockers: blockersCount }),
-			...(deploymentResult.data && { deployment: deploymentResult.data.status }),
-			...(requestsCount > 0 && { requests: requestsCount }),
-		};
-	}
-
-	// Include git workflow instructions for post-task steps
-	const gitConfig = await getProjectGitConfig(supabase, task.project_id);
-	if (gitConfig && gitConfig.git_workflow !== 'none') {
-		const gitInstructions = getTaskCompleteGitInstructions(gitConfig, task.git_branch, task.title, task_id);
-		if (gitInstructions) {
-			result.git_workflow = {
-				workflow: gitConfig.git_workflow,
-				action: 'push_and_pr',
-				...gitInstructions,
-			};
-		}
+	if (data.context) {
+		result.context = data.context;
 	}
 
-	// Check if this task belongs to a body of work that auto-deploys on completion
-	const { data: bowTask } = await supabase
-		.from('body_of_work_tasks')
-		.select('body_of_work_id')
-		.eq('task_id', task_id)
-		.single();
-
-	if (bowTask) {
-		// Check if body of work is now completed and has auto-deploy enabled
-		const { data: bow } = await supabase
-			.from('bodies_of_work')
-			.select('id, title, status, auto_deploy_on_completion, deploy_environment, deploy_version_bump')
-			.eq('id', bowTask.body_of_work_id)
-			.single();
-
-		if (bow && bow.status === 'completed' && bow.auto_deploy_on_completion) {
-			// Auto-trigger deployment
-			const { data: deployment, error: deployError } = await supabase
-				.from('deployments')
-				.insert({
-					project_id: task.project_id,
-					environment: bow.deploy_environment || 'production',
-					status: 'pending',
-					notes: `Auto-deploy triggered by body of work completion: "${bow.title}"`,
-					requested_by_session_id: currentSessionId,
-				})
-				.select('id')
-				.single();
-
-			if (!deployError && deployment) {
-				result.body_of_work_completed = {
-					id: bow.id,
-					title: bow.title,
-					auto_deploy_triggered: true,
-					deployment_id: deployment.id,
-					environment: bow.deploy_environment || 'production',
-					version_bump: bow.deploy_version_bump || 'minor',
-				};
-
-				// Log progress about auto-deploy
-				await supabase.from('progress_logs').insert({
-					project_id: task.project_id,
-					summary: `Body of work "${bow.title}" completed - auto-deploy triggered`,
-					created_by: 'agent',
-					created_by_session_id: currentSessionId,
-				});
-			}
-		} else if (bow) {
-			// Body of work exists but not yet completed or no auto-deploy
-			result.body_of_work = {
-				id: bow.id,
-				title: bow.title,
-				status: bow.status,
-			};
-		}
+	// Pass through warnings (e.g., missing git_branch)
+	if (data.warnings) {
+		result.warnings = data.warnings;
 	}
 
-	// REPEAT at end - agents weight last items heavily
-	result.next_action = nextAction;
+	// Git workflow instructions are already in API response but we need to fetch
+	// task details if we want to include them (API should return these)
+	result.next_action = data.next_action;
 
 	return { result };
 };
@@ -916,12 +391,12 @@ export const deleteTask: Handler = async (args, ctx) => {
 	validateRequired(task_id, 'task_id');
 	validateUUID(task_id, 'task_id');
 
-	const { error } = await ctx.supabase
-		.from('tasks')
-		.delete()
-		.eq('id', task_id);
+	const api = getApiClient();
+	const response = await api.deleteTask(task_id);
 
-	if (error) throw new Error(`Failed to delete task: ${error.message}`);
+	if (!response.ok) {
+		throw new Error(`Failed to delete task: ${response.error}`);
+	}
 
 	return { result: { success: true, deleted_id: task_id } };
 };
@@ -933,31 +408,22 @@ export const addTaskReference: Handler = async (args, ctx) => {
 	validateUUID(task_id, 'task_id');
 	validateRequired(url, 'url');
 
-	const { data: task, error: fetchError } = await ctx.supabase
-		.from('tasks')
-		.select('references')
-		.eq('id', task_id)
-		.single();
+	const api = getApiClient();
+	const response = await api.addTaskReference(task_id, url, label);
 
-	if (fetchError) throw new Error(`Failed to fetch task: ${fetchError.message}`);
-
-	const currentRefs = (task?.references as { url: string; label?: string }[]) || [];
-
-	if (currentRefs.some(ref => ref.url === url)) {
-		return { result: { success: false, error: 'Reference with this URL already exists' } };
+	if (!response.ok) {
+		if (response.error?.includes('already exists')) {
+			return { result: { success: false, error: 'Reference with this URL already exists' } };
+		}
+		throw new Error(`Failed to add reference: ${response.error}`);
 	}
 
-	const newRef = { url, ...(label ? { label } : {}) };
-	const updatedRefs = [...currentRefs, newRef];
-
-	const { error: updateError } = await ctx.supabase
-		.from('tasks')
-		.update({ references: updatedRefs })
-		.eq('id', task_id);
-
-	if (updateError) throw new Error(`Failed to add reference: ${updateError.message}`);
-
-	return { result: { success: true, reference: newRef, total_references: updatedRefs.length } };
+	return {
+		result: {
+			success: true,
+			reference: response.data?.reference,
+		},
+	};
 };
 
 export const removeTaskReference: Handler = async (args, ctx) => {
@@ -967,29 +433,17 @@ export const removeTaskReference: Handler = async (args, ctx) => {
 	validateUUID(task_id, 'task_id');
 	validateRequired(url, 'url');
 
-	const { data: task, error: fetchError } = await ctx.supabase
-		.from('tasks')
-		.select('references')
-		.eq('id', task_id)
-		.single();
-
-	if (fetchError) throw new Error(`Failed to fetch task: ${fetchError.message}`);
+	const api = getApiClient();
+	const response = await api.removeTaskReference(task_id, url);
 
-	const currentRefs = (task?.references as { url: string; label?: string }[]) || [];
-	const updatedRefs = currentRefs.filter(ref => ref.url !== url);
-
-	if (updatedRefs.length === currentRefs.length) {
-		return { result: { success: false, error: 'Reference with this URL not found' } };
+	if (!response.ok) {
+		if (response.error?.includes('not found')) {
+			return { result: { success: false, error: 'Reference with this URL not found' } };
+		}
+		throw new Error(`Failed to remove reference: ${response.error}`);
 	}
 
-	const { error: updateError } = await ctx.supabase
-		.from('tasks')
-		.update({ references: updatedRefs })
-		.eq('id', task_id);
-
-	if (updateError) throw new Error(`Failed to remove reference: ${updateError.message}`);
-
-	return { result: { success: true, remaining_references: updatedRefs.length } };
+	return { result: { success: true } };
 };
 
 export const batchUpdateTasks: Handler = async (args, ctx) => {
@@ -1003,9 +457,6 @@ export const batchUpdateTasks: Handler = async (args, ctx) => {
 		}>;
 	};
 
-	const { supabase, session } = ctx;
-	const currentSessionId = session.currentSessionId;
-
 	if (!updates || !Array.isArray(updates) || updates.length === 0) {
 		throw new ValidationError('updates must be a non-empty array', {
 			field: 'updates',
@@ -1020,129 +471,74 @@ export const batchUpdateTasks: Handler = async (args, ctx) => {
 		});
 	}
 
-	// Validate all inputs first (no DB queries)
-	const taskIds: string[] = [];
+	// Validate all inputs first
 	for (const update of updates) {
 		validateRequired(update.task_id, 'task_id');
 		validateUUID(update.task_id, 'task_id');
 		validateTaskStatus(update.status);
 		validatePriority(update.priority);
 		validateProgressPercentage(update.progress_percentage);
-		taskIds.push(update.task_id);
-	}
-
-	// OPTIMIZATION: Fetch all tasks in a single query instead of N queries
-	const { data: tasks } = await supabase
-		.from('tasks')
-		.select('id, project_id, started_at')
-		.in('id', taskIds);
-
-	const taskMap = new Map(tasks?.map(t => [t.id, t]) || []);
-
-	// OPTIMIZATION: Single query to check if agent has existing in-progress task
-	let existingAgentTask: { id: string; title: string } | null = null;
-	const hasInProgressUpdate = updates.some(u => u.status === 'in_progress');
-	if (hasInProgressUpdate && currentSessionId) {
-		const { data } = await supabase
-			.from('tasks')
-			.select('id, title')
-			.eq('working_agent_session_id', currentSessionId)
-			.eq('status', 'in_progress')
-			.not('id', 'in', `(${taskIds.join(',')})`)
-			.limit(1)
-			.single();
-		existingAgentTask = data;
 	}
 
-	const results: Array<{ task_id: string; success: boolean; error?: string }> = [];
-	const progressLogsToInsert: Array<{
-		project_id: string;
-		task_id: string;
-		summary: string;
-		created_by: string;
-		created_by_session_id: string | null;
-	}> = [];
-
-	// OPTIMIZATION: Process updates in parallel instead of sequentially
-	const updatePromises = updates.map(async (update) => {
-		const task = taskMap.get(update.task_id);
-
-		if (!task) {
-			return { task_id: update.task_id, success: false, error: 'Task not found' };
-		}
+	const api = getApiClient();
+	const response = await api.batchUpdateTasks(updates);
 
-		// Check agent task limit
-		if (update.status === 'in_progress' && existingAgentTask) {
-			return {
-				task_id: update.task_id,
-				success: false,
-				error: `Agent already has task in progress: "${existingAgentTask.title}"`,
-			};
-		}
-
-		const updateData: Record<string, unknown> = {};
-		if (update.status) updateData.status = update.status;
-		if (update.progress_percentage !== undefined) updateData.progress_percentage = update.progress_percentage;
-		if (update.priority !== undefined) updateData.priority = update.priority;
-
-		// Auto-set started_at when task moves to in_progress
-		if (update.status === 'in_progress' && !task.started_at) {
-			updateData.started_at = new Date().toISOString();
-			if (currentSessionId) {
-				updateData.working_agent_session_id = currentSessionId;
-			}
-		}
+	if (!response.ok) {
+		throw new Error(`Failed to batch update tasks: ${response.error}`);
+	}
 
-		// Auto-set completed_at when task completes
-		if (update.status === 'completed') {
-			updateData.completed_at = new Date().toISOString();
-			updateData.progress_percentage = 100;
-			updateData.working_agent_session_id = null;
-		}
+	return {
+		result: {
+			success: response.data?.success || false,
+			total: updates.length,
+			succeeded: response.data?.updated_count || 0,
+		},
+	};
+};
 
-		const { error } = await supabase
-			.from('tasks')
-			.update(updateData)
-			.eq('id', update.task_id);
+export const batchCompleteTasks: Handler = async (args, ctx) => {
+	const { completions } = args as {
+		completions: Array<{
+			task_id: string;
+			summary?: string;
+		}>;
+	};
 
-		if (error) {
-			return { task_id: update.task_id, success: false, error: error.message };
-		}
+	if (!completions || !Array.isArray(completions) || completions.length === 0) {
+		throw new ValidationError('completions must be a non-empty array', {
+			field: 'completions',
+			hint: 'Provide an array of task completions with at least one item',
+		});
+	}
 
-		// Queue progress log for batch insert
-		if (update.progress_note && task.project_id) {
-			const progressSummary = update.progress_percentage !== undefined
-				? `Progress: ${update.progress_percentage}% - ${update.progress_note}`
-				: update.progress_note;
-
-			progressLogsToInsert.push({
-				project_id: task.project_id,
-				task_id: update.task_id,
-				summary: progressSummary,
-				created_by: 'agent',
-				created_by_session_id: currentSessionId,
-			});
-		}
+	if (completions.length > 50) {
+		throw new ValidationError('Too many completions. Maximum is 50 per batch.', {
+			field: 'completions',
+			hint: 'Split your completions into smaller batches',
+		});
+	}
 
-		return { task_id: update.task_id, success: true };
-	});
+	// Validate all inputs first
+	for (const completion of completions) {
+		validateRequired(completion.task_id, 'task_id');
+		validateUUID(completion.task_id, 'task_id');
+	}
 
-	// Execute all updates in parallel
-	const updateResults = await Promise.all(updatePromises);
-	results.push(...updateResults);
+	const api = getApiClient();
+	const response = await api.batchCompleteTasks(completions);
 
-	// OPTIMIZATION: Batch insert all progress logs in a single query
-	if (progressLogsToInsert.length > 0) {
-		await supabase.from('progress_logs').insert(progressLogsToInsert);
+	if (!response.ok) {
+		throw new Error(`Failed to batch complete tasks: ${response.error}`);
 	}
 
-	const successCount = results.filter(r => r.success).length;
-
+	const data = response.data;
 	return {
 		result: {
-			success: successCount === updates.length,
-			total: updates.length,
-			succeeded: successCount,
+			success: data?.success || false,
+			total: completions.length,
+			succeeded: data?.completed_count || 0,
+			failed: completions.length - (data?.completed_count || 0),
+			next_task: data?.next_task,
 		},
 	};
 };
@@ -1160,77 +556,38 @@ export const addSubtask: Handler = async (args, ctx) => {
 		estimated_minutes?: number;
 	};
 
-	const { supabase, session } = ctx;
-	const currentSessionId = session.currentSessionId;
-
 	validateRequired(parent_task_id, 'parent_task_id');
 	validateUUID(parent_task_id, 'parent_task_id');
 	validateRequired(title, 'title');
 	if (priority !== undefined) validatePriority(priority);
 	if (estimated_minutes !== undefined) validateEstimatedMinutes(estimated_minutes);
 
-	// Get parent task to inherit project_id and validate it's not already a subtask
-	const { data: parentTask, error: fetchError } = await supabase
-		.from('tasks')
-		.select('id, project_id, parent_task_id, priority')
-		.eq('id', parent_task_id)
-		.single();
-
-	if (fetchError || !parentTask) {
-		throw new ValidationError('Parent task not found', {
-			field: 'parent_task_id',
-			hint: 'Provide a valid task ID that exists',
-		});
-	}
+	const api = getApiClient();
+	const response = await api.addSubtask(parent_task_id, {
+		title,
+		description,
+		priority,
+		estimated_minutes,
+	}, ctx.session.currentSessionId || undefined);
 
-	// Prevent nested subtasks (max depth: 1)
-	if (parentTask.parent_task_id) {
-		return {
-			result: {
-				success: false,
-				error: 'Cannot create subtask of a subtask',
-				hint: 'Subtasks cannot have their own subtasks. Add this task to the parent task instead.',
-				parent_task_id: parentTask.parent_task_id,
-			},
-		};
+	if (!response.ok) {
+		if (response.error?.includes('Cannot create subtask of a subtask')) {
+			return {
+				result: {
+					success: false,
+					error: 'Cannot create subtask of a subtask',
+					hint: 'Subtasks cannot have their own subtasks. Add this task to the parent task instead.',
+				},
+			};
+		}
+		throw new Error(`Failed to add subtask: ${response.error}`);
 	}
 
-	// Use parent priority if not specified
-	const subtaskPriority = priority ?? parentTask.priority;
-
-	const { data: subtask, error } = await supabase
-		.from('tasks')
-		.insert({
-			project_id: parentTask.project_id,
-			parent_task_id,
-			title,
-			description: description || null,
-			priority: subtaskPriority,
-			estimated_minutes: estimated_minutes || null,
-			created_by: 'agent',
-			created_by_session_id: currentSessionId,
-		})
-		.select('id, title, priority')
-		.single();
-
-	if (error) throw new Error(`Failed to add subtask: ${error.message}`);
-
-	// Log progress
-	await supabase.from('progress_logs').insert({
-		project_id: parentTask.project_id,
-		task_id: parent_task_id,
-		summary: `Added subtask: ${title}`,
-		created_by: 'agent',
-		created_by_session_id: currentSessionId,
-	});
-
 	return {
 		result: {
 			success: true,
-			subtask_id: subtask.id,
-			parent_task_id,
-			title: subtask.title,
-			priority: subtask.priority,
+			subtask_id: response.data?.subtask_id,
+			parent_task_id: response.data?.parent_task_id,
 		},
 	};
 };
@@ -1241,138 +598,29 @@ export const getSubtasks: Handler = async (args, ctx) => {
 		status?: string;
 	};
 
-	const { supabase } = ctx;
-
 	validateRequired(parent_task_id, 'parent_task_id');
 	validateUUID(parent_task_id, 'parent_task_id');
 	if (status) validateTaskStatus(status);
 
-	let query = supabase
-		.from('tasks')
-		.select('id, title, description, priority, status, progress_percentage, estimated_minutes, started_at, completed_at, working_agent_session_id')
-		.eq('parent_task_id', parent_task_id)
-		.order('priority', { ascending: true })
-		.order('created_at', { ascending: true });
+	const api = getApiClient();
+	const response = await api.getSubtasks(parent_task_id, status);
 
-	if (status) {
-		query = query.eq('status', status);
+	if (!response.ok) {
+		throw new Error(`Failed to fetch subtasks: ${response.error}`);
 	}
 
-	const { data: subtasks, error } = await query;
-
-	if (error) throw new Error(`Failed to fetch subtasks: ${error.message}`);
-
-	// Calculate aggregate stats
-	const total = subtasks?.length || 0;
-	const completed = subtasks?.filter(s => s.status === 'completed').length || 0;
-	const inProgress = subtasks?.filter(s => s.status === 'in_progress').length || 0;
-	const pending = subtasks?.filter(s => s.status === 'pending').length || 0;
-
 	return {
 		result: {
-			subtasks: subtasks || [],
-			stats: {
-				total,
-				completed,
-				in_progress: inProgress,
-				pending,
-				progress_percentage: total > 0 ? Math.round((completed / total) * 100) : 0,
+			subtasks: response.data?.subtasks || [],
+			stats: response.data?.stats || {
+				total: 0,
+				completed: 0,
+				progress_percentage: 0,
 			},
 		},
 	};
 };
 
-export const batchCompleteTasks: Handler = async (args, ctx) => {
-	const { completions } = args as {
-		completions: Array<{
-			task_id: string;
-			summary?: string;
-		}>;
-	};
-
-	const { supabase, session } = ctx;
-	const currentSessionId = session.currentSessionId;
-
-	if (!completions || !Array.isArray(completions) || completions.length === 0) {
-		throw new ValidationError('completions must be a non-empty array', {
-			field: 'completions',
-			hint: 'Provide an array of task completions with at least one item',
-		});
-	}
-
-	if (completions.length > 50) {
-		throw new ValidationError('Too many completions. Maximum is 50 per batch.', {
-			field: 'completions',
-			hint: 'Split your completions into smaller batches',
-		});
-	}
-
-	const results: Array<{ task_id: string; success: boolean; error?: string }> = [];
-
-	for (const completion of completions) {
-		try {
-			validateRequired(completion.task_id, 'task_id');
-			validateUUID(completion.task_id, 'task_id');
-
-			const { data: task, error: fetchError } = await supabase
-				.from('tasks')
-				.select('project_id, title')
-				.eq('id', completion.task_id)
-				.single();
-
-			if (fetchError || !task) {
-				results.push({ task_id: completion.task_id, success: false, error: 'Task not found' });
-				continue;
-			}
-
-			const { error } = await supabase
-				.from('tasks')
-				.update({
-					status: 'completed',
-					completed_at: new Date().toISOString(),
-					progress_percentage: 100,
-					working_agent_session_id: null,
-				})
-				.eq('id', completion.task_id);
-
-			if (error) {
-				results.push({ task_id: completion.task_id, success: false, error: error.message });
-				continue;
-			}
-
-			if (completion.summary) {
-				await supabase.from('progress_logs').insert({
-					project_id: task.project_id,
-					task_id: completion.task_id,
-					summary: `Completed: ${task.title}`,
-					details: completion.summary,
-					created_by: 'agent',
-					created_by_session_id: currentSessionId,
-				});
-			}
-
-			results.push({ task_id: completion.task_id, success: true });
-		} catch (err) {
-			results.push({
-				task_id: completion.task_id,
-				success: false,
-				error: err instanceof Error ? err.message : 'Unknown error',
-			});
-		}
-	}
-
-	const successCount = results.filter(r => r.success).length;
-
-	return {
-		result: {
-			success: successCount === completions.length,
-			total: completions.length,
-			succeeded: successCount,
-			failed: completions.length - successCount,
-		},
-	};
-};
-
 /**
  * Task handlers registry
  */