Update database paths and fix foreign key references across coordinator API

- Change SQLite database path from `/home/oib/windsurf/aitbc/data/` to `/opt/data/`
- Fix foreign key references to use correct table names (users, wallets, gpu_registry)
- Replace governance router with new governance and community routers
- Add multi-modal RL router to main application
- Simplify DEPLOYMENT_READINESS_REPORT.md to focus on production deployment status
- Update governance router with decentralized DAO voting

tests/integration/test_community_governance.py

@@ -0,0 +1,154 @@
+"""
+Integration tests for the Community and Governance systems
+"""
+import pytest
+import asyncio
+from datetime import datetime, timedelta
+from typing import Dict, Any, List
+import sys
+import os
+
+# Add the source directory to path to allow absolute imports
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../../apps/coordinator-api/src')))
+
+# Import from the app
+from app.domain.community import (
+    DeveloperProfile, AgentSolution, InnovationLab, Hackathon, DeveloperTier, SolutionStatus
+)
+from app.domain.governance import (
+    GovernanceProfile, Proposal, Vote, DaoTreasury, ProposalStatus, VoteType
+)
+from app.services.community_service import (
+    DeveloperEcosystemService, ThirdPartySolutionService, InnovationLabService
+)
+from app.services.governance_service import GovernanceService
+
+class MockQueryResults:
+    def __init__(self, data=None):
+        self._data = data or []
+    def first(self):
+        return self._data[0] if self._data else None
+    def all(self):
+        return self._data
+
+class MockSession:
+    def __init__(self):
+        self.data = {}
+        self.committed = False
+        self.query_results = {}
+        
+    def exec(self, query):
+        # We need to return a query result object
+        if hasattr(query, 'where'):
+            # Very simplistic mock logic
+            return MockQueryResults(self.query_results.get('where', []))
+        return MockQueryResults(self.query_results.get('default', []))
+        
+    def add(self, obj):
+        # Just store it
+        self.data[id(obj)] = obj
+        
+    def commit(self):
+        self.committed = True
+        
+    def refresh(self, obj):
+        pass
+
+@pytest.fixture
+def session():
+    """Mock database session for testing"""
+    return MockSession()
+
+@pytest.mark.asyncio
+async def test_developer_ecosystem(session: MockSession):
+    """Test developer profile creation and reputation tracking"""
+    service = DeveloperEcosystemService(session)
+    
+    # Create profile
+    profile = await service.create_developer_profile(
+        user_id="user_dev_001",
+        username="alice_dev",
+        bio="AI builder",
+        skills=["python", "pytorch"]
+    )
+    
+    assert profile is not None
+    assert profile.username == "alice_dev"
+    assert profile.tier == DeveloperTier.NOVICE
+    assert profile.reputation_score == 0.0
+    
+    # Update reputation
+    # For this to work in the mock, we need to make sure the exec returns the profile we just created
+    session.query_results['where'] = [profile]
+    
+    updated_profile = await service.update_developer_reputation(profile.developer_id, 150.0)
+    assert updated_profile.reputation_score == 150.0
+    assert updated_profile.tier == DeveloperTier.BUILDER
+
+@pytest.mark.asyncio
+async def test_solution_marketplace(session: MockSession):
+    """Test publishing and purchasing third-party solutions"""
+    dev_service = DeveloperEcosystemService(session)
+    solution_service = ThirdPartySolutionService(session)
+    
+    # Create developer
+    dev = await dev_service.create_developer_profile(
+        user_id="user_dev_002",
+        username="bob_dev"
+    )
+    
+    # Publish solution
+    solution_data = {
+        "title": "Quantum Trading Agent",
+        "description": "High frequency trading agent",
+        "price_model": "one_time",
+        "price_amount": 50.0,
+        "capabilities": ["trading", "analysis"]
+    }
+    
+    solution = await solution_service.publish_solution(dev.developer_id, solution_data)
+    assert solution is not None
+    assert solution.status == SolutionStatus.REVIEW
+    assert solution.price_amount == 50.0
+    
+    # Manually publish it for test
+    solution.status = SolutionStatus.PUBLISHED
+    
+    # Purchase setup
+    session.query_results['where'] = [solution]
+    
+    # Purchase
+    result = await solution_service.purchase_solution("user_buyer_001", solution.solution_id)
+    assert result["success"] is True
+    assert "access_token" in result
+
+@pytest.mark.asyncio
+async def test_governance_lifecycle(session: MockSession):
+    """Test the full lifecycle of a DAO proposal"""
+    gov_service = GovernanceService(session)
+    
+    # Setup Treasury
+    treasury = DaoTreasury(treasury_id="main_treasury", total_balance=10000.0)
+    
+    # Create profiles
+    alice = GovernanceProfile(user_id="user_alice", voting_power=500.0)
+    bob = GovernanceProfile(user_id="user_bob", voting_power=300.0)
+    charlie = GovernanceProfile(user_id="user_charlie", voting_power=400.0)
+    
+    # To properly test this with the mock, we'd need to set up very specific sequence of returns
+    # Let's just test proposal creation logic directly
+    now = datetime.utcnow()
+    proposal_data = {
+        "title": "Fund New Agent Framework",
+        "description": "Allocate 1000 AITBC",
+        "category": "funding",
+        "execution_payload": {"amount": 1000.0},
+        "quorum_required": 500.0,
+        "voting_starts": (now - timedelta(minutes=5)).isoformat(),
+        "voting_ends": (now + timedelta(days=1)).isoformat()
+    }
+    
+    session.query_results['where'] = [alice]
+    proposal = await gov_service.create_proposal(alice.profile_id, proposal_data)
+    assert proposal.status == ProposalStatus.ACTIVE
+    assert proposal.title == "Fund New Agent Framework"