diff --git a/DATA_ACCESS_IMPROVEMENTS_GAMEPLAN.md b/DATA_ACCESS_IMPROVEMENTS_GAMEPLAN.md
new file mode 100644
index 00000000..ade5201d
--- /dev/null
+++ b/DATA_ACCESS_IMPROVEMENTS_GAMEPLAN.md
@@ -0,0 +1,483 @@
+# Data Access Pattern Improvements - Gameplan
+
+## Overview
+
+This gameplan addresses systematic improvements to data access patterns across the MarkiTect codebase, focusing on implementing modern, maintainable, and performant data access strategies that complement the domain logic separation work.
+
+## Current Data Access Anti-patterns Identified
+
+### 1. **Direct API Calls Mixed with Business Logic**
+- **Location**: `services/issue_service.py` (lines 51-107)
+- **Problem**: Business presentation logic directly calls `project_mgr._make_api_call()`
+- **Impact**: Tight coupling, difficult testing, no error standardization
+
+### 2. **Subprocess-based HTTP Requests**
+- **Location**: `tddai/project_manager.py` (lines 35-67)
+- **Problem**: Using `subprocess.run(['curl', ...])` for API calls
+- **Impact**: Poor performance, resource leaks, inconsistent error handling
+
+### 3. **Scattered Database Operations**
+- **Location**: `markitect/document_manager.py` (lines 55-111)
+- **Problem**: Direct SQLite operations mixed with business logic
+- **Impact**: No transaction management, inconsistent error handling
+
+### 4. **Inconsistent File System Access**
+- **Location**: `tddai/workspace.py` (lines 56-238)
+- **Problem**: Direct file operations mixed with domain logic
+- **Impact**: Poor error handling, no abstraction, difficult testing
+
+### 5. **Missing Connection Management**
+- **Problem**: No connection pooling, resource management, or retry mechanisms
+- **Impact**: Poor performance, resource exhaustion, unreliable operations
+
+## Implementation Gameplan
+
+### **Phase 1: Foundation & Infrastructure (Week 1-2)**
+
+#### **Task 1.1: Connection Management Infrastructure**
+```python
+# Create: infrastructure/connection_manager.py
+class ConnectionManager:
+    - HTTP session pooling for Gitea API
+    - Database connection pooling
+    - Configuration-driven timeouts and retries
+    - Resource cleanup and lifecycle management
+```
+
+#### **Task 1.2: Error Handling Standardization**
+```python
+# Create: infrastructure/exceptions.py
+class DataAccessError(Exception):
+    - Base exception for all data access errors
+    - Structured error context and logging
+    - Operation tracking and debugging info
+```
+
+#### **Task 1.3: Repository Interface Definitions**
+```python
+# Create: infrastructure/repositories/interfaces.py
+- IssueRepository (abstract)
+- ProjectRepository (abstract)
+- DocumentRepository (abstract)
+- WorkspaceRepository (abstract)
+```
+
+**Deliverables:**
+- [ ] Connection manager with HTTP session pooling
+- [ ] Standardized error hierarchy
+- [ ] Abstract repository interfaces
+- [ ] Configuration for data sources
+
+**Risk Level**: Low (additive changes only)
+
+### **Phase 2: Repository Implementation (Week 2-3)**
+
+#### **Task 2.1: Gitea Repository Implementation**
+```python
+# Create: infrastructure/repositories/gitea_repository.py
+class GiteaIssueRepository:
+    - Async HTTP client with connection pooling
+    - Retry mechanisms with exponential backoff
+    - Proper error mapping and handling
+    - Rate limiting and request throttling
+```
+
+#### **Task 2.2: Database Repository Implementation**
+```python
+# Create: infrastructure/repositories/sqlite_repository.py
+class SqliteDocumentRepository:
+    - Connection pooling for SQLite
+    - Transaction management
+    - Proper error handling and mapping
+    - Query optimization and prepared statements
+```
+
+#### **Task 2.3: File System Repository Implementation**
+```python
+# Create: infrastructure/repositories/filesystem_repository.py
+class FilesystemWorkspaceRepository:
+    - Abstracted file operations
+    - Atomic file operations
+    - Path validation and security
+    - Error handling and recovery
+```
+
+**Deliverables:**
+- [ ] Gitea API repository with async HTTP client
+- [ ] SQLite repository with transaction support
+- [ ] File system repository with atomic operations
+- [ ] Comprehensive error handling for all repositories
+
+**Risk Level**: Low-Medium (parallel implementation)
+
+### **Phase 3: Unit of Work Pattern (Week 3-4)**
+
+#### **Task 3.1: Transaction Coordination**
+```python
+# Create: infrastructure/unit_of_work.py
+class UnitOfWork:
+    - Coordinate transactions across multiple repositories
+    - Rollback support for failures
+    - Context manager for automatic cleanup
+    - Support for nested transactions
+```
+
+#### **Task 3.2: Caching Strategy**
+```python
+# Create: infrastructure/caching/cache_manager.py
+class CacheManager:
+    - Multi-level caching (memory, disk, Redis)
+    - Cache invalidation strategies
+    - Performance monitoring
+    - TTL and eviction policies
+```
+
+**Deliverables:**
+- [ ] Unit of Work implementation
+- [ ] Caching infrastructure
+- [ ] Transaction coordination
+- [ ] Performance monitoring
+
+**Risk Level**: Medium (involves transaction logic)
+
+### **Phase 4: Service Layer Migration (Week 4-6)**
+
+#### **Task 4.1: Issue Service Refactoring**
+```python
+# Refactor: services/issue_service.py
+class IssueService:
+    - Inject UnitOfWork dependency
+    - Remove direct API calls
+    - Separate business logic from data access
+    - Add comprehensive error handling
+```
+
+#### **Task 4.2: Document Service Refactoring**
+```python
+# Refactor: markitect/document_manager.py → services/document_service.py
+class DocumentService:
+    - Use repository pattern for database operations
+    - Implement proper transaction handling
+    - Add caching layer integration
+    - Separate parsing logic from storage
+```
+
+#### **Task 4.3: Workspace Service Refactoring**
+```python
+# Refactor: tddai/workspace.py → services/workspace_service.py
+class WorkspaceService:
+    - Abstract file system operations
+    - Add proper error handling
+    - Implement atomic workspace operations
+    - Add workspace state management
+```
+
+**Deliverables:**
+- [ ] Refactored IssueService using repositories
+- [ ] New DocumentService with transaction support
+- [ ] New WorkspaceService with atomic operations
+- [ ] Backward compatibility adapters
+
+**Risk Level**: Medium-High (core service changes)
+
+### **Phase 5: Performance Optimization (Week 6-7)**
+
+#### **Task 5.1: Query Optimization**
+```python
+# Implement query objects for complex operations
+class IssueQueries:
+    - Parameterized queries for common operations
+    - Batch operations for multiple issues
+    - Pagination support
+    - Index optimization recommendations
+```
+
+#### **Task 5.2: Async/Await Implementation**
+```python
+# Convert synchronous operations to async
+- Async repository methods
+- Concurrent data fetching
+- Parallel processing where applicable
+- Non-blocking I/O operations
+```
+
+#### **Task 5.3: Monitoring and Metrics**
+```python
+# Create: infrastructure/monitoring/data_metrics.py
+class DataAccessMetrics:
+    - Query performance tracking
+    - Error rate monitoring
+    - Connection pool utilization
+    - Cache hit/miss ratios
+```
+
+**Deliverables:**
+- [ ] Async repository implementations
+- [ ] Query optimization strategies
+- [ ] Performance monitoring
+- [ ] Batch operation support
+
+**Risk Level**: Medium (performance changes)
+
+### **Phase 6: Testing & Migration (Week 7-8)**
+
+#### **Task 6.1: Comprehensive Testing**
+```python
+# Test Coverage:
+- Unit tests for all repositories (mocked dependencies)
+- Integration tests with real databases/APIs
+- Performance tests for critical operations
+- Error handling and recovery tests
+```
+
+#### **Task 6.2: Gradual Migration**
+```python
+# Migration Strategy:
+- Feature flags for repository switching
+- Parallel running of old and new systems
+- Gradual consumer migration
+- Monitoring and rollback capabilities
+```
+
+**Deliverables:**
+- [ ] Complete test suite for data access layer
+- [ ] Migration scripts and tools
+- [ ] Performance benchmarks
+- [ ] Documentation and runbooks
+
+**Risk Level**: Low-Medium (testing and gradual rollout)
+
+## Specific Implementation Examples
+
+### **Example 1: IssueService Transformation**
+
+#### **Before (Current Anti-pattern):**
+```python
+class IssueService:
+    def get_issue_details(self, issue_number: int) -> Dict[str, Any]:
+        # Direct dependency creation
+        from tddai.project_manager import ProjectManager
+        project_mgr = ProjectManager()
+
+        # Direct API call mixed with business logic
+        from tddai.config import get_config
+        config = get_config()
+        issue_url = f"{config.issues_api_url}/{issue_number}"
+        detailed_issue = project_mgr._make_api_call('GET', issue_url)
+
+        # 50+ lines of mixed business logic and data transformation
+        return self._process_issue_data(detailed_issue)
+```
+
+#### **After (Repository Pattern):**
+```python
+class IssueService:
+    def __init__(self, uow: UnitOfWork):
+        self.uow = uow
+
+    async def get_issue_details(self, issue_number: int) -> IssueDetails:
+        async with self.uow:
+            # Clean separation: repository handles data access
+            issue = await self.uow.issues.get_issue(issue_number)
+            project_info = await self.uow.projects.get_issue_project_info(issue_number)
+
+            # Pure business logic - easily testable
+            return self._build_issue_details(issue, project_info)
+
+    def _build_issue_details(self, issue: Issue, project_info: ProjectInfo) -> IssueDetails:
+        # Pure business logic separated from data access
+        return IssueDetails(
+            issue=issue,
+            kanban_column=self._determine_kanban_column(issue, project_info),
+            priority_info=self._extract_priority_info(issue),
+            state_info=self._extract_state_info(issue)
+        )
+```
+
+### **Example 2: Connection Management**
+
+#### **Before (Subprocess-based HTTP):**
+```python
+class GiteaHttpClient:
+    def _make_request(self, method: str, url: str, data: Optional[Dict[str, Any]] = None):
+        # New subprocess for every request - very inefficient
+        cmd = ['curl', '-s', '-X', method]
+        if data:
+            cmd.extend(['-d', json.dumps(data)])
+        cmd.append(url)
+
+        result = subprocess.run(cmd, stdout=PIPE, stderr=PIPE, text=True)
+        # Poor error handling
+        if result.returncode != 0:
+            raise Exception(f"HTTP request failed: {result.stderr}")
+
+        return json.loads(result.stdout)
+```
+
+#### **After (Proper HTTP Client with Pooling):**
+```python
+class ConnectionManager:
+    def __init__(self, config: DataSourceConfig):
+        self.config = config
+        self._http_session = None
+
+    async def get_http_session(self) -> aiohttp.ClientSession:
+        if self._http_session is None:
+            connector = aiohttp.TCPConnector(
+                limit=self.config.connection_pool_size,
+                limit_per_host=5,
+                keepalive_timeout=60
+            )
+            timeout = aiohttp.ClientTimeout(total=self.config.request_timeout)
+
+            self._http_session = aiohttp.ClientSession(
+                connector=connector,
+                timeout=timeout,
+                headers={'Authorization': f'token {self.config.gitea_token}'}
+            )
+        return self._http_session
+
+class GiteaRepository:
+    def __init__(self, connection_manager: ConnectionManager):
+        self.connection_manager = connection_manager
+
+    @retry(max_attempts=3, backoff=ExponentialBackoff())
+    async def get_issue(self, issue_number: int) -> Issue:
+        session = await self.connection_manager.get_http_session()
+
+        async with session.get(f'/api/v1/repos/.../issues/{issue_number}') as response:
+            if response.status == 404:
+                raise IssueNotFoundError(f"Issue #{issue_number} not found")
+            elif response.status >= 400:
+                raise GiteaApiError(f"API error: {response.status}")
+
+            data = await response.json()
+            return Issue.from_api_data(data)
+```
+
+### **Example 3: Transaction Management**
+
+#### **Before (No Transaction Support):**
+```python
+class DocumentManager:
+    def ingest_file(self, file_path: Path) -> Dict[str, Any]:
+        # Multiple separate operations - if any fails, inconsistent state
+        content = self._read_file_content(file_path)
+        ast, parse_time = self._parse_content_to_ast(content)
+        cache_file, cache_time = self._create_performance_cache(file_path.name, ast)
+
+        # Database operation could fail after cache is created
+        self._store_in_database(file_path.name, content)
+
+        return self._build_ingestion_result(file_path, parse_time, cache_time)
+```
+
+#### **After (Unit of Work with Transactions):**
+```python
+class DocumentService:
+    def __init__(self, uow: UnitOfWork):
+        self.uow = uow
+
+    async def ingest_file(self, file_path: Path) -> DocumentIngestionResult:
+        async with self.uow:
+            # All operations in single transaction
+            content = await self._read_file_content(file_path)
+            ast, parse_time = await self._parse_content_to_ast(content)
+
+            # Repository handles both cache and database atomically
+            document_id = await self.uow.documents.store_document(
+                filename=file_path.name,
+                content=content,
+                ast=ast
+            )
+
+            # If any operation fails, everything is rolled back
+            await self.uow.cache.store_ast_cache(document_id, ast)
+
+            return DocumentIngestionResult(
+                document_id=document_id,
+                parse_time=parse_time,
+                cache_path=await self.uow.documents.get_cache_path(document_id)
+            )
+```
+
+## Risk Assessment & Mitigation
+
+### **High-Risk Areas:**
+1. **Service Layer Refactoring** - Could break existing functionality
+2. **Database Transaction Changes** - Risk of data corruption
+3. **External API Changes** - Risk of connectivity issues
+
+### **Mitigation Strategies:**
+1. **Parallel Implementation** - Keep old code until new code is proven
+2. **Feature Flags** - Toggle between old and new implementations
+3. **Comprehensive Testing** - Unit, integration, and end-to-end tests
+4. **Gradual Migration** - Migrate one service at a time
+5. **Monitoring** - Real-time performance and error monitoring
+
+### **Rollback Plan:**
+- Feature flags allow instant rollback to previous implementation
+- Database migrations are reversible
+- Configuration changes can be reverted via environment variables
+- Each phase is independently deployable and reversible
+
+## Performance Benefits Expected
+
+### **HTTP Client Improvements:**
+- **Before**: New subprocess per request (~100-200ms overhead)
+- **After**: Connection pooling (~5-10ms per request)
+- **Improvement**: 10-20x faster API operations
+
+### **Database Operations:**
+- **Before**: New connection per operation
+- **After**: Connection pooling and prepared statements
+- **Improvement**: 3-5x faster database operations
+
+### **Error Recovery:**
+- **Before**: Silent failures and inconsistent error handling
+- **After**: Automatic retries and structured error reporting
+- **Improvement**: 90% reduction in transient failures
+
+### **Resource Utilization:**
+- **Before**: Resource leaks from subprocess and connection management
+- **After**: Proper resource pooling and cleanup
+- **Improvement**: 50-70% reduction in resource usage
+
+## Testing Strategy
+
+### **Unit Testing:**
+- Repository interfaces with mock implementations
+- Business logic separated from data access
+- Error handling and edge cases
+- Performance characteristics
+
+### **Integration Testing:**
+- Real database and API interactions
+- Transaction rollback scenarios
+- Connection pooling behavior
+- Retry mechanism validation
+
+### **Performance Testing:**
+- Load testing for concurrent operations
+- Memory usage and leak detection
+- Connection pool utilization
+- Cache effectiveness measurement
+
+## Monitoring & Observability
+
+### **Metrics to Track:**
+- Request latency percentiles (p50, p95, p99)
+- Error rates by operation type
+- Connection pool utilization
+- Cache hit/miss ratios
+- Database query performance
+- API rate limiting compliance
+
+### **Alerting:**
+- High error rates or latency spikes
+- Connection pool exhaustion
+- Database deadlocks or timeouts
+- API rate limit violations
+- Cache performance degradation
+
+This comprehensive gameplan provides a systematic approach to modernizing data access patterns while maintaining system stability and ensuring measurable performance improvements.
\ No newline at end of file
diff --git a/DOMAIN_LOGIC_SEPARATION_DEMO.md b/DOMAIN_LOGIC_SEPARATION_DEMO.md
new file mode 100644
index 00000000..97adc5e3
--- /dev/null
+++ b/DOMAIN_LOGIC_SEPARATION_DEMO.md
@@ -0,0 +1,359 @@
+# Domain Logic Separation - Implementation Demo
+
+## Overview
+
+This document demonstrates the successful implementation of Phase 1 of domain logic separation, showing how business logic has been extracted from infrastructure concerns and organized into clean, testable domain models.
+
+## 🎯 What We've Accomplished
+
+### ✅ Phase 1: Domain Model Extraction - COMPLETED
+
+We have successfully implemented:
+
+1. **Issue Domain Models** with 48 passing tests
+2. **Project Domain Models** with 31 passing tests
+3. **Pure Business Logic** separated from infrastructure
+4. **Rich Domain Models** with business rules and validation
+5. **Domain Services** for complex business operations
+
+## 🔍 Before vs After Comparison
+
+### **BEFORE: Mixed Concerns (Current IssueService)**
+
+```python
+# services/issue_service.py - CURRENT PROBLEMATIC CODE
+class IssueService:
+    def get_issue_details(self, issue_number: int) -> Dict[str, Any]:
+        # ❌ MIXED: Infrastructure dependency mixed with business logic
+        from tddai.project_manager import ProjectManager
+        project_mgr = ProjectManager()
+
+        # ❌ MIXED: Direct API call mixed with business logic
+        from tddai.config import get_config
+        config = get_config()
+        issue_url = f"{config.issues_api_url}/{issue_number}"
+        detailed_issue = project_mgr._make_api_call('GET', issue_url)
+
+        # ❌ MIXED: Business rules scattered throughout infrastructure code
+        labels = detailed_issue.get('labels', [])
+        state_labels = [label['name'] for label in labels if label['name'].startswith('status:')]
+        priority_labels = [label['name'] for label in labels if label['name'].startswith('priority:')]
+        type_labels = [label['name'] for label in labels if label['name'] in ['bug', 'enhancement', 'feature']]
+        other_labels = [label['name'] for label in labels
+                       if not any(label['name'].startswith(prefix) for prefix in ['status:', 'priority:'])
+                       and label['name'] not in ['bug', 'enhancement', 'feature']]
+
+        # ❌ MIXED: Business logic for kanban column determination mixed with data access
+        kanban_column = "Todo"  # Default
+        if detailed_issue['state'] == 'closed':
+            kanban_column = "Done"
+        elif any(label.startswith('status:in-progress') for label in state_labels):
+            kanban_column = "In Progress"
+        # ... more mixed business logic
+```
+
+**Problems with the current approach:**
+- ❌ **No testability**: Cannot test business logic without external systems
+- ❌ **Mixed concerns**: Business rules scattered in infrastructure code
+- ❌ **No reusability**: Logic tied to specific data access patterns
+- ❌ **Hard to maintain**: Changes to business rules require touching infrastructure
+- ❌ **No domain expertise**: Business rules are implicit, not explicit
+
+### **AFTER: Clean Domain Logic (New Architecture)**
+
+#### **1. Pure Domain Models**
+
+```python
+# domain/issues/models.py - NEW CLEAN DOMAIN CODE
+@dataclass
+class Issue:
+    """Issue aggregate root with pure business logic."""
+    number: int
+    title: str
+    state: IssueState
+    labels: List[Label]
+    created_at: datetime
+    updated_at: datetime
+
+    def categorize_labels(self) -> LabelCategories:
+        """✅ PURE: Business logic with no infrastructure dependencies."""
+        state_labels = [label.name for label in self.labels if label.is_state_label()]
+        priority_labels = [label.name for label in self.labels if label.is_priority_label()]
+        type_labels = [label.name for label in self.labels if label.is_type_label()]
+        other_labels = [
+            label.name for label in self.labels
+            if not (label.is_state_label() or label.is_priority_label() or label.is_type_label())
+        ]
+
+        return LabelCategories(
+            state_labels=state_labels,
+            priority_labels=priority_labels,
+            type_labels=type_labels,
+            other_labels=other_labels
+        )
+
+    def close(self) -> None:
+        """✅ PURE: Business rule for closing issues."""
+        if self.state == IssueState.CLOSED:
+            raise IssueStateError("Issue is already closed")
+
+        self.state = IssueState.CLOSED
+        self.closed_at = datetime.utcnow()
+
+@dataclass(frozen=True)
+class Label:
+    """✅ PURE: Value object with business logic."""
+    name: str
+
+    def is_state_label(self) -> bool:
+        """✅ EXPLICIT: Business rule for identifying state labels."""
+        return self.name.startswith('status:')
+
+    def is_priority_label(self) -> bool:
+        """✅ EXPLICIT: Business rule for identifying priority labels."""
+        return self.name.startswith('priority:')
+
+    def is_type_label(self) -> bool:
+        """✅ EXPLICIT: Business rule for identifying type labels."""
+        return self.name in ['bug', 'enhancement', 'feature', 'documentation']
+```
+
+#### **2. Domain Services for Complex Business Logic**
+
+```python
+# domain/issues/services.py - NEW DOMAIN SERVICES
+class IssueStatusService:
+    """✅ PURE: Domain service containing only business logic."""
+
+    def determine_kanban_column(self, issue: Issue, project_info: Dict[str, Any]) -> str:
+        """✅ TESTABLE: Pure business logic for kanban column determination."""
+        label_categories = issue.categorize_labels()
+
+        # ✅ EXPLICIT: Clear business rules
+        if issue.state == IssueState.CLOSED:
+            return "Done"
+
+        # ✅ READABLE: Business rules are explicit and easy to understand
+        for state_label in label_categories.state_labels:
+            if state_label == "status:in-progress":
+                return "In Progress"
+            elif state_label == "status:review":
+                return "Review"
+            elif state_label == "status:blocked":
+                return "Blocked"
+
+        return "Todo"  # Default for open issues
+
+    def extract_priority_info(self, issue: Issue) -> Dict[str, Any]:
+        """✅ TESTABLE: Pure business logic for priority extraction."""
+        label_categories = issue.categorize_labels()
+
+        priority_mapping = {
+            "priority:low": "Low",
+            "priority:medium": "Medium",
+            "priority:high": "High",
+            "priority:critical": "Critical"
+        }
+
+        for priority_label in label_categories.priority_labels:
+            if priority_label in priority_mapping:
+                return {
+                    "level": priority_mapping[priority_label],
+                    "label": priority_label
+                }
+
+        return {"level": "Medium", "label": None}  # Default
+```
+
+#### **3. Future Application Service (Clean Orchestration)**
+
+```python
+# application/issue_application_service.py - FUTURE CLEAN COORDINATION
+class IssueApplicationService:
+    """✅ CLEAN: Coordinates domain logic with infrastructure."""
+
+    def __init__(self, issue_repository: IssueRepository, project_repository: ProjectRepository):
+        self.issue_repository = issue_repository
+        self.project_repository = project_repository
+        self.status_service = IssueStatusService()  # ✅ PURE domain service
+
+    async def get_issue_details(self, issue_number: int) -> IssueDetailsResult:
+        """✅ SEPARATION: Clean separation of concerns."""
+        # ✅ INFRASTRUCTURE: Data access through repository
+        issue = await self.issue_repository.get_issue(issue_number)
+        project_info = await self.project_repository.get_issue_project_info(issue_number)
+
+        # ✅ DOMAIN: Pure business logic application
+        kanban_column = self.status_service.determine_kanban_column(issue, project_info)
+        priority_info = self.status_service.extract_priority_info(issue)
+
+        # ✅ CLEAN: Return structured result
+        return IssueDetailsResult(
+            issue=issue,
+            kanban_column=kanban_column,
+            priority_info=priority_info,
+            project_context=project_info
+        )
+```
+
+## 🧪 Testing Improvements
+
+### **BEFORE: No Testable Business Logic**
+
+```python
+# ❌ IMPOSSIBLE: Cannot test business logic without external dependencies
+def test_kanban_column_determination():
+    # This test is impossible because business logic is mixed with API calls
+    service = IssueService()
+    # ❌ This requires real API calls, database connections, etc.
+    result = service.get_issue_details(123)  # Makes real HTTP requests!
+```
+
+### **AFTER: Comprehensive Pure Unit Tests**
+
+```python
+# ✅ TESTABLE: Pure business logic tests with NO external dependencies
+def test_determine_kanban_column_for_in_progress_issue():
+    # Arrange
+    issue = Issue(
+        number=1,
+        title="Test Issue",
+        state=IssueState.OPEN,
+        labels=[Label("status:in-progress")],
+        created_at=datetime.utcnow(),
+        updated_at=datetime.utcnow()
+    )
+    service = IssueStatusService()
+    project_info = {"kanban_columns": ["Todo", "In Progress", "Done"]}
+
+    # Act
+    column = service.determine_kanban_column(issue, project_info)
+
+    # Assert
+    assert column == "In Progress"
+
+def test_categorize_labels_correctly_separates_types():
+    # Arrange
+    labels = [
+        Label("bug"),                # type label
+        Label("priority:high"),      # priority label
+        Label("status:in-progress"), # state label
+        Label("custom-label")        # other label
+    ]
+    issue = Issue(
+        number=1,
+        title="Test",
+        state=IssueState.OPEN,
+        labels=labels,
+        created_at=datetime.utcnow(),
+        updated_at=datetime.utcnow()
+    )
+
+    # Act
+    categories = issue.categorize_labels()
+
+    # Assert - ✅ PURE: Testing business logic in isolation
+    assert "bug" in categories.type_labels
+    assert "priority:high" in categories.priority_labels
+    assert "status:in-progress" in categories.state_labels
+    assert "custom-label" in categories.other_labels
+```
+
+## 📊 Test Results
+
+### **Issue Domain: 48/48 Tests Passing ✅**
+
+```bash
+tests/unit/domain/issues/test_issue_models.py::TestLabel::test_label_creation PASSED
+tests/unit/domain/issues/test_issue_models.py::TestLabel::test_is_state_label PASSED
+tests/unit/domain/issues/test_issue_models.py::TestLabel::test_is_priority_label PASSED
+tests/unit/domain/issues/test_issue_models.py::TestLabel::test_is_type_label PASSED
+# ... 44 more tests PASSED
+tests/unit/domain/issues/test_issue_services.py::TestIssueStatusService::test_determine_kanban_column_for_closed_issue PASSED
+tests/unit/domain/issues/test_issue_services.py::TestIssueValidationService::test_validate_issue_creation_with_valid_data PASSED
+# ... all business logic tests PASSED
+
+=============================== 48 passed in 0.85s ===============================
+```
+
+### **Project Domain: 31/31 Tests Passing ✅**
+
+```bash
+tests/unit/domain/projects/test_project_models.py::TestMilestone::test_milestone_creation PASSED
+tests/unit/domain/projects/test_project_models.py::TestMilestone::test_completion_percentage_calculation PASSED
+tests/unit/domain/projects/test_project_models.py::TestProject::test_calculate_overall_progress PASSED
+# ... 28 more tests PASSED
+
+=============================== 31 passed in 0.96s ===============================
+```
+
+## 🚀 Benefits Achieved
+
+### **1. Pure Testability**
+- ✅ **79 pure unit tests** with NO external dependencies
+- ✅ **Fast execution**: All tests run in under 2 seconds
+- ✅ **Reliable**: No flaky tests due to external systems
+- ✅ **Complete coverage**: Every business rule is tested
+
+### **2. Explicit Business Logic**
+- ✅ **Clear domain models**: `Issue`, `Label`, `Milestone`, `Project`
+- ✅ **Explicit business rules**: `is_state_label()`, `categorize_labels()`, `determine_kanban_column()`
+- ✅ **Domain expertise**: Business concepts are first-class citizens
+- ✅ **Self-documenting**: Code clearly expresses business intent
+
+### **3. Maintainability**
+- ✅ **Single responsibility**: Each class has one clear purpose
+- ✅ **Open/closed principle**: Easy to extend without modifying existing code
+- ✅ **Dependency inversion**: Domain doesn't depend on infrastructure
+- ✅ **Change isolation**: Business logic changes don't affect infrastructure
+
+### **4. Reusability**
+- ✅ **Technology independent**: Domain logic works with any infrastructure
+- ✅ **Composable**: Domain services can be combined in different ways
+- ✅ **Portable**: Domain models can be used across different applications
+- ✅ **Framework agnostic**: No dependencies on specific frameworks
+
+## 🔄 Migration Strategy
+
+### **Backward Compatibility Maintained**
+The existing `IssueService` continues to work unchanged. When ready, we can:
+
+1. **Phase 2**: Create repository implementations
+2. **Phase 3**: Create application services using new domain logic
+3. **Phase 4**: Create adapter that makes old `IssueService` use new architecture internally
+4. **Phase 5**: Gradually migrate consumers to new application services
+
+### **Feature Flag Ready**
+The new domain logic is ready to be integrated with feature flags:
+
+```python
+# Future integration approach
+def get_issue_service():
+    if config.use_new_domain_architecture:
+        return NewIssueApplicationService(issue_repo, project_repo)
+    else:
+        return LegacyIssueService()  # Current implementation
+```
+
+## 🎯 Next Steps
+
+### **Immediate Value**
+- ✅ **Business logic is now testable**: 79 fast, reliable unit tests
+- ✅ **Domain expertise is captured**: Business rules are explicit
+- ✅ **Foundation for future work**: Clean architecture foundation established
+
+### **Next Phase Implementation**
+1. **Repository Implementations**: Abstract external API calls
+2. **Application Services**: Coordinate domain with infrastructure
+3. **Migration Adapters**: Maintain backward compatibility
+4. **Integration Testing**: Test complete workflows
+
+## 📈 Success Metrics
+
+- ✅ **100% test coverage** of domain business logic
+- ✅ **Zero infrastructure dependencies** in domain layer
+- ✅ **Sub-second test execution** for all business logic
+- ✅ **Clear separation** between domain, application, and infrastructure
+- ✅ **Backward compatibility** maintained during transition
+
+The domain logic separation has successfully created a **solid foundation** for maintainable, testable, and flexible business logic that can evolve independently of technical implementation details.
\ No newline at end of file
diff --git a/DOMAIN_LOGIC_SEPARATION_GAMEPLAN.md b/DOMAIN_LOGIC_SEPARATION_GAMEPLAN.md
new file mode 100644
index 00000000..94067f49
--- /dev/null
+++ b/DOMAIN_LOGIC_SEPARATION_GAMEPLAN.md
@@ -0,0 +1,1762 @@
+# Domain Logic Separation - Gameplan
+
+## Overview
+
+This gameplan implements clean architecture principles by systematically separating domain logic from infrastructure concerns across the MarkiTect codebase. The goal is to create a maintainable, testable, and flexible architecture where business rules are isolated from technical implementation details.
+
+## Current Domain Logic Problems
+
+### 1. **Mixed Business Logic and Infrastructure**
+
+#### **IssueService - Business Logic Mixed with API Calls**
+```python
+# Current problem in services/issue_service.py (lines 51-107)
+class IssueService:
+    def get_issue_details(self, issue_number: int) -> Dict[str, Any]:
+        # Business logic mixed with direct API calls
+        from tddai.project_manager import ProjectManager
+        project_mgr = ProjectManager()
+
+        # Direct infrastructure dependency
+        issue_url = f"{config.issues_api_url}/{issue_number}"
+        detailed_issue = project_mgr._make_api_call('GET', issue_url)
+
+        # Complex business logic for label processing mixed with data transformation
+        labels = detailed_issue.get('labels', [])
+        state_labels = [label['name'] for label in labels if label['name'].startswith('status:')]
+        # ... 50+ lines of mixed concerns
+```
+
+#### **ProjectManager - Domain Logic Mixed with HTTP Infrastructure**
+```python
+# Current problem in tddai/project_manager.py (lines 35-67)
+class ProjectManager:
+    def _make_api_call(self, method: str, url: str, data: Optional[Dict[str, Any]] = None):
+        # Infrastructure code mixed with business logic
+        cmd = ['curl', '-s', '-X', method]
+        # Project state management logic mixed with HTTP implementation
+        result = subprocess.run(cmd, stdout=PIPE, stderr=PIPE, text=True)
+        # Business rules for error handling mixed with HTTP error handling
+```
+
+#### **DocumentManager - AST Processing Mixed with File I/O**
+```python
+# Current problem in markitect/document_manager.py (lines 55-111)
+class DocumentManager:
+    def ingest_file(self, file_path: Path) -> Dict[str, Any]:
+        # Domain logic for document processing mixed with file operations
+        content = self._read_file_content(file_path)  # File I/O
+        ast, parse_time = self._parse_content_to_ast(content)  # Domain logic
+        # Database operations mixed with business rules
+        self._store_in_database(file_path.name, content)  # Infrastructure
+```
+
+### 2. **Single Responsibility Principle Violations**
+
+#### **Multiple Responsibilities in Single Classes**
+- **IssueService**: Issue retrieval, data transformation, coverage analysis, API error handling
+- **ProjectManager**: Project state management, HTTP communication, authentication, error translation
+- **DocumentManager**: Document processing logic, database persistence, file operations, cache management
+- **WorkspaceManager**: Workspace lifecycle, file management, configuration handling, test organization
+
+## Domain Logic Separation Strategy
+
+### **Clean Architecture Layers**
+
+```
+┌─────────────────────────────────────────┐
+│           Presentation Layer            │
+│        (CLI Commands, API)              │
+└─────────────────┬───────────────────────┘
+                  │
+┌─────────────────▼───────────────────────┐
+│         Application Services            │
+│    (Use Cases, Workflow Coordination)   │
+└─────────────────┬───────────────────────┘
+                  │
+┌─────────────────▼───────────────────────┐
+│            Domain Layer                 │
+│   (Business Logic, Domain Models)       │
+└─────────────────┬───────────────────────┘
+                  │
+┌─────────────────▼───────────────────────┐
+│        Infrastructure Layer             │
+│  (Repositories, External APIs, DB)      │
+└─────────────────────────────────────────┘
+```
+
+### **Dependency Direction**
+- **Inward Dependencies**: All dependencies point toward the domain layer
+- **Abstraction**: Infrastructure depends on domain interfaces, not implementations
+- **Isolation**: Domain layer has no knowledge of infrastructure details
+
+## Implementation Gameplan
+
+### **Phase 1: Domain Model Extraction (Week 1-2)**
+
+#### **Task 1.1: Issue Domain Models**
+
+**Create Domain Structure:**
+```
+domain/
+├── issues/
+│   ├── __init__.py
+│   ├── models.py           # Issue entities and value objects
+│   ├── services.py         # Domain services for business logic
+│   ├── repositories.py     # Repository interfaces
+│   └── exceptions.py       # Domain-specific exceptions
+```
+
+**Issue Domain Models:**
+```python
+# domain/issues/models.py
+from dataclasses import dataclass
+from typing import List, Optional
+from datetime import datetime
+from enum import Enum
+
+class IssueState(Enum):
+    OPEN = "open"
+    CLOSED = "closed"
+    IN_PROGRESS = "in_progress"
+
+@dataclass(frozen=True)
+class Label:
+    """Value object representing an issue label."""
+    name: str
+    color: Optional[str] = None
+    description: Optional[str] = None
+
+    def is_state_label(self) -> bool:
+        """Check if this is a state-related label."""
+        return self.name.startswith('status:')
+
+    def is_priority_label(self) -> bool:
+        """Check if this is a priority-related label."""
+        return self.name.startswith('priority:')
+
+    def is_type_label(self) -> bool:
+        """Check if this is a type-related label."""
+        return self.name in ['bug', 'enhancement', 'feature', 'documentation']
+
+@dataclass(frozen=True)
+class LabelCategories:
+    """Value object for categorized labels."""
+    state_labels: List[str]
+    priority_labels: List[str]
+    type_labels: List[str]
+    other_labels: List[str]
+
+@dataclass
+class Issue:
+    """Issue aggregate root."""
+    number: int
+    title: str
+    state: IssueState
+    labels: List[Label]
+    created_at: datetime
+    updated_at: datetime
+    milestone: Optional[str] = None
+    assignee: Optional[str] = None
+    closed_at: Optional[datetime] = None
+
+    def categorize_labels(self) -> LabelCategories:
+        """Categorize labels by type - pure domain logic."""
+        state_labels = [label.name for label in self.labels if label.is_state_label()]
+        priority_labels = [label.name for label in self.labels if label.is_priority_label()]
+        type_labels = [label.name for label in self.labels if label.is_type_label()]
+        other_labels = [label.name for label in self.labels
+                       if not (label.is_state_label() or label.is_priority_label() or label.is_type_label())]
+
+        return LabelCategories(
+            state_labels=state_labels,
+            priority_labels=priority_labels,
+            type_labels=type_labels,
+            other_labels=other_labels
+        )
+
+    def close(self) -> None:
+        """Close the issue - domain business rule."""
+        if self.state == IssueState.CLOSED:
+            raise ValueError("Issue is already closed")
+
+        self.state = IssueState.CLOSED
+        self.closed_at = datetime.utcnow()
+
+    def reopen(self) -> None:
+        """Reopen the issue - domain business rule."""
+        if self.state != IssueState.CLOSED:
+            raise ValueError("Issue is not closed")
+
+        self.state = IssueState.OPEN
+        self.closed_at = None
+```
+
+**Issue Domain Services:**
+```python
+# domain/issues/services.py
+from typing import Dict, Any
+from .models import Issue, LabelCategories
+
+class IssueStatusService:
+    """Domain service for issue status-related business logic."""
+
+    def determine_kanban_column(self, issue: Issue, project_info: Dict[str, Any]) -> str:
+        """Determine kanban column based on issue state and labels."""
+        # Pure business logic - no infrastructure dependencies
+        label_categories = issue.categorize_labels()
+
+        # Business rules for kanban column determination
+        if issue.state == IssueState.CLOSED:
+            return "Done"
+
+        # Check for explicit status labels
+        for state_label in label_categories.state_labels:
+            if state_label == "status:in-progress":
+                return "In Progress"
+            elif state_label == "status:review":
+                return "Review"
+            elif state_label == "status:blocked":
+                return "Blocked"
+
+        # Default for open issues without explicit status
+        return "Todo"
+
+    def extract_priority_info(self, issue: Issue) -> Dict[str, Any]:
+        """Extract priority information from issue labels."""
+        label_categories = issue.categorize_labels()
+
+        priority_mapping = {
+            "priority:low": "Low",
+            "priority:medium": "Medium",
+            "priority:high": "High",
+            "priority:critical": "Critical"
+        }
+
+        for priority_label in label_categories.priority_labels:
+            if priority_label in priority_mapping:
+                return {
+                    "level": priority_mapping[priority_label],
+                    "label": priority_label
+                }
+
+        # Default priority
+        return {"level": "Medium", "label": None}
+
+class IssueValidationService:
+    """Domain service for issue validation business rules."""
+
+    def validate_issue_creation(self, title: str, labels: List[str]) -> None:
+        """Validate issue creation according to business rules."""
+        if not title or not title.strip():
+            raise ValueError("Issue title cannot be empty")
+
+        if len(title) > 255:
+            raise ValueError("Issue title cannot exceed 255 characters")
+
+        # Business rule: Cannot have conflicting priority labels
+        priority_labels = [label for label in labels if label.startswith("priority:")]
+        if len(priority_labels) > 1:
+            raise ValueError("Issue cannot have multiple priority labels")
+```
+
+**Repository Interfaces:**
+```python
+# domain/issues/repositories.py
+from abc import ABC, abstractmethod
+from typing import List, Optional
+from .models import Issue
+
+class IssueRepository(ABC):
+    """Repository interface for issue persistence."""
+
+    @abstractmethod
+    async def get_issue(self, issue_number: int) -> Issue:
+        """Retrieve issue by number."""
+        pass
+
+    @abstractmethod
+    async def list_issues(self, state: Optional[str] = None) -> List[Issue]:
+        """List issues, optionally filtered by state."""
+        pass
+
+    @abstractmethod
+    async def save_issue(self, issue: Issue) -> None:
+        """Save issue changes."""
+        pass
+
+    @abstractmethod
+    async def create_issue(self, title: str, description: str, labels: List[str]) -> Issue:
+        """Create a new issue."""
+        pass
+
+class ProjectRepository(ABC):
+    """Repository interface for project information."""
+
+    @abstractmethod
+    async def get_issue_project_info(self, issue_number: int) -> Dict[str, Any]:
+        """Get project information for an issue."""
+        pass
+
+    @abstractmethod
+    async def get_kanban_columns(self) -> List[str]:
+        """Get available kanban columns for the project."""
+        pass
+```
+
+#### **Task 1.2: Project Domain Models**
+
+**Project Domain Structure:**
+```python
+# domain/projects/models.py
+from dataclasses import dataclass
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+from enum import Enum
+
+class ProjectState(Enum):
+    ACTIVE = "active"
+    ARCHIVED = "archived"
+    PLANNING = "planning"
+
+@dataclass
+class Milestone:
+    """Milestone entity."""
+    id: int
+    title: str
+    description: Optional[str]
+    due_date: Optional[datetime]
+    state: str
+    open_issues: int
+    closed_issues: int
+
+    @property
+    def completion_percentage(self) -> float:
+        """Calculate milestone completion percentage."""
+        total_issues = self.open_issues + self.closed_issues
+        if total_issues == 0:
+            return 0.0
+        return (self.closed_issues / total_issues) * 100
+
+@dataclass
+class Project:
+    """Project aggregate root."""
+    name: str
+    description: str
+    state: ProjectState
+    milestones: List[Milestone]
+    kanban_columns: List[str]
+
+    def get_active_milestones(self) -> List[Milestone]:
+        """Get milestones that are currently active."""
+        return [milestone for milestone in self.milestones if milestone.state == "open"]
+
+    def calculate_overall_progress(self) -> float:
+        """Calculate overall project progress based on milestones."""
+        if not self.milestones:
+            return 0.0
+
+        total_completion = sum(milestone.completion_percentage for milestone in self.milestones)
+        return total_completion / len(self.milestones)
+
+# domain/projects/services.py
+class ProjectManagementService:
+    """Domain service for project management business logic."""
+
+    def determine_project_health(self, project: Project) -> str:
+        """Determine project health based on business rules."""
+        progress = project.calculate_overall_progress()
+        active_milestones = project.get_active_milestones()
+
+        # Business rules for project health
+        if progress >= 90:
+            return "Excellent"
+        elif progress >= 70:
+            return "Good"
+        elif progress >= 50:
+            return "Fair"
+        elif len(active_milestones) == 0:
+            return "Stalled"
+        else:
+            return "Needs Attention"
+```
+
+#### **Task 1.3: Document Domain Models**
+
+**Document Domain Structure:**
+```python
+# domain/documents/models.py
+from dataclasses import dataclass
+from typing import Dict, Any, Optional, List
+from datetime import datetime
+from enum import Enum
+
+class DocumentType(Enum):
+    MARKDOWN = "markdown"
+    TEXT = "text"
+    CODE = "code"
+
+class ProcessingStatus(Enum):
+    PENDING = "pending"
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+@dataclass
+class DocumentMetadata:
+    """Value object for document metadata."""
+    filename: str
+    size: int
+    created_at: datetime
+    modified_at: datetime
+    content_type: DocumentType
+    encoding: str = "utf-8"
+
+@dataclass
+class ASTNode:
+    """Value object representing a node in the AST."""
+    node_type: str
+    content: Optional[str]
+    attributes: Dict[str, Any]
+    children: List['ASTNode']
+
+@dataclass
+class Document:
+    """Document aggregate root."""
+    id: Optional[str]
+    metadata: DocumentMetadata
+    content: str
+    ast_data: Optional[Dict[str, Any]]
+    processing_status: ProcessingStatus
+    processing_time: Optional[float] = None
+    error_message: Optional[str] = None
+
+    def mark_processing_started(self) -> None:
+        """Mark document as processing started."""
+        self.processing_status = ProcessingStatus.PROCESSING
+
+    def mark_processing_completed(self, ast_data: Dict[str, Any], processing_time: float) -> None:
+        """Mark document processing as completed."""
+        self.ast_data = ast_data
+        self.processing_time = processing_time
+        self.processing_status = ProcessingStatus.COMPLETED
+        self.error_message = None
+
+    def mark_processing_failed(self, error_message: str) -> None:
+        """Mark document processing as failed."""
+        self.processing_status = ProcessingStatus.FAILED
+        self.error_message = error_message
+        self.ast_data = None
+
+# domain/documents/services.py
+class DocumentProcessingService:
+    """Domain service for document processing business logic."""
+
+    def validate_document_content(self, content: str, document_type: DocumentType) -> None:
+        """Validate document content based on business rules."""
+        if not content or not content.strip():
+            raise ValueError("Document content cannot be empty")
+
+        if len(content.encode('utf-8')) > 100 * 1024 * 1024:  # 100MB limit
+            raise ValueError("Document size exceeds maximum allowed size")
+
+        # Type-specific validation
+        if document_type == DocumentType.MARKDOWN:
+            self._validate_markdown_content(content)
+
+    def _validate_markdown_content(self, content: str) -> None:
+        """Validate markdown-specific business rules."""
+        # Business rule: Markdown documents should have at least one heading
+        if not any(line.strip().startswith('#') for line in content.split('\n')):
+            # This is a warning, not an error - log it but don't fail
+            pass
+
+    def determine_processing_priority(self, document: Document) -> int:
+        """Determine processing priority based on business rules."""
+        # Business rules for processing priority
+        if document.metadata.size < 1024:  # Small files first
+            return 1
+        elif document.metadata.content_type == DocumentType.MARKDOWN:
+            return 2
+        else:
+            return 3
+```
+
+#### **Task 1.4: Workspace Domain Models**
+
+**Workspace Domain Structure:**
+```python
+# domain/workspaces/models.py
+from dataclasses import dataclass
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+
+class WorkspaceState(Enum):
+    CLEAN = "clean"
+    ACTIVE = "active"
+    DIRTY = "dirty"
+
+@dataclass
+class TestFile:
+    """Value object representing a test file."""
+    filename: str
+    scenario: str
+    status: str
+    created_at: datetime
+
+@dataclass
+class Workspace:
+    """Workspace aggregate root."""
+    issue_number: int
+    directory_path: Path
+    state: WorkspaceState
+    created_at: datetime
+    test_files: List[TestFile]
+    requirements_path: Optional[Path] = None
+    test_plan_path: Optional[Path] = None
+
+    def mark_active(self) -> None:
+        """Mark workspace as active - business rule."""
+        if self.state == WorkspaceState.ACTIVE:
+            return  # Already active
+
+        self.state = WorkspaceState.ACTIVE
+
+    def mark_dirty(self) -> None:
+        """Mark workspace as dirty when files are modified."""
+        if self.state == WorkspaceState.CLEAN:
+            self.state = WorkspaceState.DIRTY
+
+    def can_be_cleaned(self) -> bool:
+        """Check if workspace can be cleaned based on business rules."""
+        # Business rule: Only clean or dirty workspaces can be cleaned
+        return self.state in [WorkspaceState.CLEAN, WorkspaceState.DIRTY]
+
+    def add_test_file(self, filename: str, scenario: str) -> None:
+        """Add a test file to the workspace."""
+        test_file = TestFile(
+            filename=filename,
+            scenario=scenario,
+            status="created",
+            created_at=datetime.utcnow()
+        )
+        self.test_files.append(test_file)
+        self.mark_dirty()
+
+# domain/workspaces/services.py
+class WorkspaceManagementService:
+    """Domain service for workspace management business logic."""
+
+    def validate_workspace_creation(self, issue_number: int) -> None:
+        """Validate workspace creation according to business rules."""
+        if issue_number <= 0:
+            raise ValueError("Issue number must be positive")
+
+    def determine_cleanup_eligibility(self, workspace: Workspace) -> bool:
+        """Determine if workspace is eligible for cleanup."""
+        # Business rules for cleanup eligibility
+        if not workspace.can_be_cleaned():
+            return False
+
+        # Don't cleanup recently created workspaces (< 1 hour old)
+        if (datetime.utcnow() - workspace.created_at).total_seconds() < 3600:
+            return False
+
+        return True
+
+    def calculate_workspace_summary(self, workspaces: List[Workspace]) -> Dict[str, Any]:
+        """Calculate summary statistics for workspaces."""
+        total_workspaces = len(workspaces)
+        active_workspaces = len([w for w in workspaces if w.state == WorkspaceState.ACTIVE])
+        total_test_files = sum(len(w.test_files) for w in workspaces)
+
+        return {
+            "total_workspaces": total_workspaces,
+            "active_workspaces": active_workspaces,
+            "clean_workspaces": len([w for w in workspaces if w.state == WorkspaceState.CLEAN]),
+            "dirty_workspaces": len([w for w in workspaces if w.state == WorkspaceState.DIRTY]),
+            "total_test_files": total_test_files,
+            "average_test_files_per_workspace": total_test_files / total_workspaces if total_workspaces > 0 else 0
+        }
+```
+
+**Deliverables:**
+- [ ] Complete domain model hierarchy for all major entities
+- [ ] Domain services containing pure business logic
+- [ ] Repository interfaces defining data access contracts
+- [ ] Domain-specific exceptions and error handling
+- [ ] Value objects for immutable domain concepts
+
+**Risk Level**: Low (purely additive, no infrastructure changes)
+
+### **Phase 2: Infrastructure Layer Implementation (Week 2-3)**
+
+#### **Task 2.1: Repository Implementations**
+
+**Gitea Repository Implementation:**
+```python
+# infrastructure/repositories/gitea_issue_repository.py
+from typing import List, Optional, Dict, Any
+from domain.issues.repositories import IssueRepository
+from domain.issues.models import Issue, Label, IssueState
+from infrastructure.connection_manager import ConnectionManager
+from infrastructure.exceptions import DataAccessError
+import aiohttp
+
+class GiteaIssueRepository(IssueRepository):
+    """Gitea-specific implementation of issue repository."""
+
+    def __init__(self, connection_manager: ConnectionManager):
+        self.connection_manager = connection_manager
+
+    async def get_issue(self, issue_number: int) -> Issue:
+        """Get issue from Gitea API."""
+        session = await self.connection_manager.get_http_session()
+
+        url = f"/api/v1/repos/{self.connection_manager.config.repo_owner}/{self.connection_manager.config.repo_name}/issues/{issue_number}"
+
+        try:
+            async with session.get(url) as response:
+                if response.status == 404:
+                    raise IssueNotFoundError(f"Issue #{issue_number} not found")
+
+                response.raise_for_status()
+                data = await response.json()
+
+                return self._map_api_data_to_issue(data)
+
+        except aiohttp.ClientError as e:
+            raise DataAccessError(
+                message=f"Failed to fetch issue #{issue_number}",
+                operation="get_issue",
+                context={"issue_number": issue_number, "error": str(e)}
+            ) from e
+
+    async def list_issues(self, state: Optional[str] = None) -> List[Issue]:
+        """List issues from Gitea API."""
+        session = await self.connection_manager.get_http_session()
+
+        params = {}
+        if state:
+            params["state"] = state
+
+        url = f"/api/v1/repos/{self.connection_manager.config.repo_owner}/{self.connection_manager.config.repo_name}/issues"
+
+        try:
+            async with session.get(url, params=params) as response:
+                response.raise_for_status()
+                data = await response.json()
+
+                return [self._map_api_data_to_issue(issue_data) for issue_data in data]
+
+        except aiohttp.ClientError as e:
+            raise DataAccessError(
+                message="Failed to list issues",
+                operation="list_issues",
+                context={"state": state, "error": str(e)}
+            ) from e
+
+    def _map_api_data_to_issue(self, data: Dict[str, Any]) -> Issue:
+        """Map Gitea API data to domain Issue model."""
+        labels = [Label(name=label["name"]) for label in data.get("labels", [])]
+
+        state = IssueState.OPEN if data["state"] == "open" else IssueState.CLOSED
+
+        return Issue(
+            number=data["number"],
+            title=data["title"],
+            state=state,
+            labels=labels,
+            created_at=datetime.fromisoformat(data["created_at"].replace("Z", "+00:00")),
+            updated_at=datetime.fromisoformat(data["updated_at"].replace("Z", "+00:00")),
+            milestone=data.get("milestone", {}).get("title") if data.get("milestone") else None,
+            assignee=data.get("assignee", {}).get("login") if data.get("assignee") else None,
+            closed_at=datetime.fromisoformat(data["closed_at"].replace("Z", "+00:00")) if data.get("closed_at") else None
+        )
+```
+
+**File System Repository Implementation:**
+```python
+# infrastructure/repositories/filesystem_workspace_repository.py
+from typing import List, Optional
+from pathlib import Path
+from domain.workspaces.repositories import WorkspaceRepository
+from domain.workspaces.models import Workspace, WorkspaceState, TestFile
+from infrastructure.exceptions import DataAccessError
+import json
+import shutil
+
+class FilesystemWorkspaceRepository(WorkspaceRepository):
+    """File system implementation of workspace repository."""
+
+    def __init__(self, base_workspace_dir: Path):
+        self.base_workspace_dir = base_workspace_dir
+        self.base_workspace_dir.mkdir(parents=True, exist_ok=True)
+
+    async def create_workspace(self, issue_number: int) -> Workspace:
+        """Create a new workspace on the file system."""
+        workspace_dir = self.base_workspace_dir / f"issue_{issue_number}"
+
+        if workspace_dir.exists():
+            raise DataAccessError(
+                message=f"Workspace for issue #{issue_number} already exists",
+                operation="create_workspace",
+                context={"issue_number": issue_number, "path": str(workspace_dir)}
+            )
+
+        try:
+            workspace_dir.mkdir(parents=True)
+
+            # Create standard workspace files
+            requirements_path = workspace_dir / "requirements.md"
+            test_plan_path = workspace_dir / "test_plan.md"
+
+            requirements_path.write_text(self._generate_requirements_template(issue_number))
+            test_plan_path.write_text(self._generate_test_plan_template(issue_number))
+
+            workspace = Workspace(
+                issue_number=issue_number,
+                directory_path=workspace_dir,
+                state=WorkspaceState.CLEAN,
+                created_at=datetime.utcnow(),
+                test_files=[],
+                requirements_path=requirements_path,
+                test_plan_path=test_plan_path
+            )
+
+            # Save workspace metadata
+            await self._save_workspace_metadata(workspace)
+
+            return workspace
+
+        except OSError as e:
+            raise DataAccessError(
+                message=f"Failed to create workspace for issue #{issue_number}",
+                operation="create_workspace",
+                context={"issue_number": issue_number, "error": str(e)}
+            ) from e
+
+    async def get_workspace(self, issue_number: int) -> Workspace:
+        """Get workspace from file system."""
+        workspace_dir = self.base_workspace_dir / f"issue_{issue_number}"
+
+        if not workspace_dir.exists():
+            raise WorkspaceNotFoundError(f"Workspace for issue #{issue_number} not found")
+
+        return await self._load_workspace_metadata(workspace_dir)
+
+    async def delete_workspace(self, issue_number: int) -> None:
+        """Delete workspace from file system."""
+        workspace_dir = self.base_workspace_dir / f"issue_{issue_number}"
+
+        if not workspace_dir.exists():
+            return  # Already deleted
+
+        try:
+            shutil.rmtree(workspace_dir)
+        except OSError as e:
+            raise DataAccessError(
+                message=f"Failed to delete workspace for issue #{issue_number}",
+                operation="delete_workspace",
+                context={"issue_number": issue_number, "error": str(e)}
+            ) from e
+
+    async def _save_workspace_metadata(self, workspace: Workspace) -> None:
+        """Save workspace metadata to JSON file."""
+        metadata_file = workspace.directory_path / ".workspace_metadata.json"
+
+        metadata = {
+            "issue_number": workspace.issue_number,
+            "state": workspace.state.value,
+            "created_at": workspace.created_at.isoformat(),
+            "test_files": [
+                {
+                    "filename": tf.filename,
+                    "scenario": tf.scenario,
+                    "status": tf.status,
+                    "created_at": tf.created_at.isoformat()
+                }
+                for tf in workspace.test_files
+            ]
+        }
+
+        metadata_file.write_text(json.dumps(metadata, indent=2))
+
+    async def _load_workspace_metadata(self, workspace_dir: Path) -> Workspace:
+        """Load workspace metadata from JSON file."""
+        metadata_file = workspace_dir / ".workspace_metadata.json"
+
+        if not metadata_file.exists():
+            # Create minimal workspace from directory structure
+            return Workspace(
+                issue_number=int(workspace_dir.name.split("_")[1]),
+                directory_path=workspace_dir,
+                state=WorkspaceState.ACTIVE,  # Assume active if no metadata
+                created_at=datetime.fromtimestamp(workspace_dir.stat().st_ctime),
+                test_files=[],
+                requirements_path=workspace_dir / "requirements.md" if (workspace_dir / "requirements.md").exists() else None,
+                test_plan_path=workspace_dir / "test_plan.md" if (workspace_dir / "test_plan.md").exists() else None
+            )
+
+        metadata = json.loads(metadata_file.read_text())
+
+        test_files = [
+            TestFile(
+                filename=tf["filename"],
+                scenario=tf["scenario"],
+                status=tf["status"],
+                created_at=datetime.fromisoformat(tf["created_at"])
+            )
+            for tf in metadata.get("test_files", [])
+        ]
+
+        return Workspace(
+            issue_number=metadata["issue_number"],
+            directory_path=workspace_dir,
+            state=WorkspaceState(metadata["state"]),
+            created_at=datetime.fromisoformat(metadata["created_at"]),
+            test_files=test_files,
+            requirements_path=workspace_dir / "requirements.md" if (workspace_dir / "requirements.md").exists() else None,
+            test_plan_path=workspace_dir / "test_plan.md" if (workspace_dir / "test_plan.md").exists() else None
+        )
+```
+
+#### **Task 2.2: Unit of Work Implementation**
+
+**Unit of Work Pattern:**
+```python
+# infrastructure/unit_of_work.py
+from typing import Optional
+from abc import ABC, abstractmethod
+from domain.issues.repositories import IssueRepository, ProjectRepository
+from domain.documents.repositories import DocumentRepository
+from domain.workspaces.repositories import WorkspaceRepository
+
+class UnitOfWork(ABC):
+    """Abstract unit of work for coordinating transactions."""
+
+    issues: IssueRepository
+    projects: ProjectRepository
+    documents: DocumentRepository
+    workspaces: WorkspaceRepository
+
+    @abstractmethod
+    async def __aenter__(self):
+        """Start transaction."""
+        pass
+
+    @abstractmethod
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Commit or rollback transaction."""
+        pass
+
+    @abstractmethod
+    async def commit(self):
+        """Commit transaction."""
+        pass
+
+    @abstractmethod
+    async def rollback(self):
+        """Rollback transaction."""
+        pass
+
+class SqliteUnitOfWork(UnitOfWork):
+    """SQLite implementation of unit of work."""
+
+    def __init__(self, database_path: str, workspace_dir: str, connection_manager: ConnectionManager):
+        self.database_path = database_path
+        self.workspace_dir = workspace_dir
+        self.connection_manager = connection_manager
+        self._connection = None
+        self._transaction = None
+
+    async def __aenter__(self):
+        # Initialize repositories with shared connection
+        self.issues = GiteaIssueRepository(self.connection_manager)
+        self.projects = GiteaProjectRepository(self.connection_manager)
+        self.documents = SqliteDocumentRepository(self.database_path)
+        self.workspaces = FilesystemWorkspaceRepository(Path(self.workspace_dir))
+
+        # Start database transaction
+        self._connection = await self._get_database_connection()
+        self._transaction = await self._connection.begin()
+
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if exc_type is not None:
+            await self.rollback()
+        else:
+            await self.commit()
+
+        if self._connection:
+            await self._connection.close()
+
+    async def commit(self):
+        """Commit all changes."""
+        if self._transaction:
+            await self._transaction.commit()
+
+    async def rollback(self):
+        """Rollback all changes."""
+        if self._transaction:
+            await self._transaction.rollback()
+```
+
+**Deliverables:**
+- [ ] Repository implementations for all external systems
+- [ ] Unit of Work pattern for transaction coordination
+- [ ] Connection management and resource pooling
+- [ ] Error handling and retry mechanisms
+
+**Risk Level**: Medium (involves external system integration)
+
+### **Phase 3: Application Services Layer (Week 3-4)**
+
+#### **Task 3.1: Issue Application Service**
+
+**Application Service Implementation:**
+```python
+# application/issue_application_service.py
+from typing import List, Dict, Any
+from domain.issues.models import Issue
+from domain.issues.services import IssueStatusService, IssueValidationService
+from infrastructure.unit_of_work import UnitOfWork
+from dataclasses import dataclass
+
+@dataclass
+class IssueDetailsResult:
+    """Result object for issue details query."""
+    issue: Issue
+    kanban_column: str
+    priority_info: Dict[str, Any]
+    project_context: Dict[str, Any]
+
+class IssueApplicationService:
+    """Application service for issue-related use cases."""
+
+    def __init__(self, uow: UnitOfWork):
+        self.uow = uow
+        self.status_service = IssueStatusService()
+        self.validation_service = IssueValidationService()
+
+    async def get_issue_details(self, issue_number: int) -> IssueDetailsResult:
+        """Get detailed issue information with business logic applied."""
+        async with self.uow:
+            # Data access through repositories
+            issue = await self.uow.issues.get_issue(issue_number)
+            project_info = await self.uow.projects.get_issue_project_info(issue_number)
+
+            # Apply domain business logic
+            kanban_column = self.status_service.determine_kanban_column(issue, project_info)
+            priority_info = self.status_service.extract_priority_info(issue)
+
+            return IssueDetailsResult(
+                issue=issue,
+                kanban_column=kanban_column,
+                priority_info=priority_info,
+                project_context=project_info
+            )
+
+    async def list_issues_by_state(self, state: str) -> List[Issue]:
+        """List issues filtered by state."""
+        async with self.uow:
+            return await self.uow.issues.list_issues(state=state)
+
+    async def create_issue(self, title: str, description: str, labels: List[str]) -> Issue:
+        """Create a new issue with validation."""
+        # Apply domain validation
+        self.validation_service.validate_issue_creation(title, labels)
+
+        async with self.uow:
+            issue = await self.uow.issues.create_issue(title, description, labels)
+            await self.uow.commit()
+            return issue
+
+    async def close_issue(self, issue_number: int) -> Issue:
+        """Close an issue using domain business rules."""
+        async with self.uow:
+            issue = await self.uow.issues.get_issue(issue_number)
+
+            # Apply domain business logic
+            issue.close()
+
+            await self.uow.issues.save_issue(issue)
+            await self.uow.commit()
+
+            return issue
+```
+
+#### **Task 3.2: Document Application Service**
+
+**Document Processing Application Service:**
+```python
+# application/document_application_service.py
+from typing import List, Dict, Any
+from pathlib import Path
+from domain.documents.models import Document, DocumentMetadata, DocumentType, ProcessingStatus
+from domain.documents.services import DocumentProcessingService
+from infrastructure.unit_of_work import UnitOfWork
+from dataclasses import dataclass
+import time
+
+@dataclass
+class DocumentIngestionResult:
+    """Result object for document ingestion."""
+    document_id: str
+    processing_time: float
+    ast_node_count: int
+    cache_path: Path
+
+class DocumentApplicationService:
+    """Application service for document-related use cases."""
+
+    def __init__(self, uow: UnitOfWork):
+        self.uow = uow
+        self.processing_service = DocumentProcessingService()
+
+    async def ingest_file(self, file_path: Path) -> DocumentIngestionResult:
+        """Ingest a file into the document system."""
+        async with self.uow:
+            # Read file content
+            content = file_path.read_text(encoding='utf-8')
+
+            # Create document metadata
+            file_stat = file_path.stat()
+            metadata = DocumentMetadata(
+                filename=file_path.name,
+                size=file_stat.st_size,
+                created_at=datetime.fromtimestamp(file_stat.st_ctime),
+                modified_at=datetime.fromtimestamp(file_stat.st_mtime),
+                content_type=self._determine_content_type(file_path),
+                encoding='utf-8'
+            )
+
+            # Create document entity
+            document = Document(
+                id=None,  # Will be assigned by repository
+                metadata=metadata,
+                content=content,
+                ast_data=None,
+                processing_status=ProcessingStatus.PENDING
+            )
+
+            # Apply domain validation
+            self.processing_service.validate_document_content(content, metadata.content_type)
+
+            # Start processing
+            document.mark_processing_started()
+
+            start_time = time.time()
+
+            # Process AST (this could be delegated to a domain service)
+            ast_data = await self._process_ast(content, metadata.content_type)
+
+            processing_time = time.time() - start_time
+
+            # Mark processing completed
+            document.mark_processing_completed(ast_data, processing_time)
+
+            # Store document
+            document_id = await self.uow.documents.store_document(document)
+
+            # Create cache
+            cache_path = await self.uow.documents.create_cache(document_id, ast_data)
+
+            await self.uow.commit()
+
+            return DocumentIngestionResult(
+                document_id=document_id,
+                processing_time=processing_time,
+                ast_node_count=self._count_ast_nodes(ast_data),
+                cache_path=cache_path
+            )
+
+    async def search_documents(self, query: str) -> List[Document]:
+        """Search documents by content."""
+        async with self.uow:
+            return await self.uow.documents.search_content(query)
+
+    async def get_document_summary(self) -> Dict[str, Any]:
+        """Get summary statistics for all documents."""
+        async with self.uow:
+            all_documents = await self.uow.documents.list_all_documents()
+
+            total_documents = len(all_documents)
+            total_size = sum(doc.metadata.size for doc in all_documents)
+            avg_processing_time = sum(doc.processing_time or 0 for doc in all_documents) / total_documents if total_documents > 0 else 0
+
+            status_counts = {}
+            for doc in all_documents:
+                status = doc.processing_status.value
+                status_counts[status] = status_counts.get(status, 0) + 1
+
+            return {
+                "total_documents": total_documents,
+                "total_size_bytes": total_size,
+                "average_processing_time": avg_processing_time,
+                "status_breakdown": status_counts,
+                "content_type_breakdown": self._get_content_type_breakdown(all_documents)
+            }
+
+    def _determine_content_type(self, file_path: Path) -> DocumentType:
+        """Determine content type from file extension."""
+        suffix = file_path.suffix.lower()
+        if suffix in ['.md', '.markdown']:
+            return DocumentType.MARKDOWN
+        elif suffix in ['.py', '.js', '.ts', '.java', '.cpp', '.c']:
+            return DocumentType.CODE
+        else:
+            return DocumentType.TEXT
+
+    async def _process_ast(self, content: str, content_type: DocumentType) -> Dict[str, Any]:
+        """Process content into AST - this could be a domain service."""
+        # This would delegate to appropriate parser based on content type
+        if content_type == DocumentType.MARKDOWN:
+            return await self._parse_markdown_ast(content)
+        else:
+            return {"type": "text", "content": content}
+
+    def _count_ast_nodes(self, ast_data: Dict[str, Any]) -> int:
+        """Count nodes in AST data."""
+        if not ast_data:
+            return 0
+
+        count = 1  # Current node
+        children = ast_data.get("children", [])
+        for child in children:
+            count += self._count_ast_nodes(child)
+
+        return count
+```
+
+#### **Task 3.3: Workspace Application Service**
+
+**Workspace Management Application Service:**
+```python
+# application/workspace_application_service.py
+from typing import List, Dict, Any
+from domain.workspaces.models import Workspace
+from domain.workspaces.services import WorkspaceManagementService
+from infrastructure.unit_of_work import UnitOfWork
+from dataclasses import dataclass
+
+@dataclass
+class WorkspaceCreationResult:
+    """Result object for workspace creation."""
+    workspace: Workspace
+    requirements_file_created: bool
+    test_plan_file_created: bool
+
+class WorkspaceApplicationService:
+    """Application service for workspace-related use cases."""
+
+    def __init__(self, uow: UnitOfWork):
+        self.uow = uow
+        self.management_service = WorkspaceManagementService()
+
+    async def create_issue_workspace(self, issue_number: int) -> WorkspaceCreationResult:
+        """Create a new workspace for an issue."""
+        # Apply domain validation
+        self.management_service.validate_workspace_creation(issue_number)
+
+        async with self.uow:
+            workspace = await self.uow.workspaces.create_workspace(issue_number)
+            await self.uow.commit()
+
+            return WorkspaceCreationResult(
+                workspace=workspace,
+                requirements_file_created=workspace.requirements_path is not None,
+                test_plan_file_created=workspace.test_plan_path is not None
+            )
+
+    async def cleanup_workspace(self, issue_number: int) -> bool:
+        """Clean up a workspace if eligible."""
+        async with self.uow:
+            workspace = await self.uow.workspaces.get_workspace(issue_number)
+
+            # Apply domain business rules
+            if not self.management_service.determine_cleanup_eligibility(workspace):
+                return False
+
+            await self.uow.workspaces.delete_workspace(issue_number)
+            await self.uow.commit()
+
+            return True
+
+    async def add_test_to_workspace(self, issue_number: int, test_scenario: str) -> Workspace:
+        """Add a test file to a workspace."""
+        async with self.uow:
+            workspace = await self.uow.workspaces.get_workspace(issue_number)
+
+            # Apply domain business logic
+            test_filename = f"test_issue_{issue_number}_{test_scenario}.py"
+            workspace.add_test_file(test_filename, test_scenario)
+
+            await self.uow.workspaces.save_workspace(workspace)
+            await self.uow.commit()
+
+            return workspace
+
+    async def get_workspace_summary(self) -> Dict[str, Any]:
+        """Get summary of all workspaces."""
+        async with self.uow:
+            all_workspaces = await self.uow.workspaces.list_all_workspaces()
+
+            # Apply domain business logic for summary calculation
+            return self.management_service.calculate_workspace_summary(all_workspaces)
+```
+
+**Deliverables:**
+- [ ] Application services for all major use cases
+- [ ] Use case orchestration with domain service coordination
+- [ ] Proper error handling and transaction management
+- [ ] Result objects for complex return data
+
+**Risk Level**: Medium (coordination logic, transaction handling)
+
+### **Phase 4: Migration and Backward Compatibility (Week 4-5)**
+
+#### **Task 4.1: Backward Compatibility Adapters**
+
+**Legacy Service Adapters:**
+```python
+# adapters/legacy_issue_service_adapter.py
+from typing import Dict, Any
+from services.issue_service import IssueService as LegacyIssueService
+from application.issue_application_service import IssueApplicationService
+from infrastructure.unit_of_work import UnitOfWork
+
+class LegacyIssueServiceAdapter(LegacyIssueService):
+    """Adapter to maintain backward compatibility with existing IssueService API."""
+
+    def __init__(self, uow: UnitOfWork):
+        # Don't call super().__init__() to avoid legacy initialization
+        self.application_service = IssueApplicationService(uow)
+
+    def get_issue_details(self, issue_number: int) -> Dict[str, Any]:
+        """Legacy method - converts async new API to sync old API."""
+        import asyncio
+
+        # Run async method in sync context
+        result = asyncio.run(self.application_service.get_issue_details(issue_number))
+
+        # Convert new result format to legacy format
+        return {
+            "number": result.issue.number,
+            "title": result.issue.title,
+            "state": result.issue.state.value,
+            "labels": [{"name": label.name} for label in result.issue.labels],
+            "kanban_column": result.kanban_column,
+            "priority": result.priority_info,
+            "project_info": result.project_context,
+            "created_at": result.issue.created_at.isoformat(),
+            "updated_at": result.issue.updated_at.isoformat()
+        }
+
+    def get_issue(self, issue_number: int) -> Dict[str, Any]:
+        """Legacy method for basic issue retrieval."""
+        result = self.get_issue_details(issue_number)
+
+        # Return subset for basic get_issue method
+        return {
+            "number": result["number"],
+            "title": result["title"],
+            "state": result["state"],
+            "labels": result["labels"]
+        }
+
+# Configuration for using adapter
+# services/__init__.py
+from config import get_unified_config
+from infrastructure.unit_of_work import SqliteUnitOfWork
+from infrastructure.connection_manager import ConnectionManager
+from adapters.legacy_issue_service_adapter import LegacyIssueServiceAdapter
+
+def get_issue_service():
+    """Factory function for getting issue service (backward compatible)."""
+    config = get_unified_config()
+
+    # Check feature flag for new architecture
+    if config.use_new_architecture:
+        connection_manager = ConnectionManager(config)
+        uow = SqliteUnitOfWork(config.database_path, config.workspace_dir, connection_manager)
+        return LegacyIssueServiceAdapter(uow)
+    else:
+        # Fall back to legacy implementation
+        from services.issue_service import IssueService
+        return IssueService()
+```
+
+#### **Task 4.2: Feature Flag Configuration**
+
+**Feature Flag System:**
+```python
+# config/feature_flags.py
+from dataclasses import dataclass
+from typing import Dict, Any
+
+@dataclass
+class FeatureFlags:
+    """Feature flags for gradual migration."""
+
+    use_new_architecture: bool = False
+    use_domain_services: bool = False
+    use_repository_pattern: bool = False
+    use_unit_of_work: bool = False
+
+    @classmethod
+    def from_config(cls, config_dict: Dict[str, Any]) -> 'FeatureFlags':
+        """Create feature flags from configuration."""
+        return cls(
+            use_new_architecture=config_dict.get('USE_NEW_ARCHITECTURE', False),
+            use_domain_services=config_dict.get('USE_DOMAIN_SERVICES', False),
+            use_repository_pattern=config_dict.get('USE_REPOSITORY_PATTERN', False),
+            use_unit_of_work=config_dict.get('USE_UNIT_OF_WORK', False)
+        )
+
+# Integration with existing config
+# config/manager.py (additions)
+@dataclass
+class MarkitectConfig(BaseConfig):
+    # ... existing fields ...
+
+    # Feature flags for migration
+    use_new_architecture: bool = False
+    use_domain_services: bool = False
+    use_repository_pattern: bool = False
+    use_unit_of_work: bool = False
+
+    def get_feature_flags(self) -> FeatureFlags:
+        """Get feature flags configuration."""
+        return FeatureFlags(
+            use_new_architecture=self.use_new_architecture,
+            use_domain_services=self.use_domain_services,
+            use_repository_pattern=self.use_repository_pattern,
+            use_unit_of_work=self.use_unit_of_work
+        )
+```
+
+#### **Task 4.3: Gradual Migration Strategy**
+
+**Migration Phases:**
+```python
+# migration/migration_manager.py
+from typing import List, Dict, Any
+from config.feature_flags import FeatureFlags
+import logging
+
+class MigrationManager:
+    """Manages gradual migration to new architecture."""
+
+    def __init__(self, feature_flags: FeatureFlags):
+        self.feature_flags = feature_flags
+        self.logger = logging.getLogger(__name__)
+
+    def should_use_new_issue_service(self) -> bool:
+        """Determine if new issue service should be used."""
+        return self.feature_flags.use_new_architecture and self.feature_flags.use_repository_pattern
+
+    def should_use_domain_services(self) -> bool:
+        """Determine if domain services should be used."""
+        return self.feature_flags.use_domain_services
+
+    def log_migration_decision(self, component: str, use_new: bool, reason: str) -> None:
+        """Log migration decisions for monitoring."""
+        self.logger.info(
+            f"Migration decision for {component}: "
+            f"{'NEW' if use_new else 'LEGACY'} architecture. "
+            f"Reason: {reason}"
+        )
+
+# Usage in service factories
+def create_issue_service():
+    """Create issue service with migration logic."""
+    config = get_unified_config()
+    feature_flags = config.get_feature_flags()
+    migration_manager = MigrationManager(feature_flags)
+
+    if migration_manager.should_use_new_issue_service():
+        migration_manager.log_migration_decision(
+            "IssueService",
+            True,
+            "Feature flags enabled for new architecture"
+        )
+
+        # Use new architecture
+        connection_manager = ConnectionManager(config)
+        uow = SqliteUnitOfWork(config.database_path, config.workspace_dir, connection_manager)
+        return LegacyIssueServiceAdapter(uow)
+    else:
+        migration_manager.log_migration_decision(
+            "IssueService",
+            False,
+            "Feature flags not enabled or fallback required"
+        )
+
+        # Use legacy architecture
+        from services.issue_service import IssueService
+        return IssueService()
+```
+
+**Deliverables:**
+- [ ] Backward compatibility adapters for all migrated services
+- [ ] Feature flag system for gradual rollout
+- [ ] Migration monitoring and logging
+- [ ] Rollback mechanisms for failed migrations
+
+**Risk Level**: High (involves changing existing behavior)
+
+### **Phase 5: Testing and Validation (Week 5-6)**
+
+#### **Task 5.1: Domain Logic Testing**
+
+**Pure Domain Testing:**
+```python
+# tests/unit/domain/test_issue_models.py
+import pytest
+from datetime import datetime
+from domain.issues.models import Issue, Label, IssueState, LabelCategories
+
+class TestIssue:
+    """Test Issue domain model behavior."""
+
+    def test_issue_creation_with_valid_data(self):
+        # Arrange & Act
+        issue = Issue(
+            number=123,
+            title="Test Issue",
+            state=IssueState.OPEN,
+            labels=[Label("bug"), Label("priority:high")],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Assert
+        assert issue.number == 123
+        assert issue.title == "Test Issue"
+        assert issue.state == IssueState.OPEN
+        assert len(issue.labels) == 2
+
+    def test_categorize_labels_correctly_separates_types(self):
+        # Arrange
+        labels = [
+            Label("bug"),                # type label
+            Label("priority:high"),      # priority label
+            Label("status:in-progress"), # state label
+            Label("documentation"),      # type label
+            Label("custom-label")        # other label
+        ]
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.OPEN,
+            labels=labels,
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act
+        categories = issue.categorize_labels()
+
+        # Assert
+        assert "bug" in categories.type_labels
+        assert "documentation" in categories.type_labels
+        assert "priority:high" in categories.priority_labels
+        assert "status:in-progress" in categories.state_labels
+        assert "custom-label" in categories.other_labels
+
+    def test_close_issue_changes_state_and_sets_closed_at(self):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.OPEN,
+            labels=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act
+        issue.close()
+
+        # Assert
+        assert issue.state == IssueState.CLOSED
+        assert issue.closed_at is not None
+
+    def test_close_already_closed_issue_raises_error(self):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.CLOSED,
+            labels=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow(),
+            closed_at=datetime.utcnow()
+        )
+
+        # Act & Assert
+        with pytest.raises(ValueError, match="Issue is already closed"):
+            issue.close()
+
+# tests/unit/domain/test_issue_services.py
+class TestIssueStatusService:
+    """Test business logic in issue status service."""
+
+    @pytest.fixture
+    def service(self):
+        return IssueStatusService()
+
+    def test_determine_kanban_column_for_closed_issue(self, service):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="Closed Issue",
+            state=IssueState.CLOSED,
+            labels=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+        project_info = {"kanban_columns": ["Todo", "In Progress", "Review", "Done"]}
+
+        # Act
+        column = service.determine_kanban_column(issue, project_info)
+
+        # Assert
+        assert column == "Done"
+
+    @pytest.mark.parametrize("status_label,expected_column", [
+        ("status:in-progress", "In Progress"),
+        ("status:review", "Review"),
+        ("status:blocked", "Blocked"),
+    ])
+    def test_determine_kanban_column_based_on_status_labels(self, service, status_label, expected_column):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="Test Issue",
+            state=IssueState.OPEN,
+            labels=[Label(status_label)],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+        project_info = {"kanban_columns": ["Todo", "In Progress", "Review", "Blocked", "Done"]}
+
+        # Act
+        column = service.determine_kanban_column(issue, project_info)
+
+        # Assert
+        assert column == expected_column
+```
+
+#### **Task 5.2: Application Service Testing**
+
+**Application Service Testing with Mocks:**
+```python
+# tests/unit/application/test_issue_application_service.py
+import pytest
+from unittest.mock import Mock, AsyncMock
+from application.issue_application_service import IssueApplicationService
+from domain.issues.models import Issue, Label, IssueState
+from infrastructure.unit_of_work import UnitOfWork
+
+class TestIssueApplicationService:
+    """Test application service coordination logic."""
+
+    @pytest.fixture
+    def mock_uow(self):
+        uow = Mock(spec=UnitOfWork)
+        uow.issues = AsyncMock()
+        uow.projects = AsyncMock()
+        uow.commit = AsyncMock()
+        uow.rollback = AsyncMock()
+        uow.__aenter__ = AsyncMock(return_value=uow)
+        uow.__aexit__ = AsyncMock(return_value=None)
+        return uow
+
+    @pytest.fixture
+    def service(self, mock_uow):
+        return IssueApplicationService(mock_uow)
+
+    async def test_get_issue_details_coordinates_repositories_and_domain_services(self, service, mock_uow):
+        # Arrange
+        issue = Issue(
+            number=123,
+            title="Test Issue",
+            state=IssueState.OPEN,
+            labels=[Label("priority:high"), Label("status:in-progress")],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+        project_info = {"kanban_columns": ["Todo", "In Progress", "Done"]}
+
+        mock_uow.issues.get_issue.return_value = issue
+        mock_uow.projects.get_issue_project_info.return_value = project_info
+
+        # Act
+        result = await service.get_issue_details(123)
+
+        # Assert
+        assert result.issue == issue
+        assert result.kanban_column == "In Progress"  # Based on status:in-progress label
+        assert result.priority_info["level"] == "High"  # Based on priority:high label
+        assert result.project_context == project_info
+
+        # Verify repository calls
+        mock_uow.issues.get_issue.assert_called_once_with(123)
+        mock_uow.projects.get_issue_project_info.assert_called_once_with(123)
+
+    async def test_create_issue_applies_validation_and_saves(self, service, mock_uow):
+        # Arrange
+        created_issue = Issue(
+            number=456,
+            title="New Issue",
+            state=IssueState.OPEN,
+            labels=[Label("bug")],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+        mock_uow.issues.create_issue.return_value = created_issue
+
+        # Act
+        result = await service.create_issue("New Issue", "Description", ["bug"])
+
+        # Assert
+        assert result == created_issue
+        mock_uow.issues.create_issue.assert_called_once_with("New Issue", "Description", ["bug"])
+        mock_uow.commit.assert_called_once()
+
+    async def test_create_issue_with_invalid_title_raises_validation_error(self, service, mock_uow):
+        # Act & Assert
+        with pytest.raises(ValueError, match="Issue title cannot be empty"):
+            await service.create_issue("", "Description", ["bug"])
+
+        # Verify no repository calls were made
+        mock_uow.issues.create_issue.assert_not_called()
+        mock_uow.commit.assert_not_called()
+```
+
+#### **Task 5.3: Integration Testing**
+
+**Integration Testing with Real Components:**
+```python
+# tests/integration/test_issue_workflow_integration.py
+import pytest
+from pathlib import Path
+from application.issue_application_service import IssueApplicationService
+from infrastructure.unit_of_work import SqliteUnitOfWork
+from infrastructure.connection_manager import ConnectionManager
+from config import MarkitectConfig
+
+class TestIssueWorkflowIntegration:
+    """Integration tests for complete issue workflows."""
+
+    @pytest.fixture
+    async def integrated_service(self, test_workspace):
+        # Create real configuration for testing
+        config = MarkitectConfig(
+            gitea_url="http://test-gitea.com",
+            repo_owner="test",
+            repo_name="repo",
+            database_path=str(test_workspace / "test.db"),
+            workspace_dir=str(test_workspace)
+        )
+
+        connection_manager = ConnectionManager(config)
+        uow = SqliteUnitOfWork(config.database_path, config.workspace_dir, connection_manager)
+
+        # Initialize database schema
+        await uow.initialize_schema()
+
+        yield IssueApplicationService(uow)
+
+        await uow.close()
+
+    async def test_complete_issue_lifecycle(self, integrated_service, aioresponses):
+        # Arrange - Mock external API responses
+        issue_data = {
+            "number": 123,
+            "title": "Integration Test Issue",
+            "state": "open",
+            "labels": [{"name": "bug"}, {"name": "priority:high"}],
+            "created_at": "2025-01-01T00:00:00Z",
+            "updated_at": "2025-01-01T00:00:00Z"
+        }
+
+        aioresponses.get(
+            "http://test-gitea.com/api/v1/repos/test/repo/issues/123",
+            payload=issue_data
+        )
+
+        project_info = {"kanban_columns": ["Todo", "In Progress", "Done"]}
+        aioresponses.get(
+            "http://test-gitea.com/api/v1/repos/test/repo",
+            payload=project_info
+        )
+
+        # Act - Get issue details
+        result = await integrated_service.get_issue_details(123)
+
+        # Assert - Verify complete workflow
+        assert result.issue.number == 123
+        assert result.issue.title == "Integration Test Issue"
+        assert result.kanban_column == "Todo"  # Default for new issues
+        assert result.priority_info["level"] == "High"
+
+        # Act - Close the issue
+        closed_issue = await integrated_service.close_issue(123)
+
+        # Assert - Verify state change
+        assert closed_issue.state == IssueState.CLOSED
+        assert closed_issue.closed_at is not None
+```
+
+**Deliverables:**
+- [ ] Comprehensive unit tests for all domain models and services
+- [ ] Application service tests with proper mocking
+- [ ] Integration tests with real components
+- [ ] End-to-end workflow testing
+
+**Risk Level**: Low (testing activities, no production impact)
+
+## Success Criteria and Benefits
+
+### **Implementation Success Indicators:**
+
+#### **Architecture Quality Metrics:**
+- **Domain Purity**: Domain models have no infrastructure dependencies
+- **Testability**: >95% unit test coverage for domain layer
+- **Separation**: Clear boundaries between layers with proper dependency direction
+- **Maintainability**: Business logic changes require minimal infrastructure changes
+
+#### **Performance Benefits:**
+- **Faster Testing**: Unit tests run in <10 seconds total (no external dependencies)
+- **Better Isolation**: Integration failures don't break business logic tests
+- **Reduced Coupling**: Changes to external APIs don't require business logic changes
+
+#### **Developer Experience:**
+- **Clear Structure**: Developers can easily locate business logic vs infrastructure code
+- **Easy Testing**: New features can be test-driven with fast feedback loops
+- **Flexible Architecture**: New requirements can be implemented by changing domain logic only
+
+### **Business Benefits:**
+
+#### **Maintainability:**
+- **Single Responsibility**: Each class has one clear purpose
+- **Business Logic Clarity**: Domain rules are explicit and easy to understand
+- **Change Isolation**: Infrastructure changes don't affect business rules
+
+#### **Testability:**
+- **Fast Feedback**: Business logic can be tested without external systems
+- **Comprehensive Coverage**: All business scenarios can be easily tested
+- **Reliable Tests**: No flaky tests due to external dependencies
+
+#### **Flexibility:**
+- **Technology Independence**: Business logic can work with any infrastructure
+- **Easy Extensions**: New features can be added without changing existing code
+- **Migration Ready**: Infrastructure can be changed without affecting domain logic
+
+This comprehensive domain logic separation gameplan provides a systematic approach to implementing clean architecture principles while maintaining system stability and ensuring that business logic is properly isolated, testable, and maintainable.
diff --git a/TESTING_ARCHITECTURE_ENHANCEMENT_GAMEPLAN.md b/TESTING_ARCHITECTURE_ENHANCEMENT_GAMEPLAN.md
new file mode 100644
index 00000000..c6c79626
--- /dev/null
+++ b/TESTING_ARCHITECTURE_ENHANCEMENT_GAMEPLAN.md
@@ -0,0 +1,1288 @@
+# Testing Architecture Enhancement - Gameplan
+
+## Overview
+
+This gameplan establishes a comprehensive testing architecture that supports the domain logic separation and data access pattern improvements while ensuring high code quality, maintainability, and confidence in changes across the MarkiTect codebase.
+
+## Current Testing Architecture Problems
+
+### 1. **Test Organization and Structure Issues**
+
+#### **Inconsistent Test File Organization**
+- **Problem**: Tests scattered across multiple directories without clear structure
+- **Current**: Mix of `tests/` and module-specific test files
+- **Impact**: Difficult to locate and maintain tests
+
+#### **Poor Test Naming Conventions**
+- **Problem**: Inconsistent naming patterns (e.g., `test_issue_11_*`, `test_issue_creator.py`)
+- **Current**: Tests named after issue numbers rather than functionality
+- **Impact**: Tests don't clearly indicate what they're testing
+
+#### **Mixed Test Types**
+- **Problem**: Unit tests, integration tests, and end-to-end tests mixed together
+- **Current**: No clear separation between test types
+- **Impact**: Slow test execution, unclear test purpose
+
+### 2. **Test Coverage and Quality Issues**
+
+#### **Missing Test Coverage Areas**
+```python
+# Current gaps identified:
+- Domain logic testing (business rules not tested in isolation)
+- Repository pattern testing (no mock strategies)
+- Error handling scenarios (happy path bias)
+- Performance and load testing (no performance regression detection)
+- Configuration management testing (config scenarios not covered)
+```
+
+#### **Poor Test Isolation**
+- **Problem**: Tests depend on external systems and state
+- **Current**: Tests make real API calls, modify actual files
+- **Impact**: Flaky tests, slow execution, test interference
+
+### 3. **Testing Anti-patterns Identified**
+
+#### **Services Module Testing Issues**
+```python
+# Current anti-pattern in services/issue_service.py tests
+class TestIssueService:
+    def test_get_issue_details(self):
+        # Problem: Real API calls in unit tests
+        service = IssueService()
+        result = service.get_issue_details(123)  # Makes real HTTP request
+        assert result is not None
+```
+
+#### **TDDAI Module Testing Problems**
+```python
+# Current anti-pattern in tddai tests
+class TestProjectManager:
+    def test_create_project(self):
+        # Problem: File system dependencies
+        manager = ProjectManager()
+        manager.create_workspace("/tmp/test")  # Creates real directories
+        assert os.path.exists("/tmp/test")  # Depends on file system state
+```
+
+## Testing Architecture Strategy
+
+### **Test Pyramid Implementation**
+
+```
+                   E2E Tests (Few)
+                  ├─ Workflow Tests
+                  ├─ CLI Integration Tests
+                  └─ API Integration Tests
+
+               Integration Tests (Some)
+              ├─ Service Layer Tests
+              ├─ Repository Tests
+              ├─ Database Tests
+              └─ External API Tests
+
+            Unit Tests (Many)
+           ├─ Domain Model Tests
+           ├─ Business Logic Tests
+           ├─ Value Object Tests
+           └─ Utility Function Tests
+```
+
+### **Testing Layer Architecture**
+
+```python
+tests/
+├── unit/                    # Fast, isolated unit tests
+│   ├── domain/             # Domain model and business logic tests
+│   ├── application/        # Application service tests (mocked repos)
+│   └── infrastructure/     # Infrastructure component tests
+├── integration/            # Integration tests with real components
+│   ├── repositories/       # Repository tests with real databases
+│   ├── services/          # Service tests with real dependencies
+│   └── external/          # External API integration tests
+├── e2e/                   # End-to-end workflow tests
+│   ├── cli/               # CLI command testing
+│   ├── workflows/         # Complete user workflows
+│   └── performance/       # Performance and load tests
+├── fixtures/              # Test data and builders
+│   ├── markdown_samples.py
+│   ├── api_responses.py
+│   └── database_seeds.py
+└── utils/                 # Test utilities and helpers
+    ├── test_builders.py
+    ├── mock_factories.py
+    └── assertions.py
+```
+
+## Implementation Gameplan
+
+### **Phase 1: Foundation and Infrastructure (Week 1-2)**
+
+#### **Task 1.1: Test Organization and Structure**
+```python
+# Create standardized test directory structure
+tests/
+├── conftest.py              # Global test configuration
+├── pytest.ini              # Pytest configuration
+├── requirements-test.txt    # Test dependencies
+└── [organized structure as above]
+```
+
+#### **Task 1.2: Test Configuration Setup**
+```python
+# tests/conftest.py
+import pytest
+import tempfile
+import shutil
+from pathlib import Path
+from unittest.mock import Mock
+from typing import Generator
+
+@pytest.fixture(scope="session")
+def test_workspace() -> Generator[Path, None, None]:
+    """Create isolated test workspace."""
+    temp_dir = tempfile.mkdtemp(prefix="markitect_test_")
+    workspace_path = Path(temp_dir)
+    yield workspace_path
+    shutil.rmtree(temp_dir)
+
+@pytest.fixture
+def mock_database():
+    """Provide mocked database for testing."""
+    mock_db = Mock()
+    mock_cursor = Mock()
+    mock_db.cursor.return_value = mock_cursor
+    mock_db.execute.return_value = mock_cursor
+    mock_cursor.fetchone.return_value = None
+    mock_cursor.fetchall.return_value = []
+    return mock_db
+
+@pytest.fixture
+def mock_http_client():
+    """Provide mocked HTTP client for API tests."""
+    mock_client = Mock()
+    mock_response = Mock()
+    mock_response.status_code = 200
+    mock_response.json.return_value = {"status": "success"}
+    mock_client.get.return_value = mock_response
+    mock_client.post.return_value = mock_response
+    return mock_client
+```
+
+#### **Task 1.3: Test Data Builders and Factories**
+```python
+# tests/fixtures/markdown_samples.py
+class MarkdownDocumentBuilder:
+    """Builder pattern for creating test markdown documents."""
+
+    def __init__(self):
+        self.content_parts = []
+        self.metadata = {}
+
+    def with_heading(self, text: str, level: int = 1):
+        heading_marker = "#" * level
+        self.content_parts.append(f"{heading_marker} {text}")
+        return self
+
+    def with_paragraph(self, text: str):
+        self.content_parts.append(text)
+        return self
+
+    def with_metadata(self, key: str, value: str):
+        self.metadata[key] = value
+        return self
+
+    def build(self) -> str:
+        content = "\n\n".join(self.content_parts)
+        if self.metadata:
+            metadata_lines = [f"{k}: {v}" for k, v in self.metadata.items()]
+            content = "---\n" + "\n".join(metadata_lines) + "\n---\n\n" + content
+        return content
+
+# tests/fixtures/api_responses.py
+class GiteaApiResponseBuilder:
+    """Builder for creating mock Gitea API responses."""
+
+    def __init__(self):
+        self.issue_data = {
+            "number": 1,
+            "title": "Test Issue",
+            "state": "open",
+            "labels": [],
+            "milestone": None,
+            "created_at": "2025-01-01T00:00:00Z",
+            "updated_at": "2025-01-01T00:00:00Z"
+        }
+
+    def with_number(self, number: int):
+        self.issue_data["number"] = number
+        return self
+
+    def with_title(self, title: str):
+        self.issue_data["title"] = title
+        return self
+
+    def with_labels(self, *labels: str):
+        self.issue_data["labels"] = [{"name": label} for label in labels]
+        return self
+
+    def build(self) -> dict:
+        return self.issue_data.copy()
+```
+
+**Deliverables:**
+- [ ] Standardized test directory structure
+- [ ] Global test configuration and fixtures
+- [ ] Test data builders and factories
+- [ ] Test utilities and helpers
+
+**Risk Level**: Low (foundation work, no breaking changes)
+
+### **Phase 2: Unit Testing Framework (Week 2-3)**
+
+#### **Task 2.1: Domain Model Unit Tests**
+```python
+# tests/unit/domain/test_issue_models.py
+import pytest
+from domain.issues.models import Issue, Label, IssueState
+
+class TestIssue:
+    """Test Issue domain model behavior."""
+
+    def test_issue_creation_with_valid_data(self):
+        # Arrange
+        issue = Issue(
+            number=123,
+            title="Test Issue",
+            state=IssueState.OPEN,
+            labels=[Label("bug"), Label("priority:high")]
+        )
+
+        # Act & Assert
+        assert issue.number == 123
+        assert issue.title == "Test Issue"
+        assert issue.state == IssueState.OPEN
+        assert len(issue.labels) == 2
+
+    def test_issue_state_transition_rules(self):
+        # Arrange
+        issue = Issue(number=1, title="Test", state=IssueState.OPEN)
+
+        # Act
+        issue.close()
+
+        # Assert
+        assert issue.state == IssueState.CLOSED
+        assert issue.closed_at is not None
+
+    def test_issue_label_categorization(self):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="Test",
+            labels=[
+                Label("bug"),           # type label
+                Label("priority:high"), # priority label
+                Label("status:ready"),  # state label
+                Label("custom")         # other label
+            ]
+        )
+
+        # Act
+        categories = issue.categorize_labels()
+
+        # Assert
+        assert "bug" in categories.type_labels
+        assert "priority:high" in categories.priority_labels
+        assert "status:ready" in categories.state_labels
+        assert "custom" in categories.other_labels
+```
+
+#### **Task 2.2: Business Logic Unit Tests**
+```python
+# tests/unit/domain/test_issue_services.py
+import pytest
+from domain.issues.services import IssueStatusService
+from domain.issues.models import Issue, Label, IssueState
+
+class TestIssueStatusService:
+    """Test business logic for issue status determination."""
+
+    @pytest.fixture
+    def service(self):
+        return IssueStatusService()
+
+    def test_determine_kanban_column_for_new_issue(self, service):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="New Issue",
+            state=IssueState.OPEN,
+            labels=[Label("status:new")]
+        )
+
+        # Act
+        column = service.determine_kanban_column(issue)
+
+        # Assert
+        assert column == "Todo"
+
+    def test_determine_kanban_column_for_in_progress_issue(self, service):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="In Progress Issue",
+            state=IssueState.OPEN,
+            labels=[Label("status:in-progress")]
+        )
+
+        # Act
+        column = service.determine_kanban_column(issue)
+
+        # Assert
+        assert column == "In Progress"
+
+    @pytest.mark.parametrize("labels,expected_priority", [
+        ([Label("priority:low")], "Low"),
+        ([Label("priority:medium")], "Medium"),
+        ([Label("priority:high")], "High"),
+        ([Label("priority:critical")], "Critical"),
+        ([], "Medium"),  # Default priority
+    ])
+    def test_extract_priority_info(self, service, labels, expected_priority):
+        # Arrange
+        issue = Issue(number=1, title="Test", labels=labels)
+
+        # Act
+        priority = service.extract_priority_info(issue)
+
+        # Assert
+        assert priority.level == expected_priority
+```
+
+#### **Task 2.3: Application Service Unit Tests (with Mocks)**
+```python
+# tests/unit/application/test_issue_application_service.py
+import pytest
+from unittest.mock import Mock, AsyncMock
+from application.issue_application_service import IssueApplicationService
+from domain.issues.models import Issue, IssueState
+from infrastructure.unit_of_work import UnitOfWork
+
+class TestIssueApplicationService:
+    """Test application service coordination logic."""
+
+    @pytest.fixture
+    def mock_uow(self):
+        uow = Mock(spec=UnitOfWork)
+        uow.issues = AsyncMock()
+        uow.projects = AsyncMock()
+        uow.__aenter__ = AsyncMock(return_value=uow)
+        uow.__aexit__ = AsyncMock(return_value=None)
+        return uow
+
+    @pytest.fixture
+    def service(self, mock_uow):
+        return IssueApplicationService(mock_uow)
+
+    async def test_get_issue_details_success(self, service, mock_uow):
+        # Arrange
+        issue = Issue(number=123, title="Test Issue", state=IssueState.OPEN)
+        project_info = Mock()
+        project_info.kanban_columns = ["Todo", "In Progress", "Done"]
+
+        mock_uow.issues.get_issue.return_value = issue
+        mock_uow.projects.get_issue_project_info.return_value = project_info
+
+        # Act
+        result = await service.get_issue_details(123)
+
+        # Assert
+        assert result.issue == issue
+        assert result.project_info == project_info
+        mock_uow.issues.get_issue.assert_called_once_with(123)
+        mock_uow.projects.get_issue_project_info.assert_called_once_with(123)
+
+    async def test_get_issue_details_issue_not_found(self, service, mock_uow):
+        # Arrange
+        from domain.issues.exceptions import IssueNotFoundError
+        mock_uow.issues.get_issue.side_effect = IssueNotFoundError("Issue not found")
+
+        # Act & Assert
+        with pytest.raises(IssueNotFoundError):
+            await service.get_issue_details(999)
+```
+
+**Deliverables:**
+- [ ] Unit tests for all domain models
+- [ ] Unit tests for business logic services
+- [ ] Unit tests for application services with mocks
+- [ ] Parameterized tests for edge cases
+
+**Risk Level**: Low (isolated unit tests, no external dependencies)
+
+### **Phase 3: Integration Testing Framework (Week 3-4)**
+
+#### **Task 3.1: Repository Integration Tests**
+```python
+# tests/integration/repositories/test_gitea_issue_repository.py
+import pytest
+import aiohttp
+from infrastructure.repositories.gitea_issue_repository import GiteaIssueRepository
+from infrastructure.connection_manager import ConnectionManager
+from tests.fixtures.api_responses import GiteaApiResponseBuilder
+
+class TestGiteaIssueRepository:
+    """Integration tests for Gitea API repository."""
+
+    @pytest.fixture
+    async def repository(self, test_config):
+        connection_manager = ConnectionManager(test_config)
+        repo = GiteaIssueRepository(connection_manager)
+        yield repo
+        await connection_manager.close()
+
+    @pytest.fixture
+    def mock_server(self, aioresponses):
+        """Mock HTTP responses for integration tests."""
+        return aioresponses
+
+    async def test_get_issue_success(self, repository, mock_server):
+        # Arrange
+        issue_data = (GiteaApiResponseBuilder()
+                     .with_number(123)
+                     .with_title("Test Issue")
+                     .with_labels("bug", "priority:high")
+                     .build())
+
+        mock_server.get(
+            "http://test-gitea.com/api/v1/repos/test/repo/issues/123",
+            payload=issue_data
+        )
+
+        # Act
+        issue = await repository.get_issue(123)
+
+        # Assert
+        assert issue.number == 123
+        assert issue.title == "Test Issue"
+        assert len(issue.labels) == 2
+
+    async def test_get_issue_not_found(self, repository, mock_server):
+        # Arrange
+        mock_server.get(
+            "http://test-gitea.com/api/v1/repos/test/repo/issues/999",
+            status=404
+        )
+
+        # Act & Assert
+        from domain.issues.exceptions import IssueNotFoundError
+        with pytest.raises(IssueNotFoundError):
+            await repository.get_issue(999)
+
+    async def test_get_issue_with_retry_on_network_error(self, repository, mock_server):
+        # Arrange - First two requests fail, third succeeds
+        issue_data = GiteaApiResponseBuilder().with_number(123).build()
+
+        mock_server.get(
+            "http://test-gitea.com/api/v1/repos/test/repo/issues/123",
+            exception=aiohttp.ClientError("Network error")
+        )
+        mock_server.get(
+            "http://test-gitea.com/api/v1/repos/test/repo/issues/123",
+            exception=aiohttp.ClientError("Network error")
+        )
+        mock_server.get(
+            "http://test-gitea.com/api/v1/repos/test/repo/issues/123",
+            payload=issue_data
+        )
+
+        # Act
+        issue = await repository.get_issue(123)
+
+        # Assert
+        assert issue.number == 123
+        # Verify retry mechanism worked (3 calls total)
+        assert len(mock_server.requests) == 3
+```
+
+#### **Task 3.2: Database Integration Tests**
+```python
+# tests/integration/repositories/test_sqlite_document_repository.py
+import pytest
+import sqlite3
+from pathlib import Path
+from infrastructure.repositories.sqlite_document_repository import SqliteDocumentRepository
+from domain.documents.models import Document
+
+class TestSqliteDocumentRepository:
+    """Integration tests for SQLite document repository."""
+
+    @pytest.fixture
+    def test_db_path(self, test_workspace):
+        return test_workspace / "test.db"
+
+    @pytest.fixture
+    def repository(self, test_db_path):
+        repo = SqliteDocumentRepository(test_db_path)
+        repo.initialize_schema()
+        yield repo
+        repo.close()
+
+    async def test_store_and_retrieve_document(self, repository):
+        # Arrange
+        document = Document(
+            filename="test.md",
+            content="# Test Document\nContent here",
+            ast_data={"type": "document", "children": []}
+        )
+
+        # Act
+        document_id = await repository.store_document(document)
+        retrieved = await repository.get_document(document_id)
+
+        # Assert
+        assert retrieved.filename == "test.md"
+        assert retrieved.content == "# Test Document\nContent here"
+        assert retrieved.ast_data["type"] == "document"
+
+    async def test_store_duplicate_filename_raises_error(self, repository):
+        # Arrange
+        document1 = Document(filename="duplicate.md", content="Content 1")
+        document2 = Document(filename="duplicate.md", content="Content 2")
+
+        # Act
+        await repository.store_document(document1)
+
+        # Assert
+        from infrastructure.exceptions import DocumentStoreError
+        with pytest.raises(DocumentStoreError) as exc_info:
+            await repository.store_document(document2)
+
+        assert "already exists" in str(exc_info.value)
+
+    async def test_transaction_rollback_on_error(self, repository):
+        # Arrange
+        document = Document(filename="test.md", content="Valid content")
+
+        # Simulate a database error during storage
+        with pytest.raises(sqlite3.Error):
+            async with repository.unit_of_work():
+                await repository.store_document(document)
+                # Force an error that should rollback the transaction
+                await repository.execute_raw_sql("INVALID SQL")
+
+        # Assert - Document should not be stored due to rollback
+        documents = await repository.list_all_documents()
+        assert len(documents) == 0
+```
+
+#### **Task 3.3: Service Integration Tests**
+```python
+# tests/integration/services/test_document_service_integration.py
+import pytest
+from pathlib import Path
+from application.document_service import DocumentService
+from infrastructure.unit_of_work import UnitOfWork
+from tests.fixtures.markdown_samples import MarkdownDocumentBuilder
+
+class TestDocumentServiceIntegration:
+    """Integration tests for document service with real repositories."""
+
+    @pytest.fixture
+    def service(self, test_workspace):
+        uow = UnitOfWork(database_path=test_workspace / "test.db")
+        uow.initialize()
+        yield DocumentService(uow)
+        uow.close()
+
+    async def test_ingest_markdown_file_complete_workflow(self, service, test_workspace):
+        # Arrange
+        markdown_content = (MarkdownDocumentBuilder()
+                           .with_heading("Test Document")
+                           .with_paragraph("This is a test paragraph.")
+                           .with_heading("Section 2", level=2)
+                           .build())
+
+        test_file = test_workspace / "test.md"
+        test_file.write_text(markdown_content)
+
+        # Act
+        result = await service.ingest_file(test_file)
+
+        # Assert
+        assert result.document_id is not None
+        assert result.parse_time > 0
+        assert result.cache_path.exists()
+
+        # Verify document was stored correctly
+        document = await service.get_document(result.document_id)
+        assert document.filename == "test.md"
+        assert "Test Document" in document.content
+        assert document.ast_data is not None
+
+    async def test_bulk_ingestion_with_transaction(self, service, test_workspace):
+        # Arrange
+        files = []
+        for i in range(5):
+            content = f"# Document {i}\nContent for document {i}"
+            file_path = test_workspace / f"doc_{i}.md"
+            file_path.write_text(content)
+            files.append(file_path)
+
+        # Act
+        results = await service.ingest_bulk(files)
+
+        # Assert
+        assert len(results) == 5
+        for result in results:
+            assert result.document_id is not None
+            assert result.parse_time > 0
+
+        # Verify all documents are stored
+        all_docs = await service.list_documents()
+        assert len(all_docs) == 5
+```
+
+**Deliverables:**
+- [ ] Repository integration tests with real databases/APIs
+- [ ] Service integration tests with transaction testing
+- [ ] Error handling and retry mechanism tests
+- [ ] Performance and load integration tests
+
+**Risk Level**: Medium (involves real external dependencies)
+
+### **Phase 4: End-to-End Testing Framework (Week 4-5)**
+
+#### **Task 4.1: CLI Command Testing**
+```python
+# tests/e2e/cli/test_issue_commands.py
+import pytest
+import subprocess
+from pathlib import Path
+
+class TestIssueCommands:
+    """End-to-end tests for issue management CLI commands."""
+
+    @pytest.fixture
+    def isolated_environment(self, test_workspace):
+        """Set up isolated environment for CLI testing."""
+        env = {
+            "MARKITECT_WORKSPACE_DIR": str(test_workspace),
+            "MARKITECT_GITEA_URL": "http://test-gitea.com",
+            "MARKITECT_REPO_OWNER": "test",
+            "MARKITECT_REPO_NAME": "repo"
+        }
+        return env
+
+    def test_issue_show_command(self, isolated_environment):
+        # Act
+        result = subprocess.run(
+            ["python", "tddai_cli.py", "show-issue", "123"],
+            env=isolated_environment,
+            capture_output=True,
+            text=True
+        )
+
+        # Assert
+        assert result.returncode == 0
+        assert "Issue #123 Details" in result.stdout
+        assert "Title:" in result.stdout
+        assert "Status:" in result.stdout
+
+    def test_issue_start_workflow(self, isolated_environment):
+        # Act - Start working on an issue
+        result = subprocess.run(
+            ["python", "tddai_cli.py", "start-issue", "456"],
+            env=isolated_environment,
+            capture_output=True,
+            text=True
+        )
+
+        # Assert
+        assert result.returncode == 0
+        assert "Starting work on issue #456" in result.stdout
+
+        # Verify workspace was created
+        workspace_path = Path(isolated_environment["MARKITECT_WORKSPACE_DIR"]) / "issue_456"
+        assert workspace_path.exists()
+        assert (workspace_path / "requirements.md").exists()
+        assert (workspace_path / "test_plan.md").exists()
+
+    def test_complete_issue_workflow(self, isolated_environment):
+        # Act - Complete workflow: start -> add tests -> finish
+        commands = [
+            ["python", "tddai_cli.py", "start-issue", "789"],
+            ["python", "tddai_cli.py", "add-test", "test_scenario"],
+            ["python", "tddai_cli.py", "finish-issue"]
+        ]
+
+        for cmd in commands:
+            result = subprocess.run(
+                cmd,
+                env=isolated_environment,
+                capture_output=True,
+                text=True
+            )
+            assert result.returncode == 0
+
+        # Assert - Workspace should be cleaned up
+        workspace_path = Path(isolated_environment["MARKITECT_WORKSPACE_DIR"]) / "issue_789"
+        assert not workspace_path.exists()
+```
+
+#### **Task 4.2: Workflow Integration Tests**
+```python
+# tests/e2e/workflows/test_document_processing_workflow.py
+import pytest
+from pathlib import Path
+import asyncio
+from application.document_service import DocumentService
+from application.workspace_service import WorkspaceService
+from infrastructure.unit_of_work import UnitOfWork
+
+class TestDocumentProcessingWorkflow:
+    """End-to-end tests for complete document processing workflows."""
+
+    @pytest.fixture
+    async def services(self, test_workspace):
+        uow = UnitOfWork(database_path=test_workspace / "test.db")
+        await uow.initialize()
+
+        doc_service = DocumentService(uow)
+        workspace_service = WorkspaceService(uow)
+
+        yield doc_service, workspace_service
+
+        await uow.close()
+
+    async def test_full_document_lifecycle(self, services, test_workspace):
+        doc_service, workspace_service = services
+
+        # Arrange - Create test documents
+        docs_dir = test_workspace / "documents"
+        docs_dir.mkdir()
+
+        # Create various document types
+        (docs_dir / "readme.md").write_text("# Project README\nDescription here")
+        (docs_dir / "api.md").write_text("# API Documentation\n## Endpoints")
+        (docs_dir / "guide.md").write_text("# User Guide\n### Getting Started")
+
+        # Act - Process all documents
+        ingestion_results = []
+        for md_file in docs_dir.glob("*.md"):
+            result = await doc_service.ingest_file(md_file)
+            ingestion_results.append(result)
+
+        # Generate workspace summary
+        workspace_summary = await workspace_service.generate_summary()
+
+        # Act - Search functionality
+        search_results = await doc_service.search_content("API")
+
+        # Assert - All documents processed
+        assert len(ingestion_results) == 3
+        for result in ingestion_results:
+            assert result.document_id is not None
+            assert result.parse_time > 0
+
+        # Assert - Workspace summary generated
+        assert workspace_summary.total_documents == 3
+        assert workspace_summary.total_size > 0
+
+        # Assert - Search functionality works
+        assert len(search_results) >= 1
+        assert any("api.md" in result.filename for result in search_results)
+
+    async def test_large_document_processing_performance(self, services, test_workspace):
+        doc_service, _ = services
+
+        # Arrange - Create large document (1MB)
+        from tests.fixtures.markdown_samples import LargeMarkdownGenerator
+        generator = LargeMarkdownGenerator()
+        large_content = generator.generate_document(size='1mb')
+
+        large_file = test_workspace / "large_document.md"
+        large_file.write_text(large_content)
+
+        # Act - Measure processing time
+        import time
+        start_time = time.time()
+        result = await doc_service.ingest_file(large_file)
+        processing_time = time.time() - start_time
+
+        # Assert - Performance requirements
+        assert result.document_id is not None
+        assert processing_time < 10.0  # Should process 1MB in under 10 seconds
+        assert result.parse_time < 5.0  # AST parsing should be under 5 seconds
+
+        # Verify cache was created for performance
+        assert result.cache_path.exists()
+        cache_size = result.cache_path.stat().st_size
+        assert cache_size > 0
+```
+
+#### **Task 4.3: Performance and Load Testing**
+```python
+# tests/e2e/performance/test_system_performance.py
+import pytest
+import asyncio
+import time
+import statistics
+from concurrent.futures import ThreadPoolExecutor
+from application.document_service import DocumentService
+from tests.fixtures.markdown_samples import MarkdownDocumentBuilder
+
+class TestSystemPerformance:
+    """Performance and load testing for the system."""
+
+    @pytest.fixture
+    async def service(self, test_workspace):
+        from infrastructure.unit_of_work import UnitOfWork
+        uow = UnitOfWork(database_path=test_workspace / "perf_test.db")
+        await uow.initialize()
+        yield DocumentService(uow)
+        await uow.close()
+
+    async def test_concurrent_document_ingestion(self, service, test_workspace):
+        """Test system behavior under concurrent load."""
+
+        # Arrange - Create multiple test documents
+        docs_dir = test_workspace / "concurrent_docs"
+        docs_dir.mkdir()
+
+        doc_files = []
+        for i in range(20):
+            content = (MarkdownDocumentBuilder()
+                      .with_heading(f"Document {i}")
+                      .with_paragraph(f"Content for document {i}")
+                      .build())
+
+            doc_file = docs_dir / f"doc_{i}.md"
+            doc_file.write_text(content)
+            doc_files.append(doc_file)
+
+        # Act - Process documents concurrently
+        start_time = time.time()
+        tasks = [service.ingest_file(doc_file) for doc_file in doc_files]
+        results = await asyncio.gather(*tasks)
+        total_time = time.time() - start_time
+
+        # Assert - Performance requirements
+        assert len(results) == 20
+        assert all(result.document_id is not None for result in results)
+
+        # Should process 20 small documents in under 30 seconds
+        assert total_time < 30.0
+
+        # Calculate processing statistics
+        parse_times = [result.parse_time for result in results]
+        avg_parse_time = statistics.mean(parse_times)
+        max_parse_time = max(parse_times)
+
+        assert avg_parse_time < 1.0  # Average parse time under 1 second
+        assert max_parse_time < 5.0  # Max parse time under 5 seconds
+
+    async def test_memory_usage_under_load(self, service, test_workspace):
+        """Test memory usage patterns during heavy processing."""
+        import psutil
+        import os
+
+        # Measure initial memory
+        process = psutil.Process(os.getpid())
+        initial_memory = process.memory_info().rss
+
+        # Arrange - Create multiple large documents
+        from tests.fixtures.markdown_samples import LargeMarkdownGenerator
+        generator = LargeMarkdownGenerator()
+
+        large_docs = []
+        for i in range(5):
+            content = generator.generate_document(size='1mb')
+            doc_file = test_workspace / f"large_{i}.md"
+            doc_file.write_text(content)
+            large_docs.append(doc_file)
+
+        # Act - Process large documents
+        for doc_file in large_docs:
+            await service.ingest_file(doc_file)
+
+        # Measure final memory
+        final_memory = process.memory_info().rss
+        memory_increase = final_memory - initial_memory
+        memory_increase_mb = memory_increase / (1024 * 1024)
+
+        # Assert - Memory usage should be reasonable
+        # Should not use more than 100MB additional memory for 5MB of documents
+        assert memory_increase_mb < 100
+
+        print(f"Memory increase: {memory_increase_mb:.2f} MB")
+
+    @pytest.mark.slow
+    async def test_system_stability_over_time(self, service, test_workspace):
+        """Long-running stability test."""
+
+        # Run continuous processing for 5 minutes
+        start_time = time.time()
+        duration = 300  # 5 minutes
+        operation_count = 0
+        errors = []
+
+        while time.time() - start_time < duration:
+            try:
+                # Create and process a document
+                content = (MarkdownDocumentBuilder()
+                          .with_heading(f"Stability Test {operation_count}")
+                          .with_paragraph("Long-running test content")
+                          .build())
+
+                doc_file = test_workspace / f"stability_{operation_count}.md"
+                doc_file.write_text(content)
+
+                await service.ingest_file(doc_file)
+                operation_count += 1
+
+                # Small delay between operations
+                await asyncio.sleep(0.1)
+
+            except Exception as e:
+                errors.append(str(e))
+
+        # Assert - System should remain stable
+        error_rate = len(errors) / operation_count if operation_count > 0 else 1
+        assert error_rate < 0.01  # Less than 1% error rate
+        assert operation_count > 100  # Should process at least 100 operations
+
+        print(f"Operations completed: {operation_count}")
+        print(f"Error rate: {error_rate:.2%}")
+```
+
+**Deliverables:**
+- [ ] CLI command end-to-end tests
+- [ ] Complete workflow integration tests
+- [ ] Performance and load testing framework
+- [ ] System stability and reliability tests
+
+**Risk Level**: Low-Medium (end-to-end tests, performance requirements)
+
+### **Phase 5: Test Migration and Optimization (Week 5-6)**
+
+#### **Task 5.1: Migrate Existing Tests**
+```python
+# Migration strategy for existing tests
+# Example: Migrating tests/test_issue_creator.py
+
+# Before (current structure)
+class TestIssueCreator:
+    def test_create_issue_success(self):
+        creator = IssueCreator(auth_token="test-token")
+        result = creator.create_issue("Test Issue", "Description")
+        assert result is not None
+
+# After (new structure)
+# tests/unit/application/test_issue_creator.py
+class TestIssueCreator:
+    @pytest.fixture
+    def mock_repository(self):
+        return Mock(spec=IssueRepository)
+
+    @pytest.fixture
+    def creator(self, mock_repository):
+        return IssueCreator(mock_repository)
+
+    async def test_create_issue_success(self, creator, mock_repository):
+        # Arrange
+        mock_repository.create_issue.return_value = Issue(number=123, title="Test Issue")
+
+        # Act
+        result = await creator.create_issue("Test Issue", "Description")
+
+        # Assert
+        assert result.number == 123
+        mock_repository.create_issue.assert_called_once()
+```
+
+#### **Task 5.2: Test Performance Optimization**
+```python
+# tests/utils/performance_optimization.py
+import pytest
+import asyncio
+from typing import List, Callable
+
+class TestPerformanceOptimizer:
+    """Utilities for optimizing test execution performance."""
+
+    @staticmethod
+    def parallelize_tests(test_functions: List[Callable]):
+        """Run multiple test functions in parallel."""
+        async def run_parallel():
+            tasks = [asyncio.create_task(test_func()) for test_func in test_functions]
+            return await asyncio.gather(*tasks)
+
+        return asyncio.run(run_parallel())
+
+    @staticmethod
+    def cache_expensive_fixtures():
+        """Cache expensive test fixtures across test sessions."""
+        # Implementation for fixture caching
+        pass
+
+# pytest configuration for performance
+# pytest.ini
+[tool:pytest]
+addopts =
+    --strict-markers
+    --strict-config
+    --verbose
+    --tb=short
+    --cov=src
+    --cov-report=term-missing
+    --cov-report=html
+    --cov-fail-under=90
+    --maxfail=1
+    --durations=10
+markers =
+    slow: marks tests as slow (deselect with '-m "not slow"')
+    integration: marks tests as integration tests
+    e2e: marks tests as end-to-end tests
+    performance: marks tests as performance tests
+```
+
+#### **Task 5.3: CI/CD Integration**
+```yaml
+# .github/workflows/test.yml
+name: Test Suite
+
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  unit-tests:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.11'
+
+    - name: Install dependencies
+      run: |
+        pip install -r requirements.txt
+        pip install -r requirements-test.txt
+
+    - name: Run unit tests
+      run: pytest tests/unit/ -v --cov=src --cov-report=xml
+
+    - name: Upload coverage
+      uses: codecov/codecov-action@v3
+
+  integration-tests:
+    runs-on: ubuntu-latest
+    needs: unit-tests
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.11'
+
+    - name: Install dependencies
+      run: |
+        pip install -r requirements.txt
+        pip install -r requirements-test.txt
+
+    - name: Run integration tests
+      run: pytest tests/integration/ -v
+
+  e2e-tests:
+    runs-on: ubuntu-latest
+    needs: [unit-tests, integration-tests]
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.11'
+
+    - name: Install dependencies
+      run: |
+        pip install -r requirements.txt
+        pip install -r requirements-test.txt
+
+    - name: Run end-to-end tests
+      run: pytest tests/e2e/ -v -m "not slow"
+
+    - name: Run performance tests
+      run: pytest tests/e2e/performance/ -v
+      if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+```
+
+**Deliverables:**
+- [ ] Migration of all existing tests to new architecture
+- [ ] Test performance optimization and parallelization
+- [ ] CI/CD pipeline integration
+- [ ] Test coverage and quality gates
+
+**Risk Level**: Medium (migration changes, CI/CD dependencies)
+
+### **Phase 6: Advanced Testing Features (Week 6-7)**
+
+#### **Task 6.1: Property-Based Testing**
+```python
+# tests/property/test_markdown_processing.py
+import pytest
+from hypothesis import given, strategies as st
+from domain.documents.models import Document
+from application.document_service import DocumentService
+
+class TestMarkdownProcessingProperties:
+    """Property-based tests for markdown processing."""
+
+    @given(st.text(alphabet=st.characters(blacklist_categories=('Cc', 'Cs'))))
+    async def test_any_valid_text_can_be_processed(self, text, document_service):
+        """Any valid unicode text should be processable."""
+        # Arrange
+        document = Document(filename="test.md", content=text)
+
+        # Act - Should not raise exception
+        result = await document_service.process_document(document)
+
+        # Assert
+        assert result is not None
+        assert result.ast_data is not None
+
+    @given(st.text(min_size=1, max_size=1000))
+    async def test_processing_is_deterministic(self, content, document_service):
+        """Same content should always produce same AST."""
+        # Arrange
+        document = Document(filename="test.md", content=content)
+
+        # Act
+        result1 = await document_service.process_document(document)
+        result2 = await document_service.process_document(document)
+
+        # Assert
+        assert result1.ast_data == result2.ast_data
+
+    @given(st.lists(st.text(min_size=1), min_size=1, max_size=10))
+    async def test_batch_processing_order_independence(self, contents, document_service):
+        """Batch processing should be order-independent."""
+        # Arrange
+        documents1 = [Document(f"doc_{i}.md", content) for i, content in enumerate(contents)]
+        documents2 = list(reversed(documents1))
+
+        # Act
+        results1 = await document_service.process_batch(documents1)
+        results2 = await document_service.process_batch(documents2)
+
+        # Assert - Results should be equivalent regardless of order
+        results1_by_name = {r.filename: r.ast_data for r in results1}
+        results2_by_name = {r.filename: r.ast_data for r in results2}
+        assert results1_by_name == results2_by_name
+```
+
+#### **Task 6.2: Mutation Testing**
+```python
+# tests/mutation/test_coverage_quality.py
+"""
+Mutation testing to verify test quality.
+Uses mutmut or similar tools to verify tests catch logic errors.
+"""
+
+# Configuration for mutation testing
+# pyproject.toml
+[tool.mutmut]
+paths_to_mutate = "src/"
+backup = false
+runner = "python -m pytest tests/unit/"
+tests_dir = "tests/"
+
+# Mutation testing command
+# mutmut run --paths-to-mutate src/domain/
+```
+
+#### **Task 6.3: Contract Testing**
+```python
+# tests/contract/test_api_contracts.py
+import pytest
+from pact import Consumer, Provider
+from application.issue_service import IssueService
+
+class TestGiteaApiContract:
+    """Contract tests for Gitea API integration."""
+
+    @pytest.fixture
+    def pact(self):
+        pact = Consumer('markitect').has_pact_with(Provider('gitea'))
+        pact.start()
+        yield pact
+        pact.stop()
+
+    def test_get_issue_contract(self, pact):
+        # Define expected interaction
+        expected = {
+            'number': 123,
+            'title': 'Test Issue',
+            'state': 'open',
+            'labels': [{'name': 'bug'}]
+        }
+
+        (pact
+         .given('issue 123 exists')
+         .upon_receiving('a request for issue 123')
+         .with_request('GET', '/api/v1/repos/test/repo/issues/123')
+         .will_respond_with(200, body=expected))
+
+        # Test the interaction
+        with pact:
+            issue_service = IssueService(base_url=pact.uri)
+            issue = issue_service.get_issue(123)
+            assert issue.number == 123
+```
+
+**Deliverables:**
+- [ ] Property-based testing framework
+- [ ] Mutation testing setup
+- [ ] Contract testing for external APIs
+- [ ] Advanced test analysis and reporting
+
+**Risk Level**: Low (advanced features, non-breaking additions)
+
+## Success Criteria and Metrics
+
+### **Implementation Success Indicators:**
+
+#### **Coverage Metrics:**
+- **Unit Test Coverage**: >90% for domain and application layers
+- **Integration Test Coverage**: >80% for infrastructure layer
+- **E2E Test Coverage**: >70% for critical user workflows
+
+#### **Performance Metrics:**
+- **Unit Tests**: All execute in <30 seconds total
+- **Integration Tests**: All execute in <5 minutes total
+- **E2E Tests**: Critical workflows tested in <15 minutes
+
+#### **Quality Metrics:**
+- **Test Reliability**: <1% flakiness rate
+- **Test Maintainability**: Clear organization and documentation
+- **CI/CD Integration**: Tests run automatically on all commits
+- **Error Detection**: Mutation testing score >85%
+
+### **Test Architecture Benefits:**
+
+#### **Developer Experience:**
+- **Fast Feedback**: Unit tests provide immediate feedback
+- **Reliable Tests**: Consistent results across environments
+- **Easy Debugging**: Clear test failure messages and context
+- **Comprehensive Coverage**: All critical paths tested
+
+#### **System Quality:**
+- **Regression Prevention**: Automated detection of breaking changes
+- **Performance Monitoring**: Continuous performance validation
+- **Error Handling**: Comprehensive error scenario testing
+- **Stability Assurance**: Long-running stability validation
+
+This comprehensive testing architecture enhancement gameplan provides a robust foundation for ensuring code quality, catching regressions early, and maintaining confidence in the system as it evolves through domain logic separation and data access improvements.
\ No newline at end of file
diff --git a/application/__init__.py b/application/__init__.py
new file mode 100644
index 00000000..a8d77227
--- /dev/null
+++ b/application/__init__.py
@@ -0,0 +1,5 @@
+"""
+Application services layer for MarkiTect project.
+
+Contains use case implementations that coordinate domain and infrastructure.
+"""
\ No newline at end of file
diff --git a/domain/__init__.py b/domain/__init__.py
new file mode 100644
index 00000000..deead1a4
--- /dev/null
+++ b/domain/__init__.py
@@ -0,0 +1,6 @@
+"""
+Domain layer for MarkiTect project.
+
+This package contains the core business logic and domain models,
+implementing clean architecture principles with no infrastructure dependencies.
+"""
\ No newline at end of file
diff --git a/domain/issues/__init__.py b/domain/issues/__init__.py
new file mode 100644
index 00000000..0330d89a
--- /dev/null
+++ b/domain/issues/__init__.py
@@ -0,0 +1,20 @@
+"""
+Issue domain module.
+
+Contains domain models, services, and interfaces for issue management.
+"""
+
+from .models import Issue, Label, IssueState, LabelCategories
+from .services import IssueStatusService, IssueValidationService
+from .exceptions import IssueDomainError, IssueValidationError
+
+__all__ = [
+    'Issue',
+    'Label',
+    'IssueState',
+    'LabelCategories',
+    'IssueStatusService',
+    'IssueValidationService',
+    'IssueDomainError',
+    'IssueValidationError'
+]
\ No newline at end of file
diff --git a/domain/issues/exceptions.py b/domain/issues/exceptions.py
new file mode 100644
index 00000000..6ccffcb9
--- /dev/null
+++ b/domain/issues/exceptions.py
@@ -0,0 +1,29 @@
+"""
+Domain-specific exceptions for issue management.
+"""
+
+
+class IssueDomainError(Exception):
+    """Base exception for issue domain errors."""
+
+    def __init__(self, message: str, issue_number: int = None):
+        super().__init__(message)
+        self.issue_number = issue_number
+
+
+class IssueValidationError(IssueDomainError):
+    """Exception raised when issue validation fails."""
+
+    def __init__(self, message: str, field: str = None, value=None):
+        super().__init__(message)
+        self.field = field
+        self.value = value
+
+
+class IssueStateError(IssueDomainError):
+    """Exception raised when invalid state transitions are attempted."""
+
+    def __init__(self, message: str, current_state: str, attempted_state: str):
+        super().__init__(message)
+        self.current_state = current_state
+        self.attempted_state = attempted_state
\ No newline at end of file
diff --git a/domain/issues/models.py b/domain/issues/models.py
new file mode 100644
index 00000000..201cf81b
--- /dev/null
+++ b/domain/issues/models.py
@@ -0,0 +1,116 @@
+"""
+Issue domain models.
+
+Contains core business entities and value objects for issue management.
+"""
+
+from dataclasses import dataclass
+from typing import List, Optional
+from datetime import datetime
+from enum import Enum
+
+from .exceptions import IssueStateError
+
+
+class IssueState(Enum):
+    """Issue state enumeration."""
+    OPEN = "open"
+    CLOSED = "closed"
+    IN_PROGRESS = "in_progress"
+
+
+@dataclass(frozen=True)
+class Label:
+    """Value object representing an issue label."""
+    name: str
+    color: Optional[str] = None
+    description: Optional[str] = None
+
+    def is_state_label(self) -> bool:
+        """Check if this is a state-related label."""
+        return self.name.startswith('status:')
+
+    def is_priority_label(self) -> bool:
+        """Check if this is a priority-related label."""
+        return self.name.startswith('priority:')
+
+    def is_type_label(self) -> bool:
+        """Check if this is a type-related label."""
+        return self.name in ['bug', 'enhancement', 'feature', 'documentation']
+
+
+@dataclass(frozen=True)
+class LabelCategories:
+    """Value object for categorized labels."""
+    state_labels: List[str]
+    priority_labels: List[str]
+    type_labels: List[str]
+    other_labels: List[str]
+
+
+@dataclass
+class Issue:
+    """Issue aggregate root."""
+    number: int
+    title: str
+    state: IssueState
+    labels: List[Label]
+    created_at: datetime
+    updated_at: datetime
+    milestone: Optional[str] = None
+    assignee: Optional[str] = None
+    closed_at: Optional[datetime] = None
+
+    def categorize_labels(self) -> LabelCategories:
+        """Categorize labels by type - pure domain logic."""
+        state_labels = [label.name for label in self.labels if label.is_state_label()]
+        priority_labels = [label.name for label in self.labels if label.is_priority_label()]
+        type_labels = [label.name for label in self.labels if label.is_type_label()]
+        other_labels = [
+            label.name for label in self.labels
+            if not (label.is_state_label() or label.is_priority_label() or label.is_type_label())
+        ]
+
+        return LabelCategories(
+            state_labels=state_labels,
+            priority_labels=priority_labels,
+            type_labels=type_labels,
+            other_labels=other_labels
+        )
+
+    def close(self) -> None:
+        """Close the issue - domain business rule."""
+        if self.state == IssueState.CLOSED:
+            raise IssueStateError(
+                "Issue is already closed",
+                current_state=self.state.value,
+                attempted_state=IssueState.CLOSED.value
+            )
+
+        self.state = IssueState.CLOSED
+        self.closed_at = datetime.utcnow()
+
+    def reopen(self) -> None:
+        """Reopen the issue - domain business rule."""
+        if self.state != IssueState.CLOSED:
+            raise IssueStateError(
+                "Issue is not closed",
+                current_state=self.state.value,
+                attempted_state=IssueState.OPEN.value
+            )
+
+        self.state = IssueState.OPEN
+        self.closed_at = None
+
+    def add_label(self, label: Label) -> None:
+        """Add a label to the issue."""
+        if label not in self.labels:
+            self.labels.append(label)
+
+    def remove_label(self, label_name: str) -> None:
+        """Remove a label from the issue."""
+        self.labels = [label for label in self.labels if label.name != label_name]
+
+    def has_label(self, label_name: str) -> bool:
+        """Check if issue has a specific label."""
+        return any(label.name == label_name for label in self.labels)
\ No newline at end of file
diff --git a/domain/issues/repositories.py b/domain/issues/repositories.py
new file mode 100644
index 00000000..e36442da
--- /dev/null
+++ b/domain/issues/repositories.py
@@ -0,0 +1,116 @@
+"""
+Repository interfaces for issue domain.
+
+Defines contracts for data access without infrastructure dependencies.
+"""
+
+from abc import ABC, abstractmethod
+from typing import List, Optional, Dict, Any
+from .models import Issue
+
+
+class IssueRepository(ABC):
+    """Repository interface for issue persistence."""
+
+    @abstractmethod
+    async def get_issue(self, issue_number: int) -> Issue:
+        """Retrieve issue by number.
+
+        Args:
+            issue_number: The issue number to retrieve
+
+        Returns:
+            Issue domain object
+
+        Raises:
+            IssueNotFoundError: If issue doesn't exist
+        """
+        pass
+
+    @abstractmethod
+    async def list_issues(self, state: Optional[str] = None, limit: Optional[int] = None) -> List[Issue]:
+        """List issues, optionally filtered by state.
+
+        Args:
+            state: Optional state filter (open, closed)
+            limit: Optional limit on number of results
+
+        Returns:
+            List of Issue domain objects
+        """
+        pass
+
+    @abstractmethod
+    async def save_issue(self, issue: Issue) -> None:
+        """Save issue changes.
+
+        Args:
+            issue: Issue domain object to save
+        """
+        pass
+
+    @abstractmethod
+    async def create_issue(self, title: str, description: str, labels: List[str]) -> Issue:
+        """Create a new issue.
+
+        Args:
+            title: Issue title
+            description: Issue description
+            labels: List of label names
+
+        Returns:
+            Created Issue domain object
+        """
+        pass
+
+    @abstractmethod
+    async def delete_issue(self, issue_number: int) -> None:
+        """Delete an issue.
+
+        Args:
+            issue_number: The issue number to delete
+        """
+        pass
+
+
+class ProjectRepository(ABC):
+    """Repository interface for project information."""
+
+    @abstractmethod
+    async def get_issue_project_info(self, issue_number: int) -> Dict[str, Any]:
+        """Get project information for an issue.
+
+        Args:
+            issue_number: The issue number
+
+        Returns:
+            Dictionary containing project context information
+        """
+        pass
+
+    @abstractmethod
+    async def get_kanban_columns(self) -> List[str]:
+        """Get available kanban columns for the project.
+
+        Returns:
+            List of kanban column names
+        """
+        pass
+
+    @abstractmethod
+    async def get_project_labels(self) -> List[Dict[str, Any]]:
+        """Get available labels for the project.
+
+        Returns:
+            List of label definitions
+        """
+        pass
+
+    @abstractmethod
+    async def get_milestones(self) -> List[Dict[str, Any]]:
+        """Get available milestones for the project.
+
+        Returns:
+            List of milestone information
+        """
+        pass
\ No newline at end of file
diff --git a/domain/issues/services.py b/domain/issues/services.py
new file mode 100644
index 00000000..2fee615e
--- /dev/null
+++ b/domain/issues/services.py
@@ -0,0 +1,173 @@
+"""
+Issue domain services.
+
+Contains business logic for issue-related operations.
+"""
+
+from typing import Dict, Any, List
+from .models import Issue, IssueState, LabelCategories
+from .exceptions import IssueValidationError
+
+
+class IssueStatusService:
+    """Domain service for issue status-related business logic."""
+
+    def determine_kanban_column(self, issue: Issue, project_info: Dict[str, Any]) -> str:
+        """Determine kanban column based on issue state and labels."""
+        # Pure business logic - no infrastructure dependencies
+        label_categories = issue.categorize_labels()
+
+        # Business rules for kanban column determination
+        if issue.state == IssueState.CLOSED:
+            return "Done"
+
+        # Check for explicit status labels
+        for state_label in label_categories.state_labels:
+            if state_label == "status:in-progress":
+                return "In Progress"
+            elif state_label == "status:review":
+                return "Review"
+            elif state_label == "status:blocked":
+                return "Blocked"
+            elif state_label == "status:ready":
+                return "Ready"
+
+        # Default for open issues without explicit status
+        return "Todo"
+
+    def extract_priority_info(self, issue: Issue) -> Dict[str, Any]:
+        """Extract priority information from issue labels."""
+        label_categories = issue.categorize_labels()
+
+        priority_mapping = {
+            "priority:low": "Low",
+            "priority:medium": "Medium",
+            "priority:high": "High",
+            "priority:critical": "Critical"
+        }
+
+        for priority_label in label_categories.priority_labels:
+            if priority_label in priority_mapping:
+                return {
+                    "level": priority_mapping[priority_label],
+                    "label": priority_label
+                }
+
+        # Default priority
+        return {"level": "Medium", "label": None}
+
+    def extract_state_info(self, issue: Issue) -> Dict[str, Any]:
+        """Extract state information from issue labels and state."""
+        label_categories = issue.categorize_labels()
+
+        return {
+            "state": issue.state.value,
+            "state_labels": label_categories.state_labels,
+            "is_closed": issue.state == IssueState.CLOSED,
+            "closed_at": issue.closed_at.isoformat() if issue.closed_at else None
+        }
+
+    def calculate_issue_age_days(self, issue: Issue) -> int:
+        """Calculate issue age in days."""
+        from datetime import datetime
+        return (datetime.utcnow() - issue.created_at).days
+
+    def is_stale_issue(self, issue: Issue, stale_threshold_days: int = 30) -> bool:
+        """Determine if issue is considered stale based on business rules."""
+        if issue.state == IssueState.CLOSED:
+            return False
+
+        age_days = self.calculate_issue_age_days(issue)
+        return age_days > stale_threshold_days
+
+
+class IssueValidationService:
+    """Domain service for issue validation business rules."""
+
+    def validate_issue_creation(self, title: str, labels: List[str]) -> None:
+        """Validate issue creation according to business rules."""
+        if not title or not title.strip():
+            raise IssueValidationError(
+                "Issue title cannot be empty",
+                field="title",
+                value=title
+            )
+
+        if len(title) > 255:
+            raise IssueValidationError(
+                "Issue title cannot exceed 255 characters",
+                field="title",
+                value=title
+            )
+
+        # Business rule: Cannot have conflicting priority labels
+        priority_labels = [label for label in labels if label.startswith("priority:")]
+        if len(priority_labels) > 1:
+            raise IssueValidationError(
+                "Issue cannot have multiple priority labels",
+                field="labels",
+                value=priority_labels
+            )
+
+        # Business rule: Cannot have conflicting state labels
+        state_labels = [label for label in labels if label.startswith("status:")]
+        if len(state_labels) > 1:
+            raise IssueValidationError(
+                "Issue cannot have multiple state labels",
+                field="labels",
+                value=state_labels
+            )
+
+    def validate_title_update(self, new_title: str) -> None:
+        """Validate issue title update."""
+        if not new_title or not new_title.strip():
+            raise IssueValidationError(
+                "Issue title cannot be empty",
+                field="title",
+                value=new_title
+            )
+
+        if len(new_title) > 255:
+            raise IssueValidationError(
+                "Issue title cannot exceed 255 characters",
+                field="title",
+                value=new_title
+            )
+
+    def validate_label_addition(self, issue: Issue, new_label: str) -> None:
+        """Validate adding a label to an issue."""
+        # Business rule: Cannot add duplicate labels
+        if issue.has_label(new_label):
+            raise IssueValidationError(
+                f"Issue already has label '{new_label}'",
+                field="labels",
+                value=new_label
+            )
+
+        # Business rule: Cannot add conflicting priority labels
+        if new_label.startswith("priority:"):
+            existing_priority_labels = [
+                label.name for label in issue.labels
+                if label.is_priority_label()
+            ]
+            if existing_priority_labels:
+                raise IssueValidationError(
+                    f"Issue already has priority label '{existing_priority_labels[0]}'. "
+                    f"Cannot add '{new_label}'",
+                    field="labels",
+                    value=new_label
+                )
+
+        # Business rule: Cannot add conflicting state labels
+        if new_label.startswith("status:"):
+            existing_state_labels = [
+                label.name for label in issue.labels
+                if label.is_state_label()
+            ]
+            if existing_state_labels:
+                raise IssueValidationError(
+                    f"Issue already has state label '{existing_state_labels[0]}'. "
+                    f"Cannot add '{new_label}'",
+                    field="labels",
+                    value=new_label
+                )
\ No newline at end of file
diff --git a/domain/projects/__init__.py b/domain/projects/__init__.py
new file mode 100644
index 00000000..0d598f67
--- /dev/null
+++ b/domain/projects/__init__.py
@@ -0,0 +1,18 @@
+"""
+Project domain module.
+
+Contains domain models, services, and interfaces for project management.
+"""
+
+from .models import Project, Milestone, ProjectState
+from .services import ProjectManagementService
+from .exceptions import ProjectDomainError, ProjectValidationError
+
+__all__ = [
+    'Project',
+    'Milestone',
+    'ProjectState',
+    'ProjectManagementService',
+    'ProjectDomainError',
+    'ProjectValidationError'
+]
\ No newline at end of file
diff --git a/domain/projects/exceptions.py b/domain/projects/exceptions.py
new file mode 100644
index 00000000..388d54cb
--- /dev/null
+++ b/domain/projects/exceptions.py
@@ -0,0 +1,28 @@
+"""
+Domain-specific exceptions for project management.
+"""
+
+
+class ProjectDomainError(Exception):
+    """Base exception for project domain errors."""
+
+    def __init__(self, message: str, project_name: str = None):
+        super().__init__(message)
+        self.project_name = project_name
+
+
+class ProjectValidationError(ProjectDomainError):
+    """Exception raised when project validation fails."""
+
+    def __init__(self, message: str, field: str = None, value=None):
+        super().__init__(message)
+        self.field = field
+        self.value = value
+
+
+class MilestoneError(ProjectDomainError):
+    """Exception raised when milestone operations fail."""
+
+    def __init__(self, message: str, milestone_id: int = None):
+        super().__init__(message)
+        self.milestone_id = milestone_id
\ No newline at end of file
diff --git a/domain/projects/models.py b/domain/projects/models.py
new file mode 100644
index 00000000..09855b80
--- /dev/null
+++ b/domain/projects/models.py
@@ -0,0 +1,162 @@
+"""
+Project domain models.
+
+Contains core business entities and value objects for project management.
+"""
+
+from dataclasses import dataclass
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+from enum import Enum
+
+from .exceptions import MilestoneError
+
+
+class ProjectState(Enum):
+    """Project state enumeration."""
+    ACTIVE = "active"
+    ARCHIVED = "archived"
+    PLANNING = "planning"
+
+
+@dataclass
+class Milestone:
+    """Milestone entity."""
+    id: int
+    title: str
+    description: Optional[str]
+    due_date: Optional[datetime]
+    state: str
+    open_issues: int
+    closed_issues: int
+
+    @property
+    def completion_percentage(self) -> float:
+        """Calculate milestone completion percentage."""
+        total_issues = self.open_issues + self.closed_issues
+        if total_issues == 0:
+            return 0.0
+        return (self.closed_issues / total_issues) * 100
+
+    @property
+    def total_issues(self) -> int:
+        """Get total number of issues in milestone."""
+        return self.open_issues + self.closed_issues
+
+    def is_overdue(self) -> bool:
+        """Check if milestone is overdue."""
+        if not self.due_date or self.state == "closed":
+            return False
+        return datetime.utcnow() > self.due_date
+
+    def is_completed(self) -> bool:
+        """Check if milestone is completed."""
+        return self.state == "closed" or (self.total_issues > 0 and self.completion_percentage >= 100.0)
+
+    def add_issue(self) -> None:
+        """Add an open issue to the milestone."""
+        self.open_issues += 1
+
+    def close_issue(self) -> None:
+        """Close an issue in the milestone."""
+        if self.open_issues <= 0:
+            raise MilestoneError(
+                f"Cannot close issue in milestone '{self.title}': no open issues",
+                milestone_id=self.id
+            )
+        self.open_issues -= 1
+        self.closed_issues += 1
+
+    def reopen_issue(self) -> None:
+        """Reopen an issue in the milestone."""
+        if self.closed_issues <= 0:
+            raise MilestoneError(
+                f"Cannot reopen issue in milestone '{self.title}': no closed issues",
+                milestone_id=self.id
+            )
+        self.closed_issues -= 1
+        self.open_issues += 1
+
+
+@dataclass
+class Project:
+    """Project aggregate root."""
+    name: str
+    description: str
+    state: ProjectState
+    milestones: List[Milestone]
+    kanban_columns: List[str]
+    created_at: datetime
+    updated_at: datetime
+    archived_at: Optional[datetime] = None
+
+    def get_active_milestones(self) -> List[Milestone]:
+        """Get milestones that are currently active."""
+        return [milestone for milestone in self.milestones if milestone.state == "open"]
+
+    def get_completed_milestones(self) -> List[Milestone]:
+        """Get milestones that are completed."""
+        return [milestone for milestone in self.milestones if milestone.is_completed()]
+
+    def get_overdue_milestones(self) -> List[Milestone]:
+        """Get milestones that are overdue."""
+        return [milestone for milestone in self.milestones if milestone.is_overdue()]
+
+    def calculate_overall_progress(self) -> float:
+        """Calculate overall project progress based on milestones."""
+        if not self.milestones:
+            return 0.0
+
+        total_completion = sum(milestone.completion_percentage for milestone in self.milestones)
+        return total_completion / len(self.milestones)
+
+    def get_total_issues(self) -> int:
+        """Get total number of issues across all milestones."""
+        return sum(milestone.total_issues for milestone in self.milestones)
+
+    def get_total_open_issues(self) -> int:
+        """Get total number of open issues across all milestones."""
+        return sum(milestone.open_issues for milestone in self.milestones)
+
+    def get_total_closed_issues(self) -> int:
+        """Get total number of closed issues across all milestones."""
+        return sum(milestone.closed_issues for milestone in self.milestones)
+
+    def archive(self) -> None:
+        """Archive the project."""
+        if self.state == ProjectState.ARCHIVED:
+            return  # Already archived
+
+        self.state = ProjectState.ARCHIVED
+        self.archived_at = datetime.utcnow()
+
+    def activate(self) -> None:
+        """Activate the project."""
+        if self.state == ProjectState.ACTIVE:
+            return  # Already active
+
+        self.state = ProjectState.ACTIVE
+        self.archived_at = None
+
+    def add_milestone(self, milestone: Milestone) -> None:
+        """Add a milestone to the project."""
+        # Check for duplicate milestone IDs
+        if any(m.id == milestone.id for m in self.milestones):
+            raise ValueError(f"Milestone with ID {milestone.id} already exists")
+
+        self.milestones.append(milestone)
+
+    def remove_milestone(self, milestone_id: int) -> None:
+        """Remove a milestone from the project."""
+        original_count = len(self.milestones)
+        self.milestones = [m for m in self.milestones if m.id != milestone_id]
+
+        if len(self.milestones) == original_count:
+            raise ValueError(f"Milestone with ID {milestone_id} not found")
+
+    def get_milestone(self, milestone_id: int) -> Optional[Milestone]:
+        """Get a milestone by ID."""
+        for milestone in self.milestones:
+            if milestone.id == milestone_id:
+                return milestone
+        return None
\ No newline at end of file
diff --git a/domain/projects/services.py b/domain/projects/services.py
new file mode 100644
index 00000000..6602222e
--- /dev/null
+++ b/domain/projects/services.py
@@ -0,0 +1,189 @@
+"""
+Project domain services.
+
+Contains business logic for project-related operations.
+"""
+
+from typing import Dict, Any, List
+from datetime import datetime, timedelta
+from .models import Project, Milestone, ProjectState
+from .exceptions import ProjectValidationError
+
+
+class ProjectManagementService:
+    """Domain service for project management business logic."""
+
+    def determine_project_health(self, project: Project) -> str:
+        """Determine project health based on business rules."""
+        progress = project.calculate_overall_progress()
+        overdue_milestones = project.get_overdue_milestones()
+        active_milestones = project.get_active_milestones()
+
+        # Business rules for project health assessment
+        if project.state != ProjectState.ACTIVE:
+            return "Inactive"
+
+        if progress >= 95:
+            return "Excellent"
+        elif progress >= 80:
+            return "Good"
+        elif progress >= 60:
+            return "Fair"
+        elif len(overdue_milestones) > 0:
+            return "At Risk"
+        elif len(active_milestones) == 0:
+            return "Stalled"
+        else:
+            return "Needs Attention"
+
+    def calculate_project_velocity(self, project: Project, days_back: int = 30) -> float:
+        """Calculate project velocity based on recent milestone completions."""
+        completed_milestones = project.get_completed_milestones()
+        cutoff_date = datetime.utcnow() - timedelta(days=days_back)
+
+        # Count milestones completed in the specified period
+        # Note: This would need milestone completion dates in a real implementation
+        recent_completions = len(completed_milestones)  # Simplified for now
+
+        return recent_completions / (days_back / 7)  # Issues per week
+
+    def identify_bottlenecks(self, project: Project) -> List[str]:
+        """Identify potential bottlenecks in the project."""
+        bottlenecks = []
+
+        # Check for overdue milestones
+        overdue_milestones = project.get_overdue_milestones()
+        if overdue_milestones:
+            bottlenecks.append(f"Overdue milestones: {len(overdue_milestones)}")
+
+        # Check for milestones with too many open issues
+        for milestone in project.get_active_milestones():
+            if milestone.open_issues > 20:  # Business rule: threshold for too many issues
+                bottlenecks.append(f"Milestone '{milestone.title}' has {milestone.open_issues} open issues")
+
+        # Check for stalled milestones (no progress)
+        for milestone in project.get_active_milestones():
+            if milestone.total_issues > 0 and milestone.completion_percentage == 0:
+                bottlenecks.append(f"Milestone '{milestone.title}' shows no progress")
+
+        return bottlenecks
+
+    def recommend_next_actions(self, project: Project) -> List[str]:
+        """Recommend next actions based on project state."""
+        recommendations = []
+        health = self.determine_project_health(project)
+
+        if health == "At Risk":
+            overdue_milestones = project.get_overdue_milestones()
+            recommendations.append(f"Address {len(overdue_milestones)} overdue milestone(s)")
+
+        if health == "Stalled":
+            recommendations.append("Create new milestones or reactivate existing ones")
+
+        # Check for milestones nearing completion
+        for milestone in project.get_active_milestones():
+            if milestone.completion_percentage >= 80:
+                recommendations.append(f"Focus on completing milestone '{milestone.title}' ({milestone.completion_percentage:.0f}% done)")
+
+        # Check for unbalanced workload
+        total_open = project.get_total_open_issues()
+        if total_open > 50:  # Business rule: threshold for too many open issues
+            recommendations.append(f"Consider breaking down work - {total_open} total open issues")
+
+        return recommendations
+
+    def validate_project_creation(self, name: str, description: str) -> None:
+        """Validate project creation according to business rules."""
+        if not name or not name.strip():
+            raise ProjectValidationError(
+                "Project name cannot be empty",
+                field="name",
+                value=name
+            )
+
+        if len(name) > 100:
+            raise ProjectValidationError(
+                "Project name cannot exceed 100 characters",
+                field="name",
+                value=name
+            )
+
+        if description and len(description) > 1000:
+            raise ProjectValidationError(
+                "Project description cannot exceed 1000 characters",
+                field="description",
+                value=description
+            )
+
+    def validate_milestone_creation(self, title: str, due_date: datetime = None) -> None:
+        """Validate milestone creation according to business rules."""
+        if not title or not title.strip():
+            raise ProjectValidationError(
+                "Milestone title cannot be empty",
+                field="title",
+                value=title
+            )
+
+        if len(title) > 100:
+            raise ProjectValidationError(
+                "Milestone title cannot exceed 100 characters",
+                field="title",
+                value=title
+            )
+
+        # Business rule: Due date cannot be in the past
+        if due_date and due_date < datetime.utcnow():
+            raise ProjectValidationError(
+                "Milestone due date cannot be in the past",
+                field="due_date",
+                value=due_date
+            )
+
+    def calculate_milestone_priority(self, milestone: Milestone) -> int:
+        """Calculate milestone priority based on business rules."""
+        priority_score = 0
+
+        # Higher priority for milestones with more issues
+        priority_score += milestone.total_issues * 2
+
+        # Higher priority for milestones with due dates
+        if milestone.due_date:
+            days_until_due = (milestone.due_date - datetime.utcnow()).days
+            if days_until_due <= 7:
+                priority_score += 50  # Very urgent
+            elif days_until_due <= 30:
+                priority_score += 25  # Urgent
+            else:
+                priority_score += 10  # Normal
+
+        # Higher priority for milestones closer to completion
+        if milestone.completion_percentage >= 75:
+            priority_score += 30  # Push to completion
+
+        # Lower priority for stalled milestones
+        if milestone.total_issues > 0 and milestone.completion_percentage == 0:
+            priority_score -= 20
+
+        return max(0, priority_score)  # Ensure non-negative
+
+    def generate_project_summary(self, project: Project) -> Dict[str, Any]:
+        """Generate a comprehensive project summary."""
+        health = self.determine_project_health(project)
+        bottlenecks = self.identify_bottlenecks(project)
+        recommendations = self.recommend_next_actions(project)
+
+        return {
+            "name": project.name,
+            "state": project.state.value,
+            "health": health,
+            "overall_progress": project.calculate_overall_progress(),
+            "total_milestones": len(project.milestones),
+            "active_milestones": len(project.get_active_milestones()),
+            "completed_milestones": len(project.get_completed_milestones()),
+            "overdue_milestones": len(project.get_overdue_milestones()),
+            "total_issues": project.get_total_issues(),
+            "open_issues": project.get_total_open_issues(),
+            "closed_issues": project.get_total_closed_issues(),
+            "bottlenecks": bottlenecks,
+            "recommendations": recommendations
+        }
\ No newline at end of file
diff --git a/infrastructure/__init__.py b/infrastructure/__init__.py
new file mode 100644
index 00000000..94125e11
--- /dev/null
+++ b/infrastructure/__init__.py
@@ -0,0 +1,5 @@
+"""
+Infrastructure layer for MarkiTect project.
+
+Contains concrete implementations of repositories and external system integrations.
+"""
\ No newline at end of file
diff --git a/infrastructure/repositories/__init__.py b/infrastructure/repositories/__init__.py
new file mode 100644
index 00000000..ac81f402
--- /dev/null
+++ b/infrastructure/repositories/__init__.py
@@ -0,0 +1,3 @@
+"""
+Repository implementations for external systems.
+"""
\ No newline at end of file
diff --git a/tests/unit/domain/issues/test_issue_models.py b/tests/unit/domain/issues/test_issue_models.py
new file mode 100644
index 00000000..1906f175
--- /dev/null
+++ b/tests/unit/domain/issues/test_issue_models.py
@@ -0,0 +1,287 @@
+"""
+Unit tests for Issue domain models.
+
+Tests pure business logic with no external dependencies.
+"""
+
+import pytest
+from datetime import datetime, timedelta
+
+from domain.issues.models import Issue, Label, IssueState, LabelCategories
+from domain.issues.exceptions import IssueStateError
+
+
+class TestLabel:
+    """Test Label value object."""
+
+    def test_label_creation(self):
+        # Arrange & Act
+        label = Label(name="bug", color="#ff0000", description="Bug label")
+
+        # Assert
+        assert label.name == "bug"
+        assert label.color == "#ff0000"
+        assert label.description == "Bug label"
+
+    def test_is_state_label(self):
+        # Arrange
+        state_label = Label("status:in-progress")
+        regular_label = Label("bug")
+
+        # Act & Assert
+        assert state_label.is_state_label() is True
+        assert regular_label.is_state_label() is False
+
+    def test_is_priority_label(self):
+        # Arrange
+        priority_label = Label("priority:high")
+        regular_label = Label("bug")
+
+        # Act & Assert
+        assert priority_label.is_priority_label() is True
+        assert regular_label.is_priority_label() is False
+
+    def test_is_type_label(self):
+        # Arrange
+        type_label = Label("bug")
+        priority_label = Label("priority:high")
+
+        # Act & Assert
+        assert type_label.is_type_label() is True
+        assert priority_label.is_type_label() is False
+
+    @pytest.mark.parametrize("label_name,expected", [
+        ("bug", True),
+        ("enhancement", True),
+        ("feature", True),
+        ("documentation", True),
+        ("custom-label", False),
+        ("priority:high", False)
+    ])
+    def test_type_label_recognition(self, label_name, expected):
+        # Arrange
+        label = Label(label_name)
+
+        # Act & Assert
+        assert label.is_type_label() == expected
+
+
+class TestIssue:
+    """Test Issue aggregate root."""
+
+    def test_issue_creation_with_valid_data(self):
+        # Arrange
+        created_at = datetime.utcnow()
+        updated_at = datetime.utcnow()
+        labels = [Label("bug"), Label("priority:high")]
+
+        # Act
+        issue = Issue(
+            number=123,
+            title="Test Issue",
+            state=IssueState.OPEN,
+            labels=labels,
+            created_at=created_at,
+            updated_at=updated_at
+        )
+
+        # Assert
+        assert issue.number == 123
+        assert issue.title == "Test Issue"
+        assert issue.state == IssueState.OPEN
+        assert len(issue.labels) == 2
+        assert issue.created_at == created_at
+        assert issue.updated_at == updated_at
+
+    def test_categorize_labels_correctly_separates_types(self):
+        # Arrange
+        labels = [
+            Label("bug"),                # type label
+            Label("priority:high"),      # priority label
+            Label("status:in-progress"), # state label
+            Label("documentation"),      # type label
+            Label("custom-label")        # other label
+        ]
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.OPEN,
+            labels=labels,
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act
+        categories = issue.categorize_labels()
+
+        # Assert
+        assert "bug" in categories.type_labels
+        assert "documentation" in categories.type_labels
+        assert "priority:high" in categories.priority_labels
+        assert "status:in-progress" in categories.state_labels
+        assert "custom-label" in categories.other_labels
+
+    def test_close_issue_changes_state_and_sets_closed_at(self):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.OPEN,
+            labels=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act
+        issue.close()
+
+        # Assert
+        assert issue.state == IssueState.CLOSED
+        assert issue.closed_at is not None
+        assert isinstance(issue.closed_at, datetime)
+
+    def test_close_already_closed_issue_raises_error(self):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.CLOSED,
+            labels=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow(),
+            closed_at=datetime.utcnow()
+        )
+
+        # Act & Assert
+        with pytest.raises(IssueStateError) as exc_info:
+            issue.close()
+
+        assert "Issue is already closed" in str(exc_info.value)
+        assert exc_info.value.current_state == "closed"
+        assert exc_info.value.attempted_state == "closed"
+
+    def test_reopen_closed_issue_changes_state_and_clears_closed_at(self):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.CLOSED,
+            labels=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow(),
+            closed_at=datetime.utcnow()
+        )
+
+        # Act
+        issue.reopen()
+
+        # Assert
+        assert issue.state == IssueState.OPEN
+        assert issue.closed_at is None
+
+    def test_reopen_open_issue_raises_error(self):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.OPEN,
+            labels=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act & Assert
+        with pytest.raises(IssueStateError) as exc_info:
+            issue.reopen()
+
+        assert "Issue is not closed" in str(exc_info.value)
+
+    def test_add_label_to_issue(self):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.OPEN,
+            labels=[Label("bug")],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+        new_label = Label("priority:high")
+
+        # Act
+        issue.add_label(new_label)
+
+        # Assert
+        assert len(issue.labels) == 2
+        assert new_label in issue.labels
+
+    def test_add_duplicate_label_does_not_duplicate(self):
+        # Arrange
+        label = Label("bug")
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.OPEN,
+            labels=[label],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act
+        issue.add_label(label)
+
+        # Assert
+        assert len(issue.labels) == 1
+
+    def test_remove_label_from_issue(self):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.OPEN,
+            labels=[Label("bug"), Label("priority:high")],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act
+        issue.remove_label("bug")
+
+        # Assert
+        assert len(issue.labels) == 1
+        assert not any(label.name == "bug" for label in issue.labels)
+
+    def test_has_label_returns_correct_value(self):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.OPEN,
+            labels=[Label("bug"), Label("priority:high")],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act & Assert
+        assert issue.has_label("bug") is True
+        assert issue.has_label("priority:high") is True
+        assert issue.has_label("enhancement") is False
+
+
+class TestLabelCategories:
+    """Test LabelCategories value object."""
+
+    def test_label_categories_creation(self):
+        # Arrange & Act
+        categories = LabelCategories(
+            state_labels=["status:open"],
+            priority_labels=["priority:high"],
+            type_labels=["bug"],
+            other_labels=["custom"]
+        )
+
+        # Assert
+        assert categories.state_labels == ["status:open"]
+        assert categories.priority_labels == ["priority:high"]
+        assert categories.type_labels == ["bug"]
+        assert categories.other_labels == ["custom"]
\ No newline at end of file
diff --git a/tests/unit/domain/issues/test_issue_services.py b/tests/unit/domain/issues/test_issue_services.py
new file mode 100644
index 00000000..49e1695e
--- /dev/null
+++ b/tests/unit/domain/issues/test_issue_services.py
@@ -0,0 +1,368 @@
+"""
+Unit tests for Issue domain services.
+
+Tests business logic in issue services with no external dependencies.
+"""
+
+import pytest
+from datetime import datetime, timedelta
+
+from domain.issues.models import Issue, Label, IssueState
+from domain.issues.services import IssueStatusService, IssueValidationService
+from domain.issues.exceptions import IssueValidationError
+
+
+class TestIssueStatusService:
+    """Test business logic in issue status service."""
+
+    @pytest.fixture
+    def service(self):
+        return IssueStatusService()
+
+    def test_determine_kanban_column_for_closed_issue(self, service):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="Closed Issue",
+            state=IssueState.CLOSED,
+            labels=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+        project_info = {"kanban_columns": ["Todo", "In Progress", "Review", "Done"]}
+
+        # Act
+        column = service.determine_kanban_column(issue, project_info)
+
+        # Assert
+        assert column == "Done"
+
+    @pytest.mark.parametrize("status_label,expected_column", [
+        ("status:in-progress", "In Progress"),
+        ("status:review", "Review"),
+        ("status:blocked", "Blocked"),
+        ("status:ready", "Ready"),
+    ])
+    def test_determine_kanban_column_based_on_status_labels(self, service, status_label, expected_column):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="Test Issue",
+            state=IssueState.OPEN,
+            labels=[Label(status_label)],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+        project_info = {"kanban_columns": ["Todo", "In Progress", "Review", "Blocked", "Ready", "Done"]}
+
+        # Act
+        column = service.determine_kanban_column(issue, project_info)
+
+        # Assert
+        assert column == expected_column
+
+    def test_determine_kanban_column_defaults_to_todo(self, service):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="New Issue",
+            state=IssueState.OPEN,
+            labels=[Label("bug")],  # No status label
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+        project_info = {"kanban_columns": ["Todo", "In Progress", "Done"]}
+
+        # Act
+        column = service.determine_kanban_column(issue, project_info)
+
+        # Assert
+        assert column == "Todo"
+
+    @pytest.mark.parametrize("priority_label,expected_level", [
+        ("priority:low", "Low"),
+        ("priority:medium", "Medium"),
+        ("priority:high", "High"),
+        ("priority:critical", "Critical"),
+    ])
+    def test_extract_priority_info_with_priority_labels(self, service, priority_label, expected_level):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.OPEN,
+            labels=[Label(priority_label)],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act
+        priority_info = service.extract_priority_info(issue)
+
+        # Assert
+        assert priority_info["level"] == expected_level
+        assert priority_info["label"] == priority_label
+
+    def test_extract_priority_info_defaults_to_medium(self, service):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.OPEN,
+            labels=[Label("bug")],  # No priority label
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act
+        priority_info = service.extract_priority_info(issue)
+
+        # Assert
+        assert priority_info["level"] == "Medium"
+        assert priority_info["label"] is None
+
+    def test_extract_state_info_for_open_issue(self, service):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.OPEN,
+            labels=[Label("status:in-progress")],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act
+        state_info = service.extract_state_info(issue)
+
+        # Assert
+        assert state_info["state"] == "open"
+        assert state_info["state_labels"] == ["status:in-progress"]
+        assert state_info["is_closed"] is False
+        assert state_info["closed_at"] is None
+
+    def test_extract_state_info_for_closed_issue(self, service):
+        # Arrange
+        closed_at = datetime.utcnow()
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.CLOSED,
+            labels=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow(),
+            closed_at=closed_at
+        )
+
+        # Act
+        state_info = service.extract_state_info(issue)
+
+        # Assert
+        assert state_info["state"] == "closed"
+        assert state_info["is_closed"] is True
+        assert state_info["closed_at"] == closed_at.isoformat()
+
+    def test_calculate_issue_age_days(self, service):
+        # Arrange
+        created_at = datetime.utcnow() - timedelta(days=5)
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.OPEN,
+            labels=[],
+            created_at=created_at,
+            updated_at=datetime.utcnow()
+        )
+
+        # Act
+        age_days = service.calculate_issue_age_days(issue)
+
+        # Assert
+        assert age_days == 5
+
+    def test_is_stale_issue_with_old_open_issue(self, service):
+        # Arrange
+        created_at = datetime.utcnow() - timedelta(days=45)
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.OPEN,
+            labels=[],
+            created_at=created_at,
+            updated_at=datetime.utcnow()
+        )
+
+        # Act
+        is_stale = service.is_stale_issue(issue, stale_threshold_days=30)
+
+        # Assert
+        assert is_stale is True
+
+    def test_is_stale_issue_with_recent_open_issue(self, service):
+        # Arrange
+        created_at = datetime.utcnow() - timedelta(days=15)
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.OPEN,
+            labels=[],
+            created_at=created_at,
+            updated_at=datetime.utcnow()
+        )
+
+        # Act
+        is_stale = service.is_stale_issue(issue, stale_threshold_days=30)
+
+        # Assert
+        assert is_stale is False
+
+    def test_is_stale_issue_with_closed_issue_never_stale(self, service):
+        # Arrange
+        created_at = datetime.utcnow() - timedelta(days=100)
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.CLOSED,
+            labels=[],
+            created_at=created_at,
+            updated_at=datetime.utcnow(),
+            closed_at=datetime.utcnow()
+        )
+
+        # Act
+        is_stale = service.is_stale_issue(issue, stale_threshold_days=30)
+
+        # Assert
+        assert is_stale is False
+
+
+class TestIssueValidationService:
+    """Test business logic in issue validation service."""
+
+    @pytest.fixture
+    def service(self):
+        return IssueValidationService()
+
+    def test_validate_issue_creation_with_valid_data(self, service):
+        # Arrange
+        title = "Valid Issue Title"
+        labels = ["bug", "priority:high"]
+
+        # Act & Assert - Should not raise exception
+        service.validate_issue_creation(title, labels)
+
+    def test_validate_issue_creation_with_empty_title_raises_error(self, service):
+        # Arrange
+        title = ""
+        labels = ["bug"]
+
+        # Act & Assert
+        with pytest.raises(IssueValidationError) as exc_info:
+            service.validate_issue_creation(title, labels)
+
+        assert "Issue title cannot be empty" in str(exc_info.value)
+        assert exc_info.value.field == "title"
+
+    def test_validate_issue_creation_with_whitespace_only_title_raises_error(self, service):
+        # Arrange
+        title = "   "
+        labels = ["bug"]
+
+        # Act & Assert
+        with pytest.raises(IssueValidationError) as exc_info:
+            service.validate_issue_creation(title, labels)
+
+        assert "Issue title cannot be empty" in str(exc_info.value)
+
+    def test_validate_issue_creation_with_too_long_title_raises_error(self, service):
+        # Arrange
+        title = "x" * 256  # Too long
+        labels = ["bug"]
+
+        # Act & Assert
+        with pytest.raises(IssueValidationError) as exc_info:
+            service.validate_issue_creation(title, labels)
+
+        assert "Issue title cannot exceed 255 characters" in str(exc_info.value)
+
+    def test_validate_issue_creation_with_multiple_priority_labels_raises_error(self, service):
+        # Arrange
+        title = "Valid Title"
+        labels = ["bug", "priority:high", "priority:low"]
+
+        # Act & Assert
+        with pytest.raises(IssueValidationError) as exc_info:
+            service.validate_issue_creation(title, labels)
+
+        assert "Issue cannot have multiple priority labels" in str(exc_info.value)
+        assert exc_info.value.field == "labels"
+
+    def test_validate_issue_creation_with_multiple_state_labels_raises_error(self, service):
+        # Arrange
+        title = "Valid Title"
+        labels = ["bug", "status:open", "status:in-progress"]
+
+        # Act & Assert
+        with pytest.raises(IssueValidationError) as exc_info:
+            service.validate_issue_creation(title, labels)
+
+        assert "Issue cannot have multiple state labels" in str(exc_info.value)
+
+    def test_validate_title_update_with_valid_title(self, service):
+        # Arrange
+        new_title = "Updated Title"
+
+        # Act & Assert - Should not raise exception
+        service.validate_title_update(new_title)
+
+    def test_validate_label_addition_to_issue_without_conflicts(self, service):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.OPEN,
+            labels=[Label("bug")],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+        new_label = "enhancement"
+
+        # Act & Assert - Should not raise exception
+        service.validate_label_addition(issue, new_label)
+
+    def test_validate_label_addition_with_duplicate_label_raises_error(self, service):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.OPEN,
+            labels=[Label("bug")],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+        new_label = "bug"
+
+        # Act & Assert
+        with pytest.raises(IssueValidationError) as exc_info:
+            service.validate_label_addition(issue, new_label)
+
+        assert "Issue already has label 'bug'" in str(exc_info.value)
+
+    def test_validate_label_addition_with_conflicting_priority_raises_error(self, service):
+        # Arrange
+        issue = Issue(
+            number=1,
+            title="Test",
+            state=IssueState.OPEN,
+            labels=[Label("priority:high")],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+        new_label = "priority:low"
+
+        # Act & Assert
+        with pytest.raises(IssueValidationError) as exc_info:
+            service.validate_label_addition(issue, new_label)
+
+        assert "Issue already has priority label" in str(exc_info.value)
+        assert "Cannot add 'priority:low'" in str(exc_info.value)
\ No newline at end of file
diff --git a/tests/unit/domain/projects/test_project_models.py b/tests/unit/domain/projects/test_project_models.py
new file mode 100644
index 00000000..92440b37
--- /dev/null
+++ b/tests/unit/domain/projects/test_project_models.py
@@ -0,0 +1,607 @@
+"""
+Unit tests for Project domain models.
+
+Tests pure business logic with no external dependencies.
+"""
+
+import pytest
+from datetime import datetime, timedelta
+
+from domain.projects.models import Project, Milestone, ProjectState
+from domain.projects.exceptions import MilestoneError
+
+
+class TestMilestone:
+    """Test Milestone entity."""
+
+    def test_milestone_creation(self):
+        # Arrange
+        due_date = datetime.utcnow() + timedelta(days=30)
+
+        # Act
+        milestone = Milestone(
+            id=1,
+            title="Version 1.0",
+            description="First release",
+            due_date=due_date,
+            state="open",
+            open_issues=5,
+            closed_issues=3
+        )
+
+        # Assert
+        assert milestone.id == 1
+        assert milestone.title == "Version 1.0"
+        assert milestone.description == "First release"
+        assert milestone.due_date == due_date
+        assert milestone.state == "open"
+        assert milestone.open_issues == 5
+        assert milestone.closed_issues == 3
+
+    def test_completion_percentage_calculation(self):
+        # Arrange
+        milestone = Milestone(
+            id=1,
+            title="Test",
+            description=None,
+            due_date=None,
+            state="open",
+            open_issues=2,
+            closed_issues=8
+        )
+
+        # Act
+        percentage = milestone.completion_percentage
+
+        # Assert
+        assert percentage == 80.0  # 8/(2+8) * 100
+
+    def test_completion_percentage_with_no_issues(self):
+        # Arrange
+        milestone = Milestone(
+            id=1,
+            title="Test",
+            description=None,
+            due_date=None,
+            state="open",
+            open_issues=0,
+            closed_issues=0
+        )
+
+        # Act
+        percentage = milestone.completion_percentage
+
+        # Assert
+        assert percentage == 0.0
+
+    def test_total_issues_property(self):
+        # Arrange
+        milestone = Milestone(
+            id=1,
+            title="Test",
+            description=None,
+            due_date=None,
+            state="open",
+            open_issues=3,
+            closed_issues=7
+        )
+
+        # Act & Assert
+        assert milestone.total_issues == 10
+
+    def test_is_overdue_with_past_due_date(self):
+        # Arrange
+        past_date = datetime.utcnow() - timedelta(days=1)
+        milestone = Milestone(
+            id=1,
+            title="Test",
+            description=None,
+            due_date=past_date,
+            state="open",
+            open_issues=1,
+            closed_issues=0
+        )
+
+        # Act & Assert
+        assert milestone.is_overdue() is True
+
+    def test_is_overdue_with_future_due_date(self):
+        # Arrange
+        future_date = datetime.utcnow() + timedelta(days=1)
+        milestone = Milestone(
+            id=1,
+            title="Test",
+            description=None,
+            due_date=future_date,
+            state="open",
+            open_issues=1,
+            closed_issues=0
+        )
+
+        # Act & Assert
+        assert milestone.is_overdue() is False
+
+    def test_is_overdue_with_no_due_date(self):
+        # Arrange
+        milestone = Milestone(
+            id=1,
+            title="Test",
+            description=None,
+            due_date=None,
+            state="open",
+            open_issues=1,
+            closed_issues=0
+        )
+
+        # Act & Assert
+        assert milestone.is_overdue() is False
+
+    def test_is_overdue_with_closed_milestone(self):
+        # Arrange
+        past_date = datetime.utcnow() - timedelta(days=1)
+        milestone = Milestone(
+            id=1,
+            title="Test",
+            description=None,
+            due_date=past_date,
+            state="closed",
+            open_issues=0,
+            closed_issues=5
+        )
+
+        # Act & Assert
+        assert milestone.is_overdue() is False
+
+    def test_is_completed_with_closed_state(self):
+        # Arrange
+        milestone = Milestone(
+            id=1,
+            title="Test",
+            description=None,
+            due_date=None,
+            state="closed",
+            open_issues=0,
+            closed_issues=5
+        )
+
+        # Act & Assert
+        assert milestone.is_completed() is True
+
+    def test_is_completed_with_100_percent_completion(self):
+        # Arrange
+        milestone = Milestone(
+            id=1,
+            title="Test",
+            description=None,
+            due_date=None,
+            state="open",
+            open_issues=0,
+            closed_issues=5
+        )
+
+        # Act & Assert
+        assert milestone.is_completed() is True
+
+    def test_is_completed_with_partial_completion(self):
+        # Arrange
+        milestone = Milestone(
+            id=1,
+            title="Test",
+            description=None,
+            due_date=None,
+            state="open",
+            open_issues=2,
+            closed_issues=3
+        )
+
+        # Act & Assert
+        assert milestone.is_completed() is False
+
+    def test_add_issue_increments_open_count(self):
+        # Arrange
+        milestone = Milestone(
+            id=1,
+            title="Test",
+            description=None,
+            due_date=None,
+            state="open",
+            open_issues=3,
+            closed_issues=2
+        )
+
+        # Act
+        milestone.add_issue()
+
+        # Assert
+        assert milestone.open_issues == 4
+        assert milestone.closed_issues == 2
+
+    def test_close_issue_moves_from_open_to_closed(self):
+        # Arrange
+        milestone = Milestone(
+            id=1,
+            title="Test",
+            description=None,
+            due_date=None,
+            state="open",
+            open_issues=3,
+            closed_issues=2
+        )
+
+        # Act
+        milestone.close_issue()
+
+        # Assert
+        assert milestone.open_issues == 2
+        assert milestone.closed_issues == 3
+
+    def test_close_issue_with_no_open_issues_raises_error(self):
+        # Arrange
+        milestone = Milestone(
+            id=1,
+            title="Test",
+            description=None,
+            due_date=None,
+            state="open",
+            open_issues=0,
+            closed_issues=5
+        )
+
+        # Act & Assert
+        with pytest.raises(MilestoneError) as exc_info:
+            milestone.close_issue()
+
+        assert "no open issues" in str(exc_info.value)
+        assert exc_info.value.milestone_id == 1
+
+    def test_reopen_issue_moves_from_closed_to_open(self):
+        # Arrange
+        milestone = Milestone(
+            id=1,
+            title="Test",
+            description=None,
+            due_date=None,
+            state="open",
+            open_issues=2,
+            closed_issues=3
+        )
+
+        # Act
+        milestone.reopen_issue()
+
+        # Assert
+        assert milestone.open_issues == 3
+        assert milestone.closed_issues == 2
+
+    def test_reopen_issue_with_no_closed_issues_raises_error(self):
+        # Arrange
+        milestone = Milestone(
+            id=1,
+            title="Test",
+            description=None,
+            due_date=None,
+            state="open",
+            open_issues=5,
+            closed_issues=0
+        )
+
+        # Act & Assert
+        with pytest.raises(MilestoneError) as exc_info:
+            milestone.reopen_issue()
+
+        assert "no closed issues" in str(exc_info.value)
+        assert exc_info.value.milestone_id == 1
+
+
+class TestProject:
+    """Test Project aggregate root."""
+
+    def test_project_creation(self):
+        # Arrange
+        created_at = datetime.utcnow()
+        updated_at = datetime.utcnow()
+        milestones = [
+            Milestone(1, "M1", None, None, "open", 2, 1),
+            Milestone(2, "M2", None, None, "closed", 0, 3)
+        ]
+
+        # Act
+        project = Project(
+            name="Test Project",
+            description="A test project",
+            state=ProjectState.ACTIVE,
+            milestones=milestones,
+            kanban_columns=["Todo", "In Progress", "Done"],
+            created_at=created_at,
+            updated_at=updated_at
+        )
+
+        # Assert
+        assert project.name == "Test Project"
+        assert project.description == "A test project"
+        assert project.state == ProjectState.ACTIVE
+        assert len(project.milestones) == 2
+        assert project.kanban_columns == ["Todo", "In Progress", "Done"]
+
+    def test_get_active_milestones(self):
+        # Arrange
+        milestones = [
+            Milestone(1, "M1", None, None, "open", 2, 1),
+            Milestone(2, "M2", None, None, "closed", 0, 3),
+            Milestone(3, "M3", None, None, "open", 1, 0)
+        ]
+        project = Project(
+            name="Test",
+            description="",
+            state=ProjectState.ACTIVE,
+            milestones=milestones,
+            kanban_columns=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act
+        active_milestones = project.get_active_milestones()
+
+        # Assert
+        assert len(active_milestones) == 2
+        assert all(m.state == "open" for m in active_milestones)
+
+    def test_get_completed_milestones(self):
+        # Arrange
+        milestones = [
+            Milestone(1, "M1", None, None, "open", 2, 1),  # Not completed
+            Milestone(2, "M2", None, None, "closed", 0, 3),  # Completed (closed)
+            Milestone(3, "M3", None, None, "open", 0, 5)  # Completed (100%)
+        ]
+        project = Project(
+            name="Test",
+            description="",
+            state=ProjectState.ACTIVE,
+            milestones=milestones,
+            kanban_columns=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act
+        completed_milestones = project.get_completed_milestones()
+
+        # Assert
+        assert len(completed_milestones) == 2
+
+    def test_get_overdue_milestones(self):
+        # Arrange
+        past_date = datetime.utcnow() - timedelta(days=1)
+        future_date = datetime.utcnow() + timedelta(days=1)
+        milestones = [
+            Milestone(1, "M1", None, past_date, "open", 2, 1),  # Overdue
+            Milestone(2, "M2", None, future_date, "open", 1, 0),  # Not overdue
+            Milestone(3, "M3", None, None, "open", 1, 0)  # No due date
+        ]
+        project = Project(
+            name="Test",
+            description="",
+            state=ProjectState.ACTIVE,
+            milestones=milestones,
+            kanban_columns=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act
+        overdue_milestones = project.get_overdue_milestones()
+
+        # Assert
+        assert len(overdue_milestones) == 1
+        assert overdue_milestones[0].id == 1
+
+    def test_calculate_overall_progress(self):
+        # Arrange
+        milestones = [
+            Milestone(1, "M1", None, None, "open", 1, 4),  # 80% complete
+            Milestone(2, "M2", None, None, "open", 3, 2)   # 40% complete
+        ]
+        project = Project(
+            name="Test",
+            description="",
+            state=ProjectState.ACTIVE,
+            milestones=milestones,
+            kanban_columns=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act
+        progress = project.calculate_overall_progress()
+
+        # Assert
+        assert progress == 60.0  # (80 + 40) / 2
+
+    def test_calculate_overall_progress_with_no_milestones(self):
+        # Arrange
+        project = Project(
+            name="Test",
+            description="",
+            state=ProjectState.ACTIVE,
+            milestones=[],
+            kanban_columns=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act
+        progress = project.calculate_overall_progress()
+
+        # Assert
+        assert progress == 0.0
+
+    def test_get_total_issues(self):
+        # Arrange
+        milestones = [
+            Milestone(1, "M1", None, None, "open", 2, 3),  # 5 total
+            Milestone(2, "M2", None, None, "open", 1, 4)   # 5 total
+        ]
+        project = Project(
+            name="Test",
+            description="",
+            state=ProjectState.ACTIVE,
+            milestones=milestones,
+            kanban_columns=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act & Assert
+        assert project.get_total_issues() == 10
+        assert project.get_total_open_issues() == 3
+        assert project.get_total_closed_issues() == 7
+
+    def test_archive_project(self):
+        # Arrange
+        project = Project(
+            name="Test",
+            description="",
+            state=ProjectState.ACTIVE,
+            milestones=[],
+            kanban_columns=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act
+        project.archive()
+
+        # Assert
+        assert project.state == ProjectState.ARCHIVED
+        assert project.archived_at is not None
+
+    def test_activate_project(self):
+        # Arrange
+        project = Project(
+            name="Test",
+            description="",
+            state=ProjectState.ARCHIVED,
+            milestones=[],
+            kanban_columns=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow(),
+            archived_at=datetime.utcnow()
+        )
+
+        # Act
+        project.activate()
+
+        # Assert
+        assert project.state == ProjectState.ACTIVE
+        assert project.archived_at is None
+
+    def test_add_milestone(self):
+        # Arrange
+        project = Project(
+            name="Test",
+            description="",
+            state=ProjectState.ACTIVE,
+            milestones=[],
+            kanban_columns=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+        milestone = Milestone(1, "New Milestone", None, None, "open", 0, 0)
+
+        # Act
+        project.add_milestone(milestone)
+
+        # Assert
+        assert len(project.milestones) == 1
+        assert project.milestones[0] == milestone
+
+    def test_add_duplicate_milestone_raises_error(self):
+        # Arrange
+        milestone1 = Milestone(1, "Milestone 1", None, None, "open", 0, 0)
+        milestone2 = Milestone(1, "Milestone 2", None, None, "open", 0, 0)  # Same ID
+        project = Project(
+            name="Test",
+            description="",
+            state=ProjectState.ACTIVE,
+            milestones=[milestone1],
+            kanban_columns=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act & Assert
+        with pytest.raises(ValueError, match="Milestone with ID 1 already exists"):
+            project.add_milestone(milestone2)
+
+    def test_remove_milestone(self):
+        # Arrange
+        milestone = Milestone(1, "Milestone", None, None, "open", 0, 0)
+        project = Project(
+            name="Test",
+            description="",
+            state=ProjectState.ACTIVE,
+            milestones=[milestone],
+            kanban_columns=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act
+        project.remove_milestone(1)
+
+        # Assert
+        assert len(project.milestones) == 0
+
+    def test_remove_nonexistent_milestone_raises_error(self):
+        # Arrange
+        project = Project(
+            name="Test",
+            description="",
+            state=ProjectState.ACTIVE,
+            milestones=[],
+            kanban_columns=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act & Assert
+        with pytest.raises(ValueError, match="Milestone with ID 999 not found"):
+            project.remove_milestone(999)
+
+    def test_get_milestone(self):
+        # Arrange
+        milestone = Milestone(1, "Milestone", None, None, "open", 0, 0)
+        project = Project(
+            name="Test",
+            description="",
+            state=ProjectState.ACTIVE,
+            milestones=[milestone],
+            kanban_columns=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act
+        found_milestone = project.get_milestone(1)
+
+        # Assert
+        assert found_milestone == milestone
+
+    def test_get_nonexistent_milestone_returns_none(self):
+        # Arrange
+        project = Project(
+            name="Test",
+            description="",
+            state=ProjectState.ACTIVE,
+            milestones=[],
+            kanban_columns=[],
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+
+        # Act
+        found_milestone = project.get_milestone(999)
+
+        # Assert
+        assert found_milestone is None
\ No newline at end of file