@vibescope/mcp-server 0.0.1 → 0.2.0

package/src/handlers/fallback.test.ts

@@ -1,6 +1,4 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { SupabaseClient } from '@supabase/supabase-js';
-import type { HandlerContext, TokenUsage } from './types.js';
 import {
 	startFallbackActivity,
 	stopFallbackActivity,
@@ -8,118 +6,8 @@ import {
 	getActivitySchedules,
 } from './fallback.js';
 import { ValidationError } from '../validators.js';
-
-// ============================================================================
-// Test Utilities
-// ============================================================================
-
-function createMockSupabase(overrides: {
-	selectResult?: { data: unknown; error: unknown };
-	insertResult?: { data: unknown; error: unknown };
-	updateResult?: { data: unknown; error: unknown };
-	deleteResult?: { data: unknown; error: unknown };
-} = {}) {
-	const defaultResult = { data: null, error: null };
-	let currentOperation = 'select';
-	let insertThenSelect = false;
-
-	const mock = {
-		from: vi.fn().mockReturnThis(),
-		select: vi.fn(() => {
-			if (currentOperation === 'insert') {
-				insertThenSelect = true;
-			} else {
-				currentOperation = 'select';
-				insertThenSelect = false;
-			}
-			return mock;
-		}),
-		insert: vi.fn(() => {
-			currentOperation = 'insert';
-			insertThenSelect = false;
-			return mock;
-		}),
-		update: vi.fn(() => {
-			currentOperation = 'update';
-			insertThenSelect = false;
-			return mock;
-		}),
-		delete: vi.fn(() => {
-			currentOperation = 'delete';
-			insertThenSelect = false;
-			return mock;
-		}),
-		eq: vi.fn().mockReturnThis(),
-		neq: vi.fn().mockReturnThis(),
-		in: vi.fn().mockReturnThis(),
-		is: vi.fn().mockReturnThis(),
-		not: vi.fn().mockReturnThis(),
-		or: vi.fn().mockReturnThis(),
-		gt: vi.fn().mockReturnThis(),
-		gte: vi.fn().mockReturnThis(),
-		lte: vi.fn().mockReturnThis(),
-		lt: vi.fn().mockReturnThis(),
-		order: vi.fn().mockReturnThis(),
-		limit: vi.fn().mockReturnThis(),
-		single: vi.fn(() => {
-			if (currentOperation === 'insert' || insertThenSelect) {
-				return Promise.resolve(overrides.insertResult ?? defaultResult);
-			}
-			if (currentOperation === 'select') {
-				return Promise.resolve(overrides.selectResult ?? defaultResult);
-			}
-			if (currentOperation === 'update') {
-				return Promise.resolve(overrides.updateResult ?? defaultResult);
-			}
-			return Promise.resolve(defaultResult);
-		}),
-		maybeSingle: vi.fn(() => {
-			return Promise.resolve(overrides.selectResult ?? defaultResult);
-		}),
-		then: vi.fn((resolve: (value: unknown) => void) => {
-			if (currentOperation === 'insert' || insertThenSelect) {
-				return Promise.resolve(overrides.insertResult ?? defaultResult).then(resolve);
-			}
-			if (currentOperation === 'select') {
-				return Promise.resolve(overrides.selectResult ?? defaultResult).then(resolve);
-			}
-			if (currentOperation === 'update') {
-				return Promise.resolve(overrides.updateResult ?? defaultResult).then(resolve);
-			}
-			if (currentOperation === 'delete') {
-				return Promise.resolve(overrides.deleteResult ?? defaultResult).then(resolve);
-			}
-			return Promise.resolve(defaultResult).then(resolve);
-		}),
-	};
-
-	return mock as unknown as SupabaseClient;
-}
-
-function createMockContext(
-	supabase: SupabaseClient,
-	options: { sessionId?: string | null } = {}
-): HandlerContext {
-	const defaultTokenUsage: TokenUsage = {
-		callCount: 5,
-		totalTokens: 2500,
-		byTool: {},
-	};
-
-	const sessionId = 'sessionId' in options ? options.sessionId : 'session-123';
-
-	return {
-		supabase,
-		auth: { userId: 'user-123', apiKeyId: 'api-key-123' },
-		session: {
-			instanceId: 'instance-abc',
-			currentSessionId: sessionId,
-			currentPersona: 'Wave',
-			tokenUsage: defaultTokenUsage,
-		},
-		updateSession: vi.fn(),
-	};
-}
+import { createMockContext } from './__test-utils__.js';
+import { mockApiClient } from './__test-setup__.js';
 
 // ============================================================================
 // startFallbackActivity Tests
@@ -129,8 +17,7 @@ describe('startFallbackActivity', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			startFallbackActivity({ activity: 'code_review' }, ctx)
@@ -138,8 +25,7 @@ describe('startFallbackActivity', () => {
 	});
 
 	it('should throw error for invalid project_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			startFallbackActivity({ project_id: 'invalid', activity: 'code_review' }, ctx)
@@ -147,8 +33,7 @@ describe('startFallbackActivity', () => {
 	});
 
 	it('should throw error for missing activity', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			startFallbackActivity({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
@@ -156,8 +41,7 @@ describe('startFallbackActivity', () => {
 	});
 
 	it('should throw error for invalid activity type', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			startFallbackActivity({
@@ -168,10 +52,11 @@ describe('startFallbackActivity', () => {
 	});
 
 	it('should start fallback activity successfully', async () => {
-		const supabase = createMockSupabase({
-			updateResult: { data: null, error: null },
+		mockApiClient.startFallbackActivity.mockResolvedValue({
+			ok: true,
+			data: { message: 'Started code_review' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await startFallbackActivity(
 			{
@@ -188,11 +73,12 @@ describe('startFallbackActivity', () => {
 		expect((result.result as { title: string }).title).toBeDefined();
 	});
 
-	it('should update agent_sessions with fallback activity', async () => {
-		const supabase = createMockSupabase({
-			updateResult: { data: null, error: null },
+	it('should call API client with correct parameters', async () => {
+		mockApiClient.startFallbackActivity.mockResolvedValue({
+			ok: true,
+			data: { message: 'Started' },
 		});
-		const ctx = createMockContext(supabase, { sessionId: 'my-session' });
+		const ctx = createMockContext({ sessionId: 'my-session' });
 
 		await startFallbackActivity(
 			{
@@ -202,15 +88,11 @@ describe('startFallbackActivity', () => {
 			ctx
 		);
 
-		expect(supabase.from).toHaveBeenCalledWith('agent_sessions');
-		expect(supabase.update).toHaveBeenCalledWith(
-			expect.objectContaining({
-				current_fallback_activity: 'security_review',
-				current_task_id: null,
-				status: 'active',
-			})
+		expect(mockApiClient.startFallbackActivity).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			'security_review',
+			'my-session'
 		);
-		expect(supabase.eq).toHaveBeenCalledWith('id', 'my-session');
 	});
 
 	it('should accept all valid activity types', async () => {
@@ -228,10 +110,11 @@ describe('startFallbackActivity', () => {
 		];
 
 		for (const activity of validActivities) {
-			const supabase = createMockSupabase({
-				updateResult: { data: null, error: null },
+			mockApiClient.startFallbackActivity.mockResolvedValue({
+				ok: true,
+				data: { message: `Started ${activity}` },
 			});
-			const ctx = createMockContext(supabase);
+			const ctx = createMockContext();
 
 			const result = await startFallbackActivity(
 				{
@@ -248,25 +131,97 @@ describe('startFallbackActivity', () => {
 		}
 	});
 
-	it('should throw error when update fails', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
-		// Override update to return error
-		vi.mocked(supabase.from('').update).mockReturnValue({
-			...supabase,
-			eq: vi.fn().mockReturnValue({
-				then: (resolve: (val: unknown) => void) =>
-					Promise.resolve({ data: null, error: { message: 'Update failed' } }).then(resolve),
-			}),
-		} as unknown as ReturnType<SupabaseClient['from']>);
+	it('should throw error when API call fails', async () => {
+		mockApiClient.startFallbackActivity.mockResolvedValue({
+			ok: false,
+			error: 'Failed to start activity',
+		});
+		const ctx = createMockContext();
 
 		await expect(
 			startFallbackActivity({
 				project_id: '123e4567-e89b-12d3-a456-426614174000',
 				activity: 'code_review',
 			}, ctx)
-		).rejects.toThrow();
+		).rejects.toThrow('Failed to start fallback activity');
+	});
+
+	it('should pass through worktree guidance when API returns it', async () => {
+		mockApiClient.startFallbackActivity.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				activity: 'code_review',
+				message: 'Started code_review',
+				git_workflow: {
+					workflow: 'git-flow',
+					base_branch: 'develop',
+					worktree_recommended: true,
+					note: 'Fallback activities use the base branch directly (read-only).',
+				},
+				worktree_setup: {
+					message: 'RECOMMENDED: Create a worktree to avoid conflicts.',
+					commands: [
+						'git checkout develop',
+						'git pull origin develop',
+						'git worktree add ../Project-code-review develop',
+						'cd ../Project-code-review',
+					],
+					worktree_path: '../Project-code-review',
+					branch_name: 'develop',
+					cleanup_command: 'git worktree remove ../Project-code-review',
+					report_worktree: 'heartbeat(current_worktree_path: "../Project-code-review")',
+				},
+				next_step: 'After setting up worktree: call heartbeat to report your location.',
+			},
+		});
+		const ctx = createMockContext();
+
+		const result = await startFallbackActivity(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				activity: 'code_review',
+			},
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			activity: 'code_review',
+		});
+		expect((result.result as { git_workflow?: unknown }).git_workflow).toBeDefined();
+		expect((result.result as { git_workflow: { workflow: string } }).git_workflow.workflow).toBe('git-flow');
+		expect((result.result as { worktree_setup?: unknown }).worktree_setup).toBeDefined();
+		expect((result.result as { worktree_setup: { worktree_path: string } }).worktree_setup.worktree_path).toBe('../Project-code-review');
+		expect((result.result as { next_step?: string }).next_step).toContain('heartbeat');
+	});
+
+	it('should not include worktree guidance when API does not return it', async () => {
+		mockApiClient.startFallbackActivity.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				activity: 'code_review',
+				message: 'Started code_review',
+			},
+		});
+		const ctx = createMockContext();
+
+		const result = await startFallbackActivity(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				activity: 'code_review',
+			},
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			activity: 'code_review',
+		});
+		expect((result.result as { git_workflow?: unknown }).git_workflow).toBeUndefined();
+		expect((result.result as { worktree_setup?: unknown }).worktree_setup).toBeUndefined();
+		expect((result.result as { next_step?: string }).next_step).toBeUndefined();
 	});
 });
 
@@ -278,46 +233,25 @@ describe('stopFallbackActivity', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(stopFallbackActivity({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid project_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			stopFallbackActivity({ project_id: 'invalid' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
-	it('should stop fallback activity successfully when activity exists', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: { current_fallback_activity: 'code_review' }, error: null },
-			insertResult: { data: null, error: null },
-			updateResult: { data: null, error: null },
+	it('should stop fallback activity successfully', async () => {
+		mockApiClient.stopFallbackActivity.mockResolvedValue({
+			ok: true,
+			data: { success: true },
 		});
-		const ctx = createMockContext(supabase);
-
-		const result = await stopFallbackActivity(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
-			ctx
-		);
-
-		expect(result.result).toMatchObject({
-			success: true,
-		});
-		expect((result.result as { message: string }).message).toContain('code_review');
-	});
-
-	it('should stop fallback activity when no activity was active', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: { current_fallback_activity: null }, error: null },
-			updateResult: { data: null, error: null },
-		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await stopFallbackActivity(
 			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
@@ -330,13 +264,12 @@ describe('stopFallbackActivity', () => {
 		});
 	});
 
-	it('should include summary in history when provided', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: { current_fallback_activity: 'code_review' }, error: null },
-			insertResult: { data: null, error: null },
-			updateResult: { data: null, error: null },
+	it('should call API client with summary when provided', async () => {
+		mockApiClient.stopFallbackActivity.mockResolvedValue({
+			ok: true,
+			data: { success: true },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext({ sessionId: 'my-session' });
 
 		await stopFallbackActivity(
 			{
@@ -346,32 +279,25 @@ describe('stopFallbackActivity', () => {
 			ctx
 		);
 
-		expect(supabase.from).toHaveBeenCalledWith('background_activity_history');
-		expect(supabase.insert).toHaveBeenCalledWith(
-			expect.objectContaining({
-				summary: 'Reviewed 5 files, found 3 issues',
-			})
+		expect(mockApiClient.stopFallbackActivity).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			'Reviewed 5 files, found 3 issues',
+			'my-session'
 		);
 	});
 
-	it('should clear session fallback activity', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: { current_fallback_activity: null }, error: null },
-			updateResult: { data: null, error: null },
+	it('should throw error when API call fails', async () => {
+		mockApiClient.stopFallbackActivity.mockResolvedValue({
+			ok: false,
+			error: 'Failed to stop activity',
 		});
-		const ctx = createMockContext(supabase, { sessionId: 'my-session' });
+		const ctx = createMockContext();
 
-		await stopFallbackActivity(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
-			ctx
-		);
-
-		expect(supabase.update).toHaveBeenCalledWith(
-			expect.objectContaining({
-				current_fallback_activity: null,
-				status: 'idle',
-			})
-		);
+		await expect(
+			stopFallbackActivity({
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+			}, ctx)
+		).rejects.toThrow('Failed to stop fallback activity');
 	});
 });
 
@@ -383,15 +309,13 @@ describe('getActivityHistory', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(getActivityHistory({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid project_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			getActivityHistory({ project_id: 'invalid' }, ctx)
@@ -399,10 +323,15 @@ describe('getActivityHistory', () => {
 	});
 
 	it('should return empty history when no activities', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: {
+				history: [],
+				latest_by_type: {},
+				count: 0,
+			},
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await getActivityHistory(
 			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
@@ -415,28 +344,31 @@ describe('getActivityHistory', () => {
 		});
 	});
 
-	it('should return activity history', async () => {
+	it('should return activity history from API', async () => {
 		const mockHistory = [
 			{
 				id: 'h1',
 				activity_type: 'code_review',
 				completed_at: '2025-01-14T10:00:00Z',
 				summary: 'Reviewed auth module',
-				agent_sessions: { agent_name: 'Wave' },
 			},
 			{
 				id: 'h2',
 				activity_type: 'security_review',
 				completed_at: '2025-01-14T09:00:00Z',
 				summary: null,
-				agent_sessions: { agent_name: 'Glitch' },
 			},
 		];
 
-		const supabase = createMockSupabase({
-			selectResult: { data: mockHistory, error: null },
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: {
+				history: mockHistory,
+				latest_by_type: { code_review: mockHistory[0] },
+				count: 2,
+			},
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await getActivityHistory(
 			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
@@ -447,83 +379,42 @@ describe('getActivityHistory', () => {
 		expect((result.result as { count: number }).count).toBe(2);
 	});
 
-	it('should include latest_by_type in response', async () => {
-		const mockHistory = [
-			{
-				id: 'h1',
-				activity_type: 'code_review',
-				completed_at: '2025-01-14T10:00:00Z',
-				agent_sessions: null,
-			},
-			{
-				id: 'h2',
-				activity_type: 'code_review',
-				completed_at: '2025-01-14T09:00:00Z',
-				agent_sessions: null,
-			},
-		];
-
-		const supabase = createMockSupabase({
-			selectResult: { data: mockHistory, error: null },
+	it('should call API proxy with correct parameters', async () => {
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { history: [], count: 0 },
 		});
-		const ctx = createMockContext(supabase);
-
-		const result = await getActivityHistory(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
-			ctx
-		);
-
-		const latestByType = (result.result as { latest_by_type: Record<string, unknown> }).latest_by_type;
-		expect(latestByType['code_review']).toBeDefined();
-		expect((latestByType['code_review'] as { id: string }).id).toBe('h1');
-	});
-
-	it('should filter by activity_type when provided', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
-		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await getActivityHistory(
 			{
 				project_id: '123e4567-e89b-12d3-a456-426614174000',
 				activity_type: 'security_review',
+				limit: 10,
 			},
 			ctx
 		);
 
-		expect(supabase.eq).toHaveBeenCalledWith('activity_type', 'security_review');
-	});
-
-	it('should respect limit parameter', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
-		});
-		const ctx = createMockContext(supabase);
-
-		await getActivityHistory(
+		expect(mockApiClient.proxy).toHaveBeenCalledWith(
+			'get_activity_history',
 			{
 				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				activity_type: 'security_review',
 				limit: 10,
-			},
-			ctx
+			}
 		);
-
-		expect(supabase.limit).toHaveBeenCalledWith(10);
 	});
 
-	it('should query background_activity_history table', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+	it('should throw error when API call fails', async () => {
+		mockApiClient.proxy.mockResolvedValue({
+			ok: false,
+			error: 'Query failed',
 		});
-		const ctx = createMockContext(supabase);
-
-		await getActivityHistory(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
-			ctx
-		);
+		const ctx = createMockContext();
 
-		expect(supabase.from).toHaveBeenCalledWith('background_activity_history');
+		await expect(
+			getActivityHistory({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow('Failed to get activity history');
 	});
 });
 
@@ -535,15 +426,13 @@ describe('getActivitySchedules', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(getActivitySchedules({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid project_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			getActivitySchedules({ project_id: 'invalid' }, ctx)
@@ -551,10 +440,15 @@ describe('getActivitySchedules', () => {
 	});
 
 	it('should return empty schedules when none exist', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: {
+				schedules: [],
+				due_activities: [],
+				count: 0,
+			},
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await getActivitySchedules(
 			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
@@ -568,7 +462,7 @@ describe('getActivitySchedules', () => {
 		});
 	});
 
-	it('should return activity schedules', async () => {
+	it('should return activity schedules from API', async () => {
 		const mockSchedules = [
 			{
 				id: 's1',
@@ -586,10 +480,15 @@ describe('getActivitySchedules', () => {
 			},
 		];
 
-		const supabase = createMockSupabase({
-			selectResult: { data: mockSchedules, error: null },
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: {
+				schedules: mockSchedules,
+				due_activities: ['code_review'],
+				count: 2,
+			},
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await getActivitySchedules(
 			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
@@ -598,90 +497,36 @@ describe('getActivitySchedules', () => {
 
 		expect((result.result as { schedules: unknown[] }).schedules).toHaveLength(2);
 		expect((result.result as { count: number }).count).toBe(2);
+		expect((result.result as { due_activities: string[] }).due_activities).toContain('code_review');
 	});
 
-	it('should identify due activities', async () => {
-		const pastDate = new Date(Date.now() - 3600000).toISOString(); // 1 hour ago
-		const futureDate = new Date(Date.now() + 3600000).toISOString(); // 1 hour from now
-
-		const mockSchedules = [
-			{
-				id: 's1',
-				activity_type: 'code_review',
-				enabled: true,
-				next_run_at: pastDate, // Due
-			},
-			{
-				id: 's2',
-				activity_type: 'security_review',
-				enabled: true,
-				next_run_at: futureDate, // Not due
-			},
-			{
-				id: 's3',
-				activity_type: 'test_coverage',
-				enabled: false, // Disabled
-				next_run_at: pastDate,
-			},
-		];
-
-		const supabase = createMockSupabase({
-			selectResult: { data: mockSchedules, error: null },
-		});
-		const ctx = createMockContext(supabase);
-
-		const result = await getActivitySchedules(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
-			ctx
-		);
-
-		const dueActivities = (result.result as { due_activities: string[] }).due_activities;
-		expect(dueActivities).toContain('code_review');
-		expect(dueActivities).not.toContain('security_review');
-		expect(dueActivities).not.toContain('test_coverage');
-	});
-
-	it('should query background_activity_schedules table', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+	it('should call API proxy with correct parameters', async () => {
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { schedules: [], due_activities: [], count: 0 },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await getActivitySchedules(
 			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
 			ctx
 		);
 
-		expect(supabase.from).toHaveBeenCalledWith('background_activity_schedules');
-	});
-
-	it('should order schedules by activity_type', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
-		});
-		const ctx = createMockContext(supabase);
-
-		await getActivitySchedules(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
-			ctx
+		expect(mockApiClient.proxy).toHaveBeenCalledWith(
+			'get_activity_schedules',
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' }
 		);
-
-		expect(supabase.order).toHaveBeenCalledWith('activity_type');
 	});
 
-	it('should throw error when query fails', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
-		// Override to return error
-		vi.mocked(supabase.from('').select).mockReturnValue({
-			...supabase,
-			then: (resolve: (val: unknown) => void) =>
-				Promise.resolve({ data: null, error: { message: 'Query failed' } }).then(resolve),
-		} as unknown as ReturnType<SupabaseClient['from']>);
+	it('should throw error when API call fails', async () => {
+		mockApiClient.proxy.mockResolvedValue({
+			ok: false,
+			error: 'Query failed',
+		});
+		const ctx = createMockContext();
 
 		await expect(
 			getActivitySchedules({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow();
+		).rejects.toThrow('Failed to get activity schedules');
 	});
 });