fix(backend): organizational skills do not trigger (v1 conversations) (#12037)

tests/unit/app_server/test_app_conversation_service_base.py

@@ -15,6 +15,7 @@ from openhands.app_server.app_conversation.app_conversation_models import AgentT
 from openhands.app_server.app_conversation.app_conversation_service_base import (
     AppConversationServiceBase,
 )
+from openhands.app_server.sandbox.sandbox_models import SandboxInfo
 from openhands.app_server.user.user_context import UserContext
 
 
@@ -916,3 +917,350 @@ async def test_configure_git_user_settings_special_characters_in_name(mock_works
     mock_workspace.execute_command.assert_any_call(
         'git config --global user.name "Test O\'Brien"', '/workspace/project'
     )
+
+
+# =============================================================================
+# Tests for _load_and_merge_all_skills with org skills
+# =============================================================================
+
+
+class TestLoadAndMergeAllSkillsWithOrgSkills:
+    """Test _load_and_merge_all_skills includes organization skills."""
+
+    @pytest.mark.asyncio
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_sandbox_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_global_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_user_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_org_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_repo_skills'
+    )
+    async def test_load_and_merge_includes_org_skills(
+        self,
+        mock_load_repo,
+        mock_load_org,
+        mock_load_user,
+        mock_load_global,
+        mock_load_sandbox,
+    ):
+        """Test that _load_and_merge_all_skills loads and merges org skills."""
+        # Arrange
+        mock_user_context = Mock(spec=UserContext)
+        with patch.object(
+            AppConversationServiceBase,
+            '__abstractmethods__',
+            set(),
+        ):
+            service = AppConversationServiceBase(
+                init_git_in_empty_workspace=True,
+                user_context=mock_user_context,
+            )
+
+            sandbox = Mock(spec=SandboxInfo)
+            sandbox.exposed_urls = []
+            remote_workspace = AsyncMock()
+
+            # Create distinct mock skills for each source
+            sandbox_skill = Mock()
+            sandbox_skill.name = 'sandbox_skill'
+            global_skill = Mock()
+            global_skill.name = 'global_skill'
+            user_skill = Mock()
+            user_skill.name = 'user_skill'
+            org_skill = Mock()
+            org_skill.name = 'org_skill'
+            repo_skill = Mock()
+            repo_skill.name = 'repo_skill'
+
+            mock_load_sandbox.return_value = [sandbox_skill]
+            mock_load_global.return_value = [global_skill]
+            mock_load_user.return_value = [user_skill]
+            mock_load_org.return_value = [org_skill]
+            mock_load_repo.return_value = [repo_skill]
+
+            # Act
+            result = await service._load_and_merge_all_skills(
+                sandbox, remote_workspace, 'owner/repo', '/workspace'
+            )
+
+            # Assert
+            assert len(result) == 5
+            names = {s.name for s in result}
+            assert names == {
+                'sandbox_skill',
+                'global_skill',
+                'user_skill',
+                'org_skill',
+                'repo_skill',
+            }
+            mock_load_org.assert_called_once_with(
+                remote_workspace, 'owner/repo', '/workspace', mock_user_context
+            )
+
+    @pytest.mark.asyncio
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_sandbox_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_global_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_user_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_org_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_repo_skills'
+    )
+    async def test_load_and_merge_org_skills_precedence(
+        self,
+        mock_load_repo,
+        mock_load_org,
+        mock_load_user,
+        mock_load_global,
+        mock_load_sandbox,
+    ):
+        """Test that org skills have correct precedence (higher than user, lower than repo)."""
+        # Arrange
+        mock_user_context = Mock(spec=UserContext)
+        with patch.object(
+            AppConversationServiceBase,
+            '__abstractmethods__',
+            set(),
+        ):
+            service = AppConversationServiceBase(
+                init_git_in_empty_workspace=True,
+                user_context=mock_user_context,
+            )
+
+            sandbox = Mock(spec=SandboxInfo)
+            sandbox.exposed_urls = []
+            remote_workspace = AsyncMock()
+
+            # Create skills with same name but different sources
+            user_skill = Mock()
+            user_skill.name = 'common_skill'
+            user_skill.source = 'user'
+
+            org_skill = Mock()
+            org_skill.name = 'common_skill'
+            org_skill.source = 'org'
+
+            repo_skill = Mock()
+            repo_skill.name = 'common_skill'
+            repo_skill.source = 'repo'
+
+            mock_load_sandbox.return_value = []
+            mock_load_global.return_value = []
+            mock_load_user.return_value = [user_skill]
+            mock_load_org.return_value = [org_skill]
+            mock_load_repo.return_value = [repo_skill]
+
+            # Act
+            result = await service._load_and_merge_all_skills(
+                sandbox, remote_workspace, 'owner/repo', '/workspace'
+            )
+
+            # Assert
+            # Should have only one skill with repo source (highest precedence)
+            assert len(result) == 1
+            assert result[0].source == 'repo'
+
+    @pytest.mark.asyncio
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_sandbox_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_global_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_user_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_org_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_repo_skills'
+    )
+    async def test_load_and_merge_org_skills_override_user_skills(
+        self,
+        mock_load_repo,
+        mock_load_org,
+        mock_load_user,
+        mock_load_global,
+        mock_load_sandbox,
+    ):
+        """Test that org skills override user skills for same name."""
+        # Arrange
+        mock_user_context = Mock(spec=UserContext)
+        with patch.object(
+            AppConversationServiceBase,
+            '__abstractmethods__',
+            set(),
+        ):
+            service = AppConversationServiceBase(
+                init_git_in_empty_workspace=True,
+                user_context=mock_user_context,
+            )
+
+            sandbox = Mock(spec=SandboxInfo)
+            sandbox.exposed_urls = []
+            remote_workspace = AsyncMock()
+
+            # Create skills with same name
+            user_skill = Mock()
+            user_skill.name = 'shared_skill'
+            user_skill.priority = 'low'
+
+            org_skill = Mock()
+            org_skill.name = 'shared_skill'
+            org_skill.priority = 'high'
+
+            mock_load_sandbox.return_value = []
+            mock_load_global.return_value = []
+            mock_load_user.return_value = [user_skill]
+            mock_load_org.return_value = [org_skill]
+            mock_load_repo.return_value = []
+
+            # Act
+            result = await service._load_and_merge_all_skills(
+                sandbox, remote_workspace, 'owner/repo', '/workspace'
+            )
+
+            # Assert
+            assert len(result) == 1
+            assert result[0].priority == 'high'  # Org skill should win
+
+    @pytest.mark.asyncio
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_sandbox_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_global_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_user_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_org_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_repo_skills'
+    )
+    async def test_load_and_merge_handles_org_skills_failure(
+        self,
+        mock_load_repo,
+        mock_load_org,
+        mock_load_user,
+        mock_load_global,
+        mock_load_sandbox,
+    ):
+        """Test that failure to load org skills doesn't break the overall process."""
+        # Arrange
+        mock_user_context = Mock(spec=UserContext)
+        with patch.object(
+            AppConversationServiceBase,
+            '__abstractmethods__',
+            set(),
+        ):
+            service = AppConversationServiceBase(
+                init_git_in_empty_workspace=True,
+                user_context=mock_user_context,
+            )
+
+            sandbox = Mock(spec=SandboxInfo)
+            sandbox.exposed_urls = []
+            remote_workspace = AsyncMock()
+
+            global_skill = Mock()
+            global_skill.name = 'global_skill'
+            repo_skill = Mock()
+            repo_skill.name = 'repo_skill'
+
+            mock_load_sandbox.return_value = []
+            mock_load_global.return_value = [global_skill]
+            mock_load_user.return_value = []
+            mock_load_org.return_value = []  # Org skills failed/empty
+            mock_load_repo.return_value = [repo_skill]
+
+            # Act
+            result = await service._load_and_merge_all_skills(
+                sandbox, remote_workspace, 'owner/repo', '/workspace'
+            )
+
+            # Assert
+            # Should still have skills from other sources
+            assert len(result) == 2
+            names = {s.name for s in result}
+            assert names == {'global_skill', 'repo_skill'}
+
+    @pytest.mark.asyncio
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_sandbox_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_global_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_user_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_org_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.app_conversation_service_base.load_repo_skills'
+    )
+    async def test_load_and_merge_no_selected_repository(
+        self,
+        mock_load_repo,
+        mock_load_org,
+        mock_load_user,
+        mock_load_global,
+        mock_load_sandbox,
+    ):
+        """Test skill loading when no repository is selected."""
+        # Arrange
+        mock_user_context = Mock(spec=UserContext)
+        with patch.object(
+            AppConversationServiceBase,
+            '__abstractmethods__',
+            set(),
+        ):
+            service = AppConversationServiceBase(
+                init_git_in_empty_workspace=True,
+                user_context=mock_user_context,
+            )
+
+            sandbox = Mock(spec=SandboxInfo)
+            sandbox.exposed_urls = []
+            remote_workspace = AsyncMock()
+
+            global_skill = Mock()
+            global_skill.name = 'global_skill'
+
+            mock_load_sandbox.return_value = []
+            mock_load_global.return_value = [global_skill]
+            mock_load_user.return_value = []
+            mock_load_org.return_value = []
+            mock_load_repo.return_value = []
+
+            # Act
+            result = await service._load_and_merge_all_skills(
+                sandbox, remote_workspace, None, '/workspace'
+            )
+
+            # Assert
+            assert len(result) == 1
+            # Org skills should be called even with None repository
+            mock_load_org.assert_called_once_with(
+                remote_workspace, None, '/workspace', mock_user_context
+            )

tests/unit/app_server/test_skill_loader.py

@@ -11,15 +11,27 @@ from unittest.mock import AsyncMock, MagicMock, Mock, patch
 import pytest
 
 from openhands.app_server.app_conversation.skill_loader import (
+    _cleanup_org_repository,
+    _clone_org_repository,
+    _determine_org_repo_path,
     _determine_repo_root,
     _find_and_load_global_skill_files,
     _find_and_load_skill_md_files,
+    _get_org_repository_url,
+    _is_azure_devops_repository,
+    _is_gitlab_repository,
+    _load_skills_from_org_directories,
     _load_special_files,
+    _merge_org_skills_with_precedence,
     _read_file_from_workspace,
+    _validate_repository_for_org_skills,
     load_global_skills,
+    load_org_skills,
     load_repo_skills,
     merge_skills,
 )
+from openhands.integrations.provider import ProviderType
+from openhands.integrations.service_types import AuthenticationError
 
 # ===== Test Fixtures =====
 
@@ -667,6 +679,669 @@ class TestMergeSkills:
         assert len(result) == 2
 
 
+# ===== Tests for Organization Skills Functions =====
+
+
+class TestIsGitlabRepository:
+    """Test _is_gitlab_repository helper function."""
+
+    @pytest.mark.asyncio
+    async def test_is_gitlab_repository_true(self):
+        """Test GitLab repository detection returns True."""
+        # Arrange
+        mock_user_context = AsyncMock()
+        mock_provider_handler = AsyncMock()
+        mock_repository = Mock()
+        mock_repository.git_provider = ProviderType.GITLAB
+
+        mock_user_context.get_provider_handler.return_value = mock_provider_handler
+        mock_provider_handler.verify_repo_provider.return_value = mock_repository
+
+        # Act
+        result = await _is_gitlab_repository('owner/repo', mock_user_context)
+
+        # Assert
+        assert result is True
+        mock_provider_handler.verify_repo_provider.assert_called_once_with('owner/repo')
+
+    @pytest.mark.asyncio
+    async def test_is_gitlab_repository_false(self):
+        """Test non-GitLab repository detection returns False."""
+        # Arrange
+        mock_user_context = AsyncMock()
+        mock_provider_handler = AsyncMock()
+        mock_repository = Mock()
+        mock_repository.git_provider = ProviderType.GITHUB
+
+        mock_user_context.get_provider_handler.return_value = mock_provider_handler
+        mock_provider_handler.verify_repo_provider.return_value = mock_repository
+
+        # Act
+        result = await _is_gitlab_repository('owner/repo', mock_user_context)
+
+        # Assert
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_is_gitlab_repository_exception_handling(self):
+        """Test exception handling returns False."""
+        # Arrange
+        mock_user_context = AsyncMock()
+        mock_user_context.get_provider_handler.side_effect = Exception('API error')
+
+        # Act
+        result = await _is_gitlab_repository('owner/repo', mock_user_context)
+
+        # Assert
+        assert result is False
+
+
+class TestIsAzureDevOpsRepository:
+    """Test _is_azure_devops_repository helper function."""
+
+    @pytest.mark.asyncio
+    async def test_is_azure_devops_repository_true(self):
+        """Test Azure DevOps repository detection returns True."""
+        # Arrange
+        mock_user_context = AsyncMock()
+        mock_provider_handler = AsyncMock()
+        mock_repository = Mock()
+        mock_repository.git_provider = ProviderType.AZURE_DEVOPS
+
+        mock_user_context.get_provider_handler.return_value = mock_provider_handler
+        mock_provider_handler.verify_repo_provider.return_value = mock_repository
+
+        # Act
+        result = await _is_azure_devops_repository(
+            'org/project/repo', mock_user_context
+        )
+
+        # Assert
+        assert result is True
+        mock_provider_handler.verify_repo_provider.assert_called_once_with(
+            'org/project/repo'
+        )
+
+    @pytest.mark.asyncio
+    async def test_is_azure_devops_repository_false(self):
+        """Test non-Azure DevOps repository detection returns False."""
+        # Arrange
+        mock_user_context = AsyncMock()
+        mock_provider_handler = AsyncMock()
+        mock_repository = Mock()
+        mock_repository.git_provider = ProviderType.GITHUB
+
+        mock_user_context.get_provider_handler.return_value = mock_provider_handler
+        mock_provider_handler.verify_repo_provider.return_value = mock_repository
+
+        # Act
+        result = await _is_azure_devops_repository('owner/repo', mock_user_context)
+
+        # Assert
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_is_azure_devops_repository_exception_handling(self):
+        """Test exception handling returns False."""
+        # Arrange
+        mock_user_context = AsyncMock()
+        mock_user_context.get_provider_handler.side_effect = Exception('Network error')
+
+        # Act
+        result = await _is_azure_devops_repository('owner/repo', mock_user_context)
+
+        # Assert
+        assert result is False
+
+
+class TestDetermineOrgRepoPath:
+    """Test _determine_org_repo_path helper function."""
+
+    @pytest.mark.asyncio
+    @patch('openhands.app_server.app_conversation.skill_loader._is_gitlab_repository')
+    @patch(
+        'openhands.app_server.app_conversation.skill_loader._is_azure_devops_repository'
+    )
+    async def test_github_repository_path(self, mock_is_azure, mock_is_gitlab):
+        """Test org path for GitHub repository."""
+        # Arrange
+        mock_user_context = AsyncMock()
+        mock_is_gitlab.return_value = False
+        mock_is_azure.return_value = False
+
+        # Act
+        org_repo, org_name = await _determine_org_repo_path(
+            'owner/repo', mock_user_context
+        )
+
+        # Assert
+        assert org_repo == 'owner/.openhands'
+        assert org_name == 'owner'
+
+    @pytest.mark.asyncio
+    @patch('openhands.app_server.app_conversation.skill_loader._is_gitlab_repository')
+    @patch(
+        'openhands.app_server.app_conversation.skill_loader._is_azure_devops_repository'
+    )
+    async def test_gitlab_repository_path(self, mock_is_azure, mock_is_gitlab):
+        """Test org path for GitLab repository."""
+        # Arrange
+        mock_user_context = AsyncMock()
+        mock_is_gitlab.return_value = True
+        mock_is_azure.return_value = False
+
+        # Act
+        org_repo, org_name = await _determine_org_repo_path(
+            'owner/repo', mock_user_context
+        )
+
+        # Assert
+        assert org_repo == 'owner/openhands-config'
+        assert org_name == 'owner'
+
+    @pytest.mark.asyncio
+    @patch('openhands.app_server.app_conversation.skill_loader._is_gitlab_repository')
+    @patch(
+        'openhands.app_server.app_conversation.skill_loader._is_azure_devops_repository'
+    )
+    async def test_azure_devops_repository_path(self, mock_is_azure, mock_is_gitlab):
+        """Test org path for Azure DevOps repository."""
+        # Arrange
+        mock_user_context = AsyncMock()
+        mock_is_gitlab.return_value = False
+        mock_is_azure.return_value = True
+
+        # Act
+        org_repo, org_name = await _determine_org_repo_path(
+            'org/project/repo', mock_user_context
+        )
+
+        # Assert
+        assert org_repo == 'org/openhands-config/openhands-config'
+        assert org_name == 'org'
+
+
+class TestValidateRepositoryForOrgSkills:
+    """Test _validate_repository_for_org_skills helper function."""
+
+    def test_valid_repository_two_parts(self):
+        """Test validation passes for repository with two parts."""
+        # Act
+        result = _validate_repository_for_org_skills('owner/repo')
+
+        # Assert
+        assert result is True
+
+    def test_valid_repository_three_parts(self):
+        """Test validation passes for repository with three parts (Azure DevOps)."""
+        # Act
+        result = _validate_repository_for_org_skills('org/project/repo')
+
+        # Assert
+        assert result is True
+
+    def test_invalid_repository_one_part(self):
+        """Test validation fails for repository with only one part."""
+        # Act
+        result = _validate_repository_for_org_skills('repo')
+
+        # Assert
+        assert result is False
+
+    def test_invalid_repository_empty_string(self):
+        """Test validation fails for empty string."""
+        # Act
+        result = _validate_repository_for_org_skills('')
+
+        # Assert
+        assert result is False
+
+
+class TestGetOrgRepositoryUrl:
+    """Test _get_org_repository_url helper function."""
+
+    @pytest.mark.asyncio
+    async def test_successful_url_retrieval(self):
+        """Test successfully retrieving authenticated URL."""
+        # Arrange
+        mock_user_context = AsyncMock()
+        expected_url = 'https://token@github.com/owner/.openhands.git'
+        mock_user_context.get_authenticated_git_url.return_value = expected_url
+
+        # Act
+        result = await _get_org_repository_url('owner/.openhands', mock_user_context)
+
+        # Assert
+        assert result == expected_url
+        mock_user_context.get_authenticated_git_url.assert_called_once_with(
+            'owner/.openhands'
+        )
+
+    @pytest.mark.asyncio
+    async def test_authentication_error(self):
+        """Test handling of authentication error returns None."""
+        # Arrange
+        mock_user_context = AsyncMock()
+        mock_user_context.get_authenticated_git_url.side_effect = AuthenticationError(
+            'Not found'
+        )
+
+        # Act
+        result = await _get_org_repository_url('owner/.openhands', mock_user_context)
+
+        # Assert
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_general_exception(self):
+        """Test handling of general exception returns None."""
+        # Arrange
+        mock_user_context = AsyncMock()
+        mock_user_context.get_authenticated_git_url.side_effect = Exception(
+            'Network error'
+        )
+
+        # Act
+        result = await _get_org_repository_url('owner/.openhands', mock_user_context)
+
+        # Assert
+        assert result is None
+
+
+class TestCloneOrgRepository:
+    """Test _clone_org_repository helper function."""
+
+    @pytest.mark.asyncio
+    async def test_successful_clone(self, mock_async_remote_workspace):
+        """Test successful repository clone."""
+        # Arrange
+        result_obj = Mock()
+        result_obj.exit_code = 0
+        mock_async_remote_workspace.execute_command.return_value = result_obj
+
+        # Act
+        success = await _clone_org_repository(
+            mock_async_remote_workspace,
+            'https://github.com/owner/.openhands.git',
+            '/workspace/_org_openhands_owner',
+            '/workspace',
+            'owner/.openhands',
+        )
+
+        # Assert
+        assert success is True
+        mock_async_remote_workspace.execute_command.assert_called_once()
+        call_args = mock_async_remote_workspace.execute_command.call_args
+        assert 'git clone' in call_args[0][0]
+        assert '--depth 1' in call_args[0][0]
+
+    @pytest.mark.asyncio
+    async def test_failed_clone(self, mock_async_remote_workspace):
+        """Test failed repository clone."""
+        # Arrange
+        result_obj = Mock()
+        result_obj.exit_code = 1
+        result_obj.stderr = 'Repository not found'
+        mock_async_remote_workspace.execute_command.return_value = result_obj
+
+        # Act
+        success = await _clone_org_repository(
+            mock_async_remote_workspace,
+            'https://github.com/owner/.openhands.git',
+            '/workspace/_org_openhands_owner',
+            '/workspace',
+            'owner/.openhands',
+        )
+
+        # Assert
+        assert success is False
+
+
+class TestLoadSkillsFromOrgDirectories:
+    """Test _load_skills_from_org_directories helper function."""
+
+    @pytest.mark.asyncio
+    @patch(
+        'openhands.app_server.app_conversation.skill_loader._find_and_load_skill_md_files'
+    )
+    async def test_load_from_both_directories(
+        self, mock_find_and_load, mock_async_remote_workspace, mock_skills_list
+    ):
+        """Test loading skills from both skills/ and microagents/ directories."""
+        # Arrange
+        skills_dir_skills = [mock_skills_list[0]]
+        microagents_dir_skills = [mock_skills_list[1], mock_skills_list[2]]
+        mock_find_and_load.side_effect = [skills_dir_skills, microagents_dir_skills]
+
+        # Act
+        result_skills, result_microagents = await _load_skills_from_org_directories(
+            mock_async_remote_workspace, '/workspace/_org_openhands_owner', '/workspace'
+        )
+
+        # Assert
+        assert result_skills == skills_dir_skills
+        assert result_microagents == microagents_dir_skills
+        assert mock_find_and_load.call_count == 2
+
+        # Verify correct directories were checked
+        first_call = mock_find_and_load.call_args_list[0]
+        second_call = mock_find_and_load.call_args_list[1]
+        assert '/skills' in first_call[0][1]
+        assert '/microagents' in second_call[0][1]
+
+    @pytest.mark.asyncio
+    @patch(
+        'openhands.app_server.app_conversation.skill_loader._find_and_load_skill_md_files'
+    )
+    async def test_load_with_empty_directories(
+        self, mock_find_and_load, mock_async_remote_workspace
+    ):
+        """Test loading when both directories are empty."""
+        # Arrange
+        mock_find_and_load.side_effect = [[], []]
+
+        # Act
+        result_skills, result_microagents = await _load_skills_from_org_directories(
+            mock_async_remote_workspace, '/workspace/_org_openhands_owner', '/workspace'
+        )
+
+        # Assert
+        assert result_skills == []
+        assert result_microagents == []
+
+
+class TestMergeOrgSkillsWithPrecedence:
+    """Test _merge_org_skills_with_precedence helper function."""
+
+    def test_merge_no_duplicates(self, mock_skills_list):
+        """Test merging skills with no name conflicts."""
+        # Arrange
+        skills_dir_skills = [mock_skills_list[0]]
+        microagents_dir_skills = [mock_skills_list[1], mock_skills_list[2]]
+
+        # Act
+        result = _merge_org_skills_with_precedence(
+            skills_dir_skills, microagents_dir_skills
+        )
+
+        # Assert
+        assert len(result) == 3
+        names = {s.name for s in result}
+        assert names == {'skill_0', 'skill_1', 'skill_2'}
+
+    def test_merge_with_duplicate_skills_dir_wins(self):
+        """Test skills/ directory takes precedence over microagents/."""
+        # Arrange
+        skill_from_microagents = Mock()
+        skill_from_microagents.name = 'common_skill'
+        skill_from_microagents.source = 'microagents'
+
+        skill_from_skills = Mock()
+        skill_from_skills.name = 'common_skill'
+        skill_from_skills.source = 'skills'
+
+        # Act
+        result = _merge_org_skills_with_precedence(
+            [skill_from_skills], [skill_from_microagents]
+        )
+
+        # Assert
+        assert len(result) == 1
+        assert result[0].source == 'skills'
+
+    def test_merge_with_empty_lists(self):
+        """Test merging with empty skill lists."""
+        # Act
+        result = _merge_org_skills_with_precedence([], [])
+
+        # Assert
+        assert result == []
+
+    def test_merge_with_only_skills_dir(self, mock_skills_list):
+        """Test merging with only skills/ directory populated."""
+        # Act
+        result = _merge_org_skills_with_precedence([mock_skills_list[0]], [])
+
+        # Assert
+        assert len(result) == 1
+        assert result[0] == mock_skills_list[0]
+
+    def test_merge_with_only_microagents_dir(self, mock_skills_list):
+        """Test merging with only microagents/ directory populated."""
+        # Act
+        result = _merge_org_skills_with_precedence([], [mock_skills_list[0]])
+
+        # Assert
+        assert len(result) == 1
+        assert result[0] == mock_skills_list[0]
+
+
+class TestCleanupOrgRepository:
+    """Test _cleanup_org_repository helper function."""
+
+    @pytest.mark.asyncio
+    async def test_cleanup_successful(self, mock_async_remote_workspace):
+        """Test successful cleanup of org repository directory."""
+        # Arrange
+        result_obj = Mock()
+        result_obj.exit_code = 0
+        mock_async_remote_workspace.execute_command.return_value = result_obj
+
+        # Act
+        await _cleanup_org_repository(
+            mock_async_remote_workspace,
+            '/workspace/_org_openhands_owner',
+            '/workspace',
+        )
+
+        # Assert
+        mock_async_remote_workspace.execute_command.assert_called_once()
+        call_args = mock_async_remote_workspace.execute_command.call_args
+        assert 'rm -rf' in call_args[0][0]
+        assert '/workspace/_org_openhands_owner' in call_args[0][0]
+
+
+class TestLoadOrgSkills:
+    """Test load_org_skills main function."""
+
+    @pytest.mark.asyncio
+    async def test_load_org_skills_no_selected_repository(
+        self, mock_async_remote_workspace
+    ):
+        """Test load_org_skills returns empty list when no repository selected."""
+        # Arrange
+        mock_user_context = AsyncMock()
+
+        # Act
+        result = await load_org_skills(
+            mock_async_remote_workspace, None, '/workspace', mock_user_context
+        )
+
+        # Assert
+        assert result == []
+
+    @pytest.mark.asyncio
+    @patch(
+        'openhands.app_server.app_conversation.skill_loader._validate_repository_for_org_skills'
+    )
+    async def test_load_org_skills_invalid_repository(
+        self, mock_validate, mock_async_remote_workspace
+    ):
+        """Test load_org_skills returns empty list for invalid repository."""
+        # Arrange
+        mock_validate.return_value = False
+        mock_user_context = AsyncMock()
+
+        # Act
+        result = await load_org_skills(
+            mock_async_remote_workspace, 'invalid', '/workspace', mock_user_context
+        )
+
+        # Assert
+        assert result == []
+        mock_validate.assert_called_once_with('invalid')
+
+    @pytest.mark.asyncio
+    @patch(
+        'openhands.app_server.app_conversation.skill_loader._validate_repository_for_org_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.skill_loader._determine_org_repo_path'
+    )
+    @patch('openhands.app_server.app_conversation.skill_loader._get_org_repository_url')
+    async def test_load_org_skills_no_url_available(
+        self,
+        mock_get_url,
+        mock_determine_path,
+        mock_validate,
+        mock_async_remote_workspace,
+    ):
+        """Test load_org_skills returns empty list when URL cannot be retrieved."""
+        # Arrange
+        mock_validate.return_value = True
+        mock_determine_path.return_value = ('owner/.openhands', 'owner')
+        mock_get_url.return_value = None
+        mock_user_context = AsyncMock()
+
+        # Act
+        result = await load_org_skills(
+            mock_async_remote_workspace,
+            'owner/repo',
+            '/workspace',
+            mock_user_context,
+        )
+
+        # Assert
+        assert result == []
+
+    @pytest.mark.asyncio
+    @patch(
+        'openhands.app_server.app_conversation.skill_loader._validate_repository_for_org_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.skill_loader._determine_org_repo_path'
+    )
+    @patch('openhands.app_server.app_conversation.skill_loader._get_org_repository_url')
+    @patch('openhands.app_server.app_conversation.skill_loader._clone_org_repository')
+    async def test_load_org_skills_clone_fails(
+        self,
+        mock_clone,
+        mock_get_url,
+        mock_determine_path,
+        mock_validate,
+        mock_async_remote_workspace,
+    ):
+        """Test load_org_skills returns empty list when clone fails."""
+        # Arrange
+        mock_validate.return_value = True
+        mock_determine_path.return_value = ('owner/.openhands', 'owner')
+        mock_get_url.return_value = 'https://github.com/owner/.openhands.git'
+        mock_clone.return_value = False
+        mock_user_context = AsyncMock()
+
+        # Act
+        result = await load_org_skills(
+            mock_async_remote_workspace,
+            'owner/repo',
+            '/workspace',
+            mock_user_context,
+        )
+
+        # Assert
+        assert result == []
+
+    @pytest.mark.asyncio
+    @patch(
+        'openhands.app_server.app_conversation.skill_loader._validate_repository_for_org_skills'
+    )
+    @patch(
+        'openhands.app_server.app_conversation.skill_loader._determine_org_repo_path'
+    )
+    @patch('openhands.app_server.app_conversation.skill_loader._get_org_repository_url')
+    @patch('openhands.app_server.app_conversation.skill_loader._clone_org_repository')
+    @patch(
+        'openhands.app_server.app_conversation.skill_loader._load_skills_from_org_directories'
+    )
+    @patch('openhands.app_server.app_conversation.skill_loader._cleanup_org_repository')
+    async def test_load_org_skills_success(
+        self,
+        mock_cleanup,
+        mock_load_skills,
+        mock_clone,
+        mock_get_url,
+        mock_determine_path,
+        mock_validate,
+        mock_async_remote_workspace,
+        mock_skills_list,
+    ):
+        """Test successful org skills loading."""
+        # Arrange
+        mock_validate.return_value = True
+        mock_determine_path.return_value = ('owner/.openhands', 'owner')
+        mock_get_url.return_value = 'https://github.com/owner/.openhands.git'
+        mock_clone.return_value = True
+        mock_load_skills.return_value = ([mock_skills_list[0]], [mock_skills_list[1]])
+        mock_user_context = AsyncMock()
+
+        # Act
+        result = await load_org_skills(
+            mock_async_remote_workspace,
+            'owner/repo',
+            '/workspace',
+            mock_user_context,
+        )
+
+        # Assert
+        assert len(result) == 2
+        mock_cleanup.assert_called_once()
+
+    @pytest.mark.asyncio
+    @patch(
+        'openhands.app_server.app_conversation.skill_loader._validate_repository_for_org_skills'
+    )
+    async def test_load_org_skills_handles_authentication_error(
+        self, mock_validate, mock_async_remote_workspace
+    ):
+        """Test load_org_skills handles AuthenticationError gracefully."""
+        # Arrange
+        mock_validate.side_effect = AuthenticationError('Auth failed')
+        mock_user_context = AsyncMock()
+
+        # Act
+        result = await load_org_skills(
+            mock_async_remote_workspace,
+            'owner/repo',
+            '/workspace',
+            mock_user_context,
+        )
+
+        # Assert
+        assert result == []
+
+    @pytest.mark.asyncio
+    @patch(
+        'openhands.app_server.app_conversation.skill_loader._validate_repository_for_org_skills'
+    )
+    async def test_load_org_skills_handles_general_exception(
+        self, mock_validate, mock_async_remote_workspace
+    ):
+        """Test load_org_skills handles general exceptions gracefully."""
+        # Arrange
+        mock_validate.side_effect = Exception('Unexpected error')
+        mock_user_context = AsyncMock()
+
+        # Act
+        result = await load_org_skills(
+            mock_async_remote_workspace,
+            'owner/repo',
+            '/workspace',
+            mock_user_context,
+        )
+
+        # Assert
+        assert result == []
+
+
 # ===== Integration Tests =====
 
 
@@ -754,3 +1429,110 @@ class TestSkillLoaderIntegration:
         # Should have only one skill with repo source (highest precedence)
         assert len(all_skills) == 1
         assert all_skills[0].source == 'repo'
+
+    @pytest.mark.asyncio
+    @patch('openhands.app_server.app_conversation.skill_loader.load_global_skills')
+    @patch('openhands.sdk.context.skills.load_user_skills')
+    @patch('openhands.app_server.app_conversation.skill_loader.load_org_skills')
+    @patch('openhands.app_server.app_conversation.skill_loader.load_repo_skills')
+    async def test_loading_with_org_skills_precedence(
+        self,
+        mock_load_repo,
+        mock_load_org,
+        mock_load_user,
+        mock_load_global,
+        mock_async_remote_workspace,
+    ):
+        """Test that org skills fit correctly in precedence order."""
+        # Arrange
+        # Create skills with same name but different sources
+        global_skill = Mock()
+        global_skill.name = 'shared_skill'
+        global_skill.priority = 'low'
+
+        user_skill = Mock()
+        user_skill.name = 'shared_skill'
+        user_skill.priority = 'medium'
+
+        org_skill = Mock()
+        org_skill.name = 'shared_skill'
+        org_skill.priority = 'high'
+
+        repo_skill = Mock()
+        repo_skill.name = 'shared_skill'
+        repo_skill.priority = 'highest'
+
+        mock_load_global.return_value = [global_skill]
+        mock_load_user.return_value = [user_skill]
+        mock_load_org.return_value = [org_skill]
+        mock_load_repo.return_value = [repo_skill]
+
+        mock_user_context = AsyncMock()
+
+        # Act
+        global_skills = mock_load_global()
+        user_skills = mock_load_user()
+        org_skills = await mock_load_org(
+            mock_async_remote_workspace, 'owner/repo', '/workspace', mock_user_context
+        )
+        repo_skills = await mock_load_repo(
+            mock_async_remote_workspace, 'owner/repo', '/workspace'
+        )
+
+        # Merge with correct precedence: global < user < org < repo
+        all_skills = merge_skills([global_skills, user_skills, org_skills, repo_skills])
+
+        # Assert
+        assert len(all_skills) == 1
+        assert all_skills[0].priority == 'highest'  # Repo has highest precedence
+
+    @pytest.mark.asyncio
+    @patch('openhands.app_server.app_conversation.skill_loader.load_global_skills')
+    @patch('openhands.sdk.context.skills.load_user_skills')
+    @patch('openhands.app_server.app_conversation.skill_loader.load_org_skills')
+    @patch('openhands.app_server.app_conversation.skill_loader.load_repo_skills')
+    async def test_loading_org_skills_with_unique_names(
+        self,
+        mock_load_repo,
+        mock_load_org,
+        mock_load_user,
+        mock_load_global,
+        mock_async_remote_workspace,
+    ):
+        """Test loading org skills with unique names alongside other sources."""
+        # Arrange
+        global_skill = Mock()
+        global_skill.name = 'global_skill'
+
+        user_skill = Mock()
+        user_skill.name = 'user_skill'
+
+        org_skill = Mock()
+        org_skill.name = 'org_skill'
+
+        repo_skill = Mock()
+        repo_skill.name = 'repo_skill'
+
+        mock_load_global.return_value = [global_skill]
+        mock_load_user.return_value = [user_skill]
+        mock_load_org.return_value = [org_skill]
+        mock_load_repo.return_value = [repo_skill]
+
+        mock_user_context = AsyncMock()
+
+        # Act
+        global_skills = mock_load_global()
+        user_skills = mock_load_user()
+        org_skills = await mock_load_org(
+            mock_async_remote_workspace, 'owner/repo', '/workspace', mock_user_context
+        )
+        repo_skills = await mock_load_repo(
+            mock_async_remote_workspace, 'owner/repo', '/workspace'
+        )
+
+        all_skills = merge_skills([global_skills, user_skills, org_skills, repo_skills])
+
+        # Assert
+        assert len(all_skills) == 4
+        names = {s.name for s in all_skills}
+        assert names == {'global_skill', 'user_skill', 'org_skill', 'repo_skill'}