diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 0c9c77e0..2285e3f7 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -343,14 +343,16 @@ jobs:
 
       - name: Initialize database
         run: |
-          mkdir -p .codeframe
+          # E2E tests expect database at tests/e2e/.codeframe/state.db
+          mkdir -p tests/e2e/.codeframe
           source .venv/bin/activate
-          python -c "from codeframe.persistence.database import Database; db = Database('.codeframe/state.db'); db.initialize(); db.close()"
-          echo "✅ Database initialized"
+          python -c "from codeframe.persistence.database import Database; db = Database('tests/e2e/.codeframe/state.db'); db.initialize(); db.close()"
+          echo "✅ Database initialized at tests/e2e/.codeframe/state.db"
 
       - name: Start backend server
         env:
-          DATABASE_PATH: ${{ github.workspace }}/.codeframe/state.db
+          # Must match TEST_DB_PATH in tests/e2e/e2e-config.ts
+          DATABASE_PATH: ${{ github.workspace }}/tests/e2e/.codeframe/state.db
           WORKSPACE_ROOT: ${{ github.workspace }}
           CODEFRAME_DEPLOYMENT_MODE: self_hosted
         run: |
diff --git a/.gitignore b/.gitignore
index 9cf30f91..2089c8ed 100644
--- a/.gitignore
+++ b/.gitignore
@@ -83,3 +83,5 @@ testsprite_tests/tmp/config.json
 tests/e2e/playwright-report/
 tests/e2e/test-results/
 tests/e2e/.auth/
+tests/e2e/.codeframe/
+test_audit_report.md
diff --git a/docs/TESTING_STRATEGY.md b/docs/TESTING_STRATEGY.md
new file mode 100644
index 00000000..5022d7dd
--- /dev/null
+++ b/docs/TESTING_STRATEGY.md
@@ -0,0 +1,267 @@
+# Testing Strategy for CodeFRAME
+
+This document outlines the testing philosophy, guidelines, and best practices for the CodeFRAME project.
+
+## Testing Philosophy
+
+### Core Principles
+
+1. **Real Implementations Over Mocks**: Prefer testing with real components when possible. Mocking should only be used for external services that are impractical to use in tests.
+
+2. **Mock Boundaries, Not Internals**: Only mock at system boundaries (external APIs, network calls). Never mock internal methods or classes to make tests pass.
+
+3. **Tests Should Fail When Code Breaks**: If removing a function or breaking logic doesn't cause a test to fail, the test is not valuable.
+
+4. **Integration Tests for Workflows**: Test complete workflows with real database and file operations. Unit tests should focus on pure logic.
+
+## Test Categories
+
+### Unit Tests
+- **Purpose**: Test individual functions and classes in isolation
+- **Mock Policy**: Mock only external I/O (network, external APIs)
+- **Location**: `tests/` directory (excluding `tests/integration/`)
+- **Run Command**: `pytest -m "not integration"`
+
+**Good Unit Test Example**:
+```python
+def test_sanitize_prompt_removes_special_chars():
+    """Test pure logic - no mocking needed."""
+    result = sanitize_prompt_input("Hello <script>alert()</script>")
+    assert "<script>" not in result
+```
+
+**Bad Unit Test Example**:
+```python
+@patch("module.execute_task")  # ❌ Mocking the method being tested!
+def test_execute_task(mock_execute):
+    mock_execute.return_value = {"status": "completed"}
+    result = execute_task(task)  # This tests nothing!
+    assert result["status"] == "completed"
+```
+
+### Integration Tests
+- **Purpose**: Test component interactions with real implementations
+- **Mock Policy**: Mock only external services (Anthropic API, OpenAI, GitHub)
+- **Location**: `tests/integration/`
+- **Run Command**: `pytest -m integration`
+
+**Good Integration Test Example**:
+```python
+@pytest.mark.integration
+async def test_token_usage_recorded_in_database(real_db):
+    """Uses real database to verify token tracking works."""
+    agent = WorkerAgent(db=real_db, agent_id="test-agent")
+
+    # Mock only the external LLM API
+    with patch("anthropic.AsyncAnthropic") as mock_api:
+        mock_api.return_value.messages.create.return_value = mock_response
+        result = await agent.execute_task(task)
+
+    # Verify real database was updated
+    cursor = real_db.conn.cursor()
+    cursor.execute("SELECT * FROM token_usage WHERE task_id = ?", (task.id,))
+    assert cursor.fetchone() is not None
+```
+
+### End-to-End Tests (E2E)
+- **Purpose**: Test complete user workflows through the UI
+- **Mock Policy**: None - tests real system end-to-end
+- **Location**: `e2e/` directory
+- **Run Command**: `npx playwright test`
+
+## What to Mock (and What Not to Mock)
+
+### ✅ Acceptable to Mock
+
+| Component | Why |
+|-----------|-----|
+| `AsyncAnthropic` | External API, costs money, rate limited |
+| `AsyncOpenAI` | External API, costs money, rate limited |
+| `github.Github` | External API, requires auth |
+| `requests.get/post` | External network calls |
+| `httpx.AsyncClient` | External network calls |
+| `subprocess.run` for external tools | Only for CI tools that aren't installed |
+
+### ❌ Never Mock These
+
+| Component | Why |
+|-----------|-----|
+| `Database` class | Core functionality, use `:memory:` SQLite |
+| `execute_task()` | Core agent functionality being tested |
+| `apply_file_changes()` | Core file operation logic |
+| `QualityGates.run_*_gate()` | Quality enforcement logic |
+| Repository classes | Use real in-memory database |
+| Internal helper methods | Test through public interface |
+
+## Test Fixtures
+
+### Database Fixtures
+
+```python
+# Real in-memory database - use for most integration tests
+@pytest.fixture
+def real_db():
+    db = Database(":memory:")
+    db.initialize()
+    yield db
+    db.conn.close()
+
+# File-backed database - use when testing persistence
+@pytest.fixture
+def real_db_file(tmp_path):
+    db_path = tmp_path / "test.db"
+    db = Database(str(db_path))
+    db.initialize()
+    yield db
+    db.conn.close()
+```
+
+### LLM Mock Fixtures
+
+```python
+@pytest.fixture
+def mock_anthropic_api():
+    with patch("anthropic.AsyncAnthropic") as mock:
+        mock_client = AsyncMock()
+        mock_response = Mock()
+        mock_response.content = [Mock(text="Task completed")]
+        mock_response.usage = Mock(input_tokens=100, output_tokens=50)
+        mock_client.messages.create.return_value = mock_response
+        mock.return_value = mock_client
+        yield mock_client
+```
+
+### Workspace Fixtures
+
+```python
+@pytest.fixture
+def test_workspace(tmp_path):
+    """Real temp directory for file operations."""
+    workspace = tmp_path / "workspace"
+    workspace.mkdir()
+    (workspace / "src").mkdir()
+    (workspace / "tests").mkdir()
+    yield workspace
+```
+
+## Running Tests
+
+### Quick Commands
+
+```bash
+# Run all tests
+uv run pytest
+
+# Run only unit tests (fast)
+uv run pytest -m "not integration and not slow"
+
+# Run only integration tests
+uv run pytest -m integration
+
+# Run tests with coverage
+uv run pytest --cov=codeframe --cov-report=html
+
+# Run specific test file
+uv run pytest tests/integration/test_worker_agent_execution.py -v
+
+# Run tests matching a pattern
+uv run pytest -k "token_usage" -v
+```
+
+### CI Configuration
+
+The CI pipeline should run tests in this order:
+
+1. **Lint & Type Check** (fastest)
+   ```bash
+   ruff check .
+   mypy codeframe/
+   ```
+
+2. **Unit Tests** (fast, ~30 seconds)
+   ```bash
+   pytest -m "not integration and not slow and not e2e"
+   ```
+
+3. **Integration Tests** (medium, ~2 minutes)
+   ```bash
+   pytest -m integration
+   ```
+
+4. **E2E Tests** (slow, ~5 minutes)
+   ```bash
+   npx playwright test
+   ```
+
+## Writing New Tests
+
+### Test Naming Convention
+
+```python
+# Unit test: test_{method_name}_{scenario}
+def test_sanitize_prompt_removes_html_tags():
+    ...
+
+# Integration test: test_{workflow}_{expected_outcome}
+async def test_token_usage_recorded_after_task_execution():
+    ...
+
+# E2E test: test_{user_story}
+def test_user_can_create_project_and_run_first_task():
+    ...
+```
+
+### Test Structure (Arrange-Act-Assert)
+
+```python
+async def test_example(real_db):
+    # Arrange - Setup test data and dependencies
+    project_id = real_db.create_project(name="test", ...)
+    agent = WorkerAgent(db=real_db, ...)
+
+    # Act - Perform the action being tested
+    with patch("anthropic.AsyncAnthropic") as mock_api:
+        result = await agent.execute_task(task)
+
+    # Assert - Verify the expected outcome
+    assert result["status"] == "completed"
+    cursor = real_db.conn.cursor()
+    cursor.execute("SELECT * FROM token_usage")
+    assert cursor.fetchone() is not None
+```
+
+## Audit Tool
+
+Use the test audit script to identify over-mocked tests:
+
+```bash
+python scripts/audit_mocked_tests.py
+```
+
+This generates a report categorizing tests by mock severity:
+- **HIGH**: Tests that mock core functionality (need rewrite)
+- **MEDIUM**: Tests with heavy mocking (review needed)
+- **LOW**: Acceptable mocking (external services only)
+
+## Coverage Goals
+
+- **Overall**: ≥85% line coverage
+- **Core modules** (`agents/`, `lib/`, `persistence/`): ≥90%
+- **UI components**: ≥70%
+
+## Troubleshooting
+
+### "Test passes but shouldn't"
+- Check if you're mocking the method being tested
+- Run the audit script to find over-mocked tests
+- Verify the test actually exercises the code path
+
+### "Integration test is flaky"
+- Ensure proper cleanup in fixtures
+- Check for shared state between tests
+- Use isolated database instances per test
+
+### "Test is too slow"
+- Move to integration tests if it needs real I/O
+- Mock only external calls, not internal logic
+- Consider using `pytest-xdist` for parallelization
diff --git a/pytest.ini b/pytest.ini
index 3f4f88ca..92b12412 100644
--- a/pytest.ini
+++ b/pytest.ini
@@ -33,13 +33,23 @@ addopts =
 # Markers for test categorization
 markers =
     slow: marks tests as slow (deselect with '-m "not slow"')
-    integration: marks tests as integration tests
-    unit: marks tests as unit tests
+    integration: marks tests as integration tests (use real DB and components)
+    unit: marks tests as unit tests (mock external dependencies)
     requires_api_key: marks tests that require API keys
     requires_db: marks tests that require database
+    requires_subprocess: marks tests that execute subprocess commands
     e2e: marks tests as end-to-end tests
     asyncio: marks tests as async tests
 
+# To run only unit tests (fast):
+#   pytest -m "not integration and not slow and not e2e"
+#
+# To run only integration tests:
+#   pytest -m integration
+#
+# To run all tests except slow ones:
+#   pytest -m "not slow"
+
 # Coverage warnings
 filterwarnings =
     error::DeprecationWarning
diff --git a/scripts/audit_mocked_tests.py b/scripts/audit_mocked_tests.py
new file mode 100644
index 00000000..6fe67119
--- /dev/null
+++ b/scripts/audit_mocked_tests.py
@@ -0,0 +1,527 @@
+#!/usr/bin/env python3
+"""
+Test Mocking Audit Script
+
+Scans all test files to identify excessive mocking patterns and generates
+a report categorizing tests by their mocking severity.
+
+Categories:
+- HIGH: Tests that mock core functionality being tested (false positives)
+- MEDIUM: Tests with heavy mocking that may hide integration issues
+- LOW: Tests with appropriate mocking of external services only
+
+Usage:
+    python scripts/audit_mocked_tests.py [--output report.md] [--json]
+"""
+
+import ast
+import json
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class MockPattern:
+    """Represents a detected mock pattern in a test."""
+
+    name: str
+    line_number: int
+    mock_type: str  # 'patch', 'Mock', 'MagicMock', 'AsyncMock', 'patch.object'
+    target: str  # What is being mocked
+    severity: str  # 'high', 'medium', 'low'
+    reason: str
+
+
+@dataclass
+class TestInfo:
+    """Information about a single test function."""
+
+    name: str
+    class_name: str | None
+    file_path: str
+    line_number: int
+    mock_patterns: list[MockPattern] = field(default_factory=list)
+    severity: str = "low"
+    recommendation: str = ""
+
+
+@dataclass
+class AuditResult:
+    """Complete audit result for all test files."""
+
+    tests: list[TestInfo] = field(default_factory=list)
+    summary: dict[str, int] = field(default_factory=dict)
+    files_analyzed: int = 0
+
+
+# Patterns that indicate excessive mocking (mocking core functionality)
+CORE_FUNCTIONALITY_PATTERNS = [
+    # Database operations - should use real in-memory database
+    ("codeframe.persistence.database.Database", "database operations"),
+    ("db.create_", "database creation methods"),
+    ("db.get_", "database retrieval methods"),
+    ("db.update_", "database update methods"),
+    ("db.save_", "database save methods"),
+    # Agent core methods - should test actual implementation
+    ("execute_task", "task execution (core agent functionality)"),
+    ("_record_token_usage", "token tracking"),
+    ("assign_task", "task assignment"),
+    ("apply_file_changes", "file operations"),
+    # Quality gates - should test actual subprocess calls in integration
+    ("subprocess.run", "quality gate subprocess execution"),
+    ("run_tests_gate", "quality gate methods"),
+    ("run_type_check_gate", "quality gate methods"),
+    ("run_all_gates", "quality gate methods"),
+]
+
+# Patterns that are acceptable to mock (external services)
+ACCEPTABLE_MOCK_PATTERNS = [
+    ("AsyncAnthropic", "external LLM API"),
+    ("anthropic.AsyncAnthropic", "external LLM API"),
+    ("AnthropicProvider", "external LLM API"),
+    ("AsyncOpenAI", "external LLM API"),
+    ("openai.AsyncOpenAI", "external LLM API"),
+    ("github.Github", "external GitHub API"),
+    ("requests.", "external HTTP requests"),
+    ("httpx.", "external HTTP requests"),
+    ("aiohttp.", "external HTTP requests"),
+    ("smtp", "external email service"),
+    ("os.environ", "environment variables"),
+    ("ANTHROPIC_API_KEY", "API key environment variable"),
+]
+
+# Tests that mock implementation being tested (false positives)
+FALSE_POSITIVE_INDICATORS = [
+    "patch.object",  # Mocking the method being tested
+    "return_value",  # Setting return value of what should be tested
+]
+
+
+class TestMockAnalyzer(ast.NodeVisitor):
+    """AST visitor to analyze mock usage in test files."""
+
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+        self.current_class: str | None = None
+        self.current_function: str | None = None
+        self.tests: list[TestInfo] = []
+        self.current_test_mocks: list[MockPattern] = []
+        self.imports: dict[str, str] = {}  # alias -> full name
+
+    def visit_Import(self, node: ast.Import) -> Any:
+        for alias in node.names:
+            name = alias.asname if alias.asname else alias.name
+            self.imports[name] = alias.name
+        self.generic_visit(node)
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> Any:
+        module = node.module or ""
+        for alias in node.names:
+            name = alias.asname if alias.asname else alias.name
+            full_name = f"{module}.{alias.name}" if module else alias.name
+            self.imports[name] = full_name
+        self.generic_visit(node)
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> Any:
+        old_class = self.current_class
+        self.current_class = node.name
+        self.generic_visit(node)
+        self.current_class = old_class
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> Any:
+        self._visit_function(node)
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> Any:
+        self._visit_function(node)
+
+    def _visit_function(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> None:
+        if not node.name.startswith("test_"):
+            self.generic_visit(node)
+            return
+
+        self.current_function = node.name
+        self.current_test_mocks = []
+
+        # Check decorators for patches
+        for decorator in node.decorator_list:
+            self._analyze_decorator(decorator)
+
+        # Visit function body for with statements and Mock usage
+        self.generic_visit(node)
+
+        # Create test info
+        test_info = TestInfo(
+            name=node.name,
+            class_name=self.current_class,
+            file_path=self.file_path,
+            line_number=node.lineno,
+            mock_patterns=self.current_test_mocks.copy(),
+        )
+
+        # Calculate severity based on mock patterns
+        test_info.severity, test_info.recommendation = self._calculate_severity(test_info)
+        self.tests.append(test_info)
+
+        self.current_function = None
+        self.current_test_mocks = []
+
+    def _analyze_decorator(self, decorator: ast.expr) -> None:
+        """Analyze a decorator for mock patterns."""
+        if isinstance(decorator, ast.Call):
+            func = decorator.func
+            if isinstance(func, ast.Attribute):
+                if func.attr == "patch":
+                    self._handle_patch_decorator(decorator)
+            elif isinstance(func, ast.Name) and func.id == "patch":
+                self._handle_patch_decorator(decorator)
+
+    def _handle_patch_decorator(self, call: ast.Call) -> None:
+        """Handle @patch decorator."""
+        if call.args:
+            target = self._get_string_value(call.args[0])
+            if target:
+                pattern = self._create_mock_pattern(target, call.lineno, "patch")
+                self.current_test_mocks.append(pattern)
+
+    def visit_With(self, node: ast.With) -> Any:
+        """Analyze with statements for patch context managers."""
+        for item in node.items:
+            self._analyze_with_item(item)
+        self.generic_visit(node)
+
+    def _analyze_with_item(self, item: ast.withitem) -> None:
+        """Analyze a single with item."""
+        if isinstance(item.context_expr, ast.Call):
+            call = item.context_expr
+            func = call.func
+
+            # Check for patch()
+            if isinstance(func, ast.Attribute):
+                if func.attr in ("patch", "object"):
+                    target = self._get_patch_target(call)
+                    if target:
+                        pattern = self._create_mock_pattern(
+                            target, call.lineno, f"patch.{func.attr}"
+                        )
+                        self.current_test_mocks.append(pattern)
+            elif isinstance(func, ast.Name) and func.id == "patch":
+                target = self._get_patch_target(call)
+                if target:
+                    pattern = self._create_mock_pattern(target, call.lineno, "patch")
+                    self.current_test_mocks.append(pattern)
+
+    def _get_patch_target(self, call: ast.Call) -> str | None:
+        """Extract the target string from a patch call."""
+        if call.args:
+            return self._get_string_value(call.args[0])
+        return None
+
+    def _get_string_value(self, node: ast.expr) -> str | None:
+        """Extract string value from an AST node."""
+        if isinstance(node, ast.Constant) and isinstance(node.value, str):
+            return node.value
+        return None
+
+    def visit_Call(self, node: ast.Call) -> Any:
+        """Analyze function calls for Mock/MagicMock/AsyncMock usage."""
+        if self.current_function and self.current_function.startswith("test_"):
+            func = node.func
+            if isinstance(func, ast.Name):
+                if func.id in ("Mock", "MagicMock", "AsyncMock"):
+                    pattern = MockPattern(
+                        name=func.id,
+                        line_number=node.lineno,
+                        mock_type=func.id,
+                        target="unspecified",
+                        severity="medium",
+                        reason="Direct Mock object creation",
+                    )
+                    self.current_test_mocks.append(pattern)
+            elif isinstance(func, ast.Attribute):
+                if func.attr in ("Mock", "MagicMock", "AsyncMock"):
+                    pattern = MockPattern(
+                        name=func.attr,
+                        line_number=node.lineno,
+                        mock_type=func.attr,
+                        target="unspecified",
+                        severity="medium",
+                        reason="Direct Mock object creation",
+                    )
+                    self.current_test_mocks.append(pattern)
+
+        self.generic_visit(node)
+
+    def _create_mock_pattern(self, target: str, line_number: int, mock_type: str) -> MockPattern:
+        """Create a MockPattern with appropriate severity."""
+        severity = "low"
+        reason = "Acceptable external service mock"
+
+        # Check if it's mocking core functionality
+        for pattern, desc in CORE_FUNCTIONALITY_PATTERNS:
+            if pattern in target:
+                severity = "high"
+                reason = f"Mocking core functionality: {desc}"
+                break
+
+        # Check if it's acceptable
+        if severity != "high":
+            is_acceptable = False
+            for pattern, desc in ACCEPTABLE_MOCK_PATTERNS:
+                if pattern in target:
+                    is_acceptable = True
+                    reason = f"Acceptable mock: {desc}"
+                    break
+
+            if not is_acceptable and severity != "high":
+                severity = "medium"
+                reason = f"Potentially excessive mock: {target}"
+
+        return MockPattern(
+            name=target.split(".")[-1],
+            line_number=line_number,
+            mock_type=mock_type,
+            target=target,
+            severity=severity,
+            reason=reason,
+        )
+
+    def _calculate_severity(self, test: TestInfo) -> tuple[str, str]:
+        """Calculate overall test severity and recommendation."""
+        if not test.mock_patterns:
+            return "low", "No mocking detected - good unit test"
+
+        high_count = sum(1 for p in test.mock_patterns if p.severity == "high")
+        medium_count = sum(1 for p in test.mock_patterns if p.severity == "medium")
+
+        if high_count > 0:
+            return "high", "Rewrite as integration test with real implementations"
+        elif medium_count > 2:
+            return "medium", "Consider reducing mocking or converting to integration test"
+        elif medium_count > 0:
+            return "low", "Acceptable mocking level for unit test"
+        else:
+            return "low", "Only mocking external services - good practice"
+
+
+def analyze_file(file_path: Path) -> list[TestInfo]:
+    """Analyze a single test file for mock patterns."""
+    try:
+        source = file_path.read_text()
+        tree = ast.parse(source)
+        analyzer = TestMockAnalyzer(str(file_path))
+        analyzer.visit(tree)
+        return analyzer.tests
+    except SyntaxError as e:
+        print(f"Syntax error in {file_path}: {e}", file=sys.stderr)
+        return []
+    except Exception as e:
+        print(f"Error analyzing {file_path}: {e}", file=sys.stderr)
+        return []
+
+
+def scan_test_directory(test_dir: Path) -> AuditResult:
+    """Scan all test files in a directory."""
+    result = AuditResult()
+    result.summary = {"high": 0, "medium": 0, "low": 0, "total_tests": 0, "total_mocks": 0}
+
+    test_files = list(test_dir.rglob("test_*.py")) + list(test_dir.rglob("*_test.py"))
+    result.files_analyzed = len(test_files)
+
+    for file_path in sorted(test_files):
+        tests = analyze_file(file_path)
+        result.tests.extend(tests)
+
+        for test in tests:
+            result.summary[test.severity] += 1
+            result.summary["total_tests"] += 1
+            result.summary["total_mocks"] += len(test.mock_patterns)
+
+    return result
+
+
+def generate_markdown_report(result: AuditResult) -> str:
+    """Generate a markdown report from audit results."""
+    lines = [
+        "# Test Mocking Audit Report",
+        "",
+        "## Summary",
+        "",
+        f"- **Files Analyzed**: {result.files_analyzed}",
+        f"- **Total Tests**: {result.summary['total_tests']}",
+        f"- **Total Mock Patterns**: {result.summary['total_mocks']}",
+        "",
+        "### Severity Distribution",
+        "",
+        f"- **HIGH** (needs rewrite): {result.summary['high']}",
+        f"- **MEDIUM** (review needed): {result.summary['medium']}",
+        f"- **LOW** (acceptable): {result.summary['low']}",
+        "",
+        "---",
+        "",
+    ]
+
+    # Group tests by severity
+    high_tests = [t for t in result.tests if t.severity == "high"]
+    medium_tests = [t for t in result.tests if t.severity == "medium"]
+
+    if high_tests:
+        lines.extend([
+            "## HIGH Severity Tests (Needs Rewrite)",
+            "",
+            "These tests mock core functionality and should be rewritten as integration tests.",
+            "",
+        ])
+        for test in high_tests:
+            lines.extend(_format_test_entry(test))
+
+    if medium_tests:
+        lines.extend([
+            "## MEDIUM Severity Tests (Review Needed)",
+            "",
+            "These tests have heavy mocking that may hide integration issues.",
+            "",
+        ])
+        for test in medium_tests:
+            lines.extend(_format_test_entry(test))
+
+    lines.extend([
+        "",
+        "---",
+        "",
+        "## Recommendations",
+        "",
+        "### For HIGH Severity Tests:",
+        "1. Convert to integration tests in `tests/integration/`",
+        "2. Use real database fixtures (`:memory:` SQLite)",
+        "3. Use real file operations in temp directories",
+        "4. Only mock external APIs (Anthropic, OpenAI, GitHub)",
+        "",
+        "### For MEDIUM Severity Tests:",
+        "1. Review if mocking is necessary",
+        "2. Consider using real implementations where possible",
+        "3. Document why mocking is needed if kept",
+        "",
+        "### General Guidelines:",
+        "- Unit tests: Focus on logic, mock external I/O only",
+        "- Integration tests: Use real components, mock only external services",
+        "- Never mock `execute_task()`, database operations, or quality gates in unit tests",
+        "",
+    ])
+
+    return "\n".join(lines)
+
+
+def _format_test_entry(test: TestInfo) -> list[str]:
+    """Format a single test entry for the report."""
+    class_prefix = f"{test.class_name}." if test.class_name else ""
+    lines = [
+        f"### `{class_prefix}{test.name}`",
+        f"- **File**: `{test.file_path}:{test.line_number}`",
+        f"- **Recommendation**: {test.recommendation}",
+        "- **Mock Patterns**:",
+    ]
+
+    for pattern in test.mock_patterns:
+        severity_marker = {"high": "**", "medium": "", "low": ""}.get(pattern.severity, "")
+        lines.append(
+            f"  - {severity_marker}`{pattern.target}`{severity_marker} "
+            f"({pattern.mock_type}, line {pattern.line_number}): {pattern.reason}"
+        )
+
+    lines.append("")
+    return lines
+
+
+def generate_json_report(result: AuditResult) -> str:
+    """Generate a JSON report from audit results."""
+    data = {
+        "summary": result.summary,
+        "files_analyzed": result.files_analyzed,
+        "tests": [
+            {
+                "name": t.name,
+                "class_name": t.class_name,
+                "file_path": t.file_path,
+                "line_number": t.line_number,
+                "severity": t.severity,
+                "recommendation": t.recommendation,
+                "mock_patterns": [
+                    {
+                        "target": p.target,
+                        "mock_type": p.mock_type,
+                        "line_number": p.line_number,
+                        "severity": p.severity,
+                        "reason": p.reason,
+                    }
+                    for p in t.mock_patterns
+                ],
+            }
+            for t in result.tests
+        ],
+    }
+    return json.dumps(data, indent=2)
+
+
+def main() -> None:
+    """Main entry point."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Audit test files for excessive mocking")
+    parser.add_argument(
+        "--output",
+        "-o",
+        type=str,
+        default="test_audit_report.md",
+        help="Output file path (default: test_audit_report.md)",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output in JSON format instead of Markdown",
+    )
+    parser.add_argument(
+        "--test-dir",
+        "-d",
+        type=str,
+        default="tests",
+        help="Test directory to scan (default: tests)",
+    )
+
+    args = parser.parse_args()
+
+    # Find project root (where tests/ directory is)
+    script_dir = Path(__file__).parent
+    project_root = script_dir.parent
+    test_dir = project_root / args.test_dir
+
+    if not test_dir.exists():
+        print(f"Test directory not found: {test_dir}", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"Scanning test files in {test_dir}...")
+    result = scan_test_directory(test_dir)
+
+    if args.json:
+        report = generate_json_report(result)
+        output_file = args.output.replace(".md", ".json") if args.output.endswith(".md") else args.output
+    else:
+        report = generate_markdown_report(result)
+        output_file = args.output
+
+    output_path = project_root / output_file
+    output_path.write_text(report)
+    print(f"Report written to {output_path}")
+
+    # Print summary
+    print("\n=== Summary ===")
+    print(f"Files analyzed: {result.files_analyzed}")
+    print(f"Total tests: {result.summary['total_tests']}")
+    print(f"HIGH severity: {result.summary['high']}")
+    print(f"MEDIUM severity: {result.summary['medium']}")
+    print(f"LOW severity: {result.summary['low']}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/e2e/test_dashboard.spec.ts b/tests/e2e/test_dashboard.spec.ts
index 8d76f610..3d10bdf5 100644
--- a/tests/e2e/test_dashboard.spec.ts
+++ b/tests/e2e/test_dashboard.spec.ts
@@ -168,10 +168,11 @@ test.describe('Dashboard - Sprint 10 Features', () => {
 
     // Make panel visible if it's in a tab or collapsed
     if (!(await reviewPanel.isVisible())) {
-      const reviewTab = page.locator('[data-testid="review-tab"]');
-      await reviewTab.waitFor({ state: 'visible', timeout: 10000 }).catch(() => {});
-      if (await reviewTab.isVisible()) {
-        await reviewTab.click();
+      // Review panel is in the Overview tab
+      const overviewTab = page.locator('[data-testid="overview-tab"]');
+      await overviewTab.waitFor({ state: 'visible', timeout: 10000 }).catch(() => {});
+      if (await overviewTab.isVisible()) {
+        await overviewTab.click();
         // Wait for panel to become visible after tab switch
         await reviewPanel.waitFor({ state: 'visible', timeout: 5000 }).catch(() => {});
       }
@@ -203,10 +204,11 @@ test.describe('Dashboard - Sprint 10 Features', () => {
 
     // Make panel visible if needed
     if (!(await qualityGatesPanel.isVisible())) {
-      const qualityTab = page.locator('[data-testid="quality-tab"]');
-      await qualityTab.waitFor({ state: 'visible', timeout: 10000 }).catch(() => {});
-      if (await qualityTab.isVisible()) {
-        await qualityTab.click();
+      // Quality gates panel is in the Overview tab
+      const overviewTab = page.locator('[data-testid="overview-tab"]');
+      await overviewTab.waitFor({ state: 'visible', timeout: 10000 }).catch(() => {});
+      if (await overviewTab.isVisible()) {
+        await overviewTab.click();
         // Wait for panel to become visible after tab switch
         await qualityGatesPanel.waitFor({ state: 'visible', timeout: 5000 }).catch(() => {});
       }
diff --git a/tests/integration/conftest.py b/tests/integration/conftest.py
new file mode 100644
index 00000000..36c46eaa
--- /dev/null
+++ b/tests/integration/conftest.py
@@ -0,0 +1,482 @@
+"""
+Integration Test Fixtures for CodeFRAME
+
+Provides shared fixtures for integration tests that use real implementations:
+- Real SQLite database (in-memory or temp file)
+- Real file system operations in temp directories
+- Real subprocess execution for quality gates
+- Mock only external services (Anthropic, OpenAI, GitHub APIs)
+
+Usage:
+    @pytest.mark.integration
+    async def test_something(real_db, test_workspace, mock_llm_api):
+        # Your test using real database and workspace
+        pass
+"""
+
+import json
+from pathlib import Path
+from typing import Any, Generator
+from unittest.mock import AsyncMock, Mock, patch
+
+import pytest
+
+from codeframe.persistence.database import Database
+from codeframe.core.models import AgentMaturity, TaskStatus
+
+
+# =============================================================================
+# Database Fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def real_db() -> Generator[Database, None, None]:
+    """Create a real in-memory SQLite database with full schema.
+
+    This fixture provides a real database instance for integration testing.
+    The database is isolated per test and cleaned up automatically.
+
+    Yields:
+        Database: A fully initialized in-memory database instance.
+    """
+    db = Database(":memory:")
+    db.initialize()
+    yield db
+    if db.conn:
+        db.conn.close()
+
+
+@pytest.fixture
+def real_db_file(tmp_path: Path) -> Generator[Database, None, None]:
+    """Create a real SQLite database file for persistence testing.
+
+    Use this fixture when you need to test database persistence across
+    multiple database connections or process restarts.
+
+    Args:
+        tmp_path: Pytest temp directory fixture
+
+    Yields:
+        Database: A file-backed database instance.
+    """
+    db_path = tmp_path / "test_codeframe.db"
+    db = Database(str(db_path))
+    db.initialize()
+    yield db
+    if db.conn:
+        db.conn.close()
+
+
+@pytest.fixture
+def integration_project(real_db: Database, test_workspace: Path) -> dict[str, Any]:
+    """Create a complete test project with database and workspace.
+
+    This fixture provides a fully configured project for integration testing,
+    including:
+    - Project record in database
+    - Test workspace directory
+    - Sample issues and tasks
+
+    Args:
+        real_db: Real database fixture
+        test_workspace: Temp directory fixture
+
+    Returns:
+        dict: Project configuration with keys:
+            - project_id: Database project ID
+            - workspace_path: Path to workspace directory
+            - db: Database instance
+    """
+    project_id = real_db.create_project(
+        name="integration-test-project",
+        description="Project for integration testing",
+        source_type="empty",
+        workspace_path=str(test_workspace),
+    )
+
+    # Create sample issue
+    issue_id = real_db.create_issue({
+        "project_id": project_id,
+        "issue_number": "INT-001",
+        "title": "Integration Test Issue",
+        "description": "Test issue for integration testing",
+        "priority": 1,
+        "workflow_step": 1,
+    })
+
+    return {
+        "project_id": project_id,
+        "issue_id": issue_id,
+        "workspace_path": test_workspace,
+        "db": real_db,
+    }
+
+
+# =============================================================================
+# File System Fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def test_workspace(tmp_path: Path) -> Generator[Path, None, None]:
+    """Create a temp directory for file operations.
+
+    This fixture provides an isolated workspace for each test,
+    mimicking a real project workspace.
+
+    Yields:
+        Path: Path to temp workspace directory.
+    """
+    workspace = tmp_path / "workspace"
+    workspace.mkdir(parents=True)
+
+    # Create standard project structure
+    (workspace / "src").mkdir()
+    (workspace / "tests").mkdir()
+
+    yield workspace
+
+    # Cleanup (handled by pytest tmp_path automatically)
+
+
+@pytest.fixture
+def python_project_workspace(test_workspace: Path) -> Path:
+    """Create a workspace with Python project structure.
+
+    Creates:
+    - pyproject.toml
+    - src/ directory with sample module
+    - tests/ directory with sample test
+
+    Args:
+        test_workspace: Base workspace fixture
+
+    Returns:
+        Path: Path to Python project workspace.
+    """
+    # Create pyproject.toml
+    pyproject = {
+        "project": {
+            "name": "test-project",
+            "version": "0.1.0",
+            "requires-python": ">=3.11",
+        },
+        "tool": {
+            "pytest": {"testpaths": ["tests"]},
+            "ruff": {"line-length": 100},
+        },
+    }
+    (test_workspace / "pyproject.toml").write_text(
+        "[project]\nname = 'test-project'\nversion = '0.1.0'\n"
+    )
+
+    # Create sample module
+    (test_workspace / "src" / "module.py").write_text(
+        'def hello(name: str) -> str:\n    """Return greeting."""\n    return f"Hello, {name}!"\n'
+    )
+
+    # Create sample test
+    (test_workspace / "tests" / "test_module.py").write_text(
+        'from src.module import hello\n\ndef test_hello():\n    assert hello("World") == "Hello, World!"\n'
+    )
+
+    return test_workspace
+
+
+@pytest.fixture
+def typescript_project_workspace(test_workspace: Path) -> Path:
+    """Create a workspace with TypeScript project structure.
+
+    Creates:
+    - package.json
+    - tsconfig.json
+    - src/ directory with sample module
+    - tests/ directory with sample test
+
+    Args:
+        test_workspace: Base workspace fixture
+
+    Returns:
+        Path: Path to TypeScript project workspace.
+    """
+    # Create package.json
+    package_json = {
+        "name": "test-project",
+        "version": "0.1.0",
+        "scripts": {
+            "test": "jest",
+            "build": "tsc",
+        },
+        "devDependencies": {
+            "typescript": "^5.0.0",
+            "jest": "^29.0.0",
+        },
+    }
+    (test_workspace / "package.json").write_text(json.dumps(package_json, indent=2))
+
+    # Create tsconfig.json
+    tsconfig = {
+        "compilerOptions": {
+            "target": "ES2020",
+            "module": "commonjs",
+            "strict": True,
+            "outDir": "./dist",
+        },
+        "include": ["src/**/*"],
+    }
+    (test_workspace / "tsconfig.json").write_text(json.dumps(tsconfig, indent=2))
+
+    # Create sample module
+    (test_workspace / "src" / "module.ts").write_text(
+        'export function hello(name: string): string {\n  return `Hello, ${name}!`;\n}\n'
+    )
+
+    return test_workspace
+
+
+# =============================================================================
+# External API Mock Fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def mock_anthropic_api():
+    """Mock Anthropic API for integration tests.
+
+    This fixture provides a mock Anthropic client that returns realistic
+    responses without making actual API calls.
+
+    Use this for integration tests that need to test agent behavior
+    without incurring API costs.
+
+    Yields:
+        Mock: Mock Anthropic client with configured responses.
+    """
+    with patch("anthropic.AsyncAnthropic") as mock_class:
+        mock_client = AsyncMock()
+        mock_class.return_value = mock_client
+
+        # Default successful response
+        def create_response(content: str = "Task completed successfully."):
+            response = Mock()
+            response.content = [Mock(text=content)]
+            response.usage = Mock(input_tokens=100, output_tokens=50)
+            return response
+
+        mock_client.messages.create = AsyncMock(return_value=create_response())
+
+        yield mock_client
+
+
+@pytest.fixture
+def mock_llm_response_factory(mock_anthropic_api):
+    """Factory fixture for creating custom LLM responses.
+
+    Use this to configure specific responses for different test scenarios.
+
+    Example:
+        def test_something(mock_llm_response_factory):
+            response = mock_llm_response_factory(
+                content='{"files": [...], "explanation": "Done"}'
+            )
+            # mock_anthropic_api now returns this response
+    """
+
+    def factory(content: str, input_tokens: int = 100, output_tokens: int = 50):
+        response = Mock()
+        response.content = [Mock(text=content)]
+        response.usage = Mock(input_tokens=input_tokens, output_tokens=output_tokens)
+        mock_anthropic_api.messages.create.return_value = response
+        return response
+
+    return factory
+
+
+# =============================================================================
+# Agent Fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def worker_agent_config(real_db: Database) -> dict[str, Any]:
+    """Basic worker agent configuration for integration tests.
+
+    Returns:
+        dict: Agent configuration with real database and test API key.
+    """
+    return {
+        "agent_id": "test-worker-001",
+        "agent_type": "backend",
+        "provider": "anthropic",
+        "db": real_db,
+        "maturity": AgentMaturity.D2,
+    }
+
+
+@pytest.fixture
+def registered_agent(real_db: Database, worker_agent_config: dict) -> str:
+    """Create a registered agent in the database.
+
+    Args:
+        real_db: Database fixture
+        worker_agent_config: Agent config fixture
+
+    Returns:
+        str: Agent ID
+    """
+    agent_id = worker_agent_config["agent_id"]
+    real_db.create_agent(
+        agent_id=agent_id,
+        agent_type=worker_agent_config["agent_type"],
+        provider=worker_agent_config["provider"],
+        maturity_level=worker_agent_config["maturity"],
+    )
+    return agent_id
+
+
+# =============================================================================
+# Task Fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def sample_task(integration_project: dict) -> dict[str, Any]:
+    """Create a sample task in the integration project.
+
+    Args:
+        integration_project: Project fixture
+
+    Returns:
+        dict: Task data including ID and full task object.
+    """
+    db = integration_project["db"]
+    project_id = integration_project["project_id"]
+    issue_id = integration_project["issue_id"]
+
+    task_id = db.create_task_with_issue(
+        project_id=project_id,
+        issue_id=issue_id,
+        task_number="INT-001-1",
+        parent_issue_number="INT-001",
+        title="Sample Integration Test Task",
+        description="Create a sample module with tests",
+        status=TaskStatus.PENDING,
+        priority=1,
+        workflow_step=1,
+        can_parallelize=False,
+    )
+
+    task = db.get_task(task_id)
+
+    return {
+        "id": task_id,
+        "task": task,
+        "project_id": project_id,
+        "issue_id": issue_id,
+    }
+
+
+@pytest.fixture
+def pending_tasks(integration_project: dict) -> list[dict[str, Any]]:
+    """Create multiple pending tasks for parallel execution testing.
+
+    Args:
+        integration_project: Project fixture
+
+    Returns:
+        list: List of task data dicts.
+    """
+    db = integration_project["db"]
+    project_id = integration_project["project_id"]
+    issue_id = integration_project["issue_id"]
+
+    tasks = []
+    for i in range(3):
+        task_id = db.create_task_with_issue(
+            project_id=project_id,
+            issue_id=issue_id,
+            task_number=f"INT-001-{i+1}",
+            parent_issue_number="INT-001",
+            title=f"Parallel Task {i+1}",
+            description=f"Task {i+1} for parallel execution",
+            status=TaskStatus.PENDING,
+            priority=1,
+            workflow_step=i + 1,
+            can_parallelize=True,
+        )
+        task = db.get_task(task_id)
+        tasks.append({"id": task_id, "task": task})
+
+    return tasks
+
+
+# =============================================================================
+# Environment Fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def clean_env(monkeypatch):
+    """Provide a clean environment for testing.
+
+    Clears CODEFRAME environment variables and provides helpers.
+
+    Args:
+        monkeypatch: Pytest monkeypatch fixture
+
+    Returns:
+        dict: Environment helpers.
+    """
+    # Clear existing environment variables
+    vars_to_clear = [
+        "ANTHROPIC_API_KEY",
+        "OPENAI_API_KEY",
+        "DATABASE_PATH",
+        "API_HOST",
+        "API_PORT",
+    ]
+    for var in vars_to_clear:
+        monkeypatch.delenv(var, raising=False)
+
+    # Set test API key
+    monkeypatch.setenv("ANTHROPIC_API_KEY", "sk-ant-test-integration-key")
+
+    return {"monkeypatch": monkeypatch}
+
+
+# =============================================================================
+# Quality Gates Fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def quality_gates_config(integration_project: dict) -> dict[str, Any]:
+    """Configuration for quality gates integration tests.
+
+    Returns:
+        dict: Quality gates configuration.
+    """
+    return {
+        "db": integration_project["db"],
+        "project_id": integration_project["project_id"],
+        "project_root": integration_project["workspace_path"],
+    }
+
+
+# =============================================================================
+# Markers
+# =============================================================================
+
+
+def pytest_configure(config):
+    """Add custom markers for integration tests."""
+    config.addinivalue_line(
+        "markers", "integration: mark test as an integration test"
+    )
+    config.addinivalue_line(
+        "markers", "slow: mark test as slow (deselect with '-m \"not slow\"')"
+    )
+    config.addinivalue_line(
+        "markers", "requires_subprocess: mark test as requiring subprocess execution"
+    )
diff --git a/tests/integration/test_database_operations.py b/tests/integration/test_database_operations.py
new file mode 100644
index 00000000..00b37a06
--- /dev/null
+++ b/tests/integration/test_database_operations.py
@@ -0,0 +1,577 @@
+"""
+Integration tests for database operations.
+
+These tests verify actual database behavior with:
+- Real SQLite database operations
+- Transaction handling and rollback
+- Concurrent access patterns
+- Repository pattern functionality
+
+Unlike unit tests, these tests use real database instances to
+verify actual persistence behavior.
+"""
+
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+import pytest
+
+from codeframe.core.models import AgentMaturity, CallType, TaskStatus, TokenUsage
+from codeframe.persistence.database import Database
+
+
+@pytest.mark.integration
+class TestDatabaseProjectOperations:
+    """Integration tests for project CRUD operations."""
+
+    def test_project_create_and_retrieve(self, real_db: Database):
+        """Test creating and retrieving a project."""
+        project_id = real_db.create_project(
+            name="test-project",
+            description="A test project",
+            source_type="git_remote",
+            workspace_path="/tmp/test-project",
+        )
+
+        project = real_db.get_project(project_id)
+
+        assert project is not None
+        assert project["name"] == "test-project"
+        assert project["description"] == "A test project"
+        assert project["source_type"] == "git_remote"
+        assert project["workspace_path"] == "/tmp/test-project"
+
+    def test_project_update(self, real_db: Database):
+        """Test updating a project's properties."""
+        project_id = real_db.create_project(
+            name="original-name",
+            description="Original description",
+            source_type="empty",
+            workspace_path="/tmp/original",
+        )
+
+        # Update project
+        real_db.update_project(
+            project_id,
+            {
+                "name": "updated-name",
+                "description": "Updated description",
+            },
+        )
+
+        project = real_db.get_project(project_id)
+
+        assert project["name"] == "updated-name"
+        assert project["description"] == "Updated description"
+        # Unchanged fields preserved
+        assert project["workspace_path"] == "/tmp/original"
+
+    def test_project_list_returns_all_projects(self, real_db: Database):
+        """Test listing all projects."""
+        # Create multiple projects
+        ids = []
+        for i in range(5):
+            project_id = real_db.create_project(
+                name=f"project-{i}",
+                description=f"Project {i}",
+                source_type="empty",
+                workspace_path=f"/tmp/project-{i}",
+            )
+            ids.append(project_id)
+
+        projects = real_db.list_projects()
+
+        assert len(projects) == 5
+        project_names = {p["name"] for p in projects}
+        expected_names = {f"project-{i}" for i in range(5)}
+        assert project_names == expected_names
+
+
+@pytest.mark.integration
+class TestDatabaseTaskOperations:
+    """Integration tests for task CRUD operations."""
+
+    def test_task_create_with_issue(self, integration_project):
+        """Test creating a task linked to an issue."""
+        db = integration_project["db"]
+        project_id = integration_project["project_id"]
+        issue_id = integration_project["issue_id"]
+
+        task_id = db.create_task_with_issue(
+            project_id=project_id,
+            issue_id=issue_id,
+            task_number="TASK-001",
+            parent_issue_number="INT-001",
+            title="Implementation Task",
+            description="Implement the feature",
+            status=TaskStatus.PENDING,
+            priority=1,
+            workflow_step=1,
+            can_parallelize=True,
+        )
+
+        task = db.get_task(task_id)
+
+        assert task is not None
+        assert task.title == "Implementation Task"
+        assert task.status == TaskStatus.PENDING
+        assert task.project_id == project_id
+
+    def test_task_status_transitions(self, integration_project):
+        """Test valid task status transitions."""
+        db = integration_project["db"]
+        project_id = integration_project["project_id"]
+        issue_id = integration_project["issue_id"]
+
+        task_id = db.create_task_with_issue(
+            project_id=project_id,
+            issue_id=issue_id,
+            task_number="STATUS-001",
+            parent_issue_number="INT-001",
+            title="Status Test",
+            description="Test status transitions",
+            status=TaskStatus.PENDING,
+            priority=1,
+            workflow_step=1,
+            can_parallelize=False,
+        )
+
+        # Transition: PENDING -> ASSIGNED
+        db.update_task(task_id, {
+            "status": TaskStatus.ASSIGNED.value,
+            "assigned_to": "agent-001",
+        })
+        task = db.get_task(task_id)
+        assert task.status == TaskStatus.ASSIGNED
+
+        # Transition: ASSIGNED -> IN_PROGRESS
+        db.update_task(task_id, {"status": TaskStatus.IN_PROGRESS.value})
+        task = db.get_task(task_id)
+        assert task.status == TaskStatus.IN_PROGRESS
+
+        # Transition: IN_PROGRESS -> COMPLETED
+        db.update_task(task_id, {"status": TaskStatus.COMPLETED.value})
+        task = db.get_task(task_id)
+        assert task.status == TaskStatus.COMPLETED
+        # Note: completed_at is set by application logic, not DB trigger
+
+    def test_task_list_by_issue(self, integration_project):
+        """Test listing tasks by issue."""
+        db = integration_project["db"]
+        project_id = integration_project["project_id"]
+        issue_id = integration_project["issue_id"]
+
+        # Create multiple tasks
+        for i in range(3):
+            db.create_task_with_issue(
+                project_id=project_id,
+                issue_id=issue_id,
+                task_number=f"LIST-{i+1:03d}",
+                parent_issue_number="INT-001",
+                title=f"Task {i+1}",
+                description=f"Task {i+1} description",
+                status=TaskStatus.PENDING,
+                priority=i,
+                workflow_step=i + 1,
+                can_parallelize=True,
+            )
+
+        # Query tasks via SQL (get_tasks_by_issue is async)
+        cursor = db.conn.cursor()
+        cursor.execute("SELECT * FROM tasks WHERE issue_id = ?", (issue_id,))
+        rows = cursor.fetchall()
+
+        assert len(rows) == 3
+        assert all(row["project_id"] == project_id for row in rows)
+
+
+@pytest.mark.integration
+class TestDatabaseAgentOperations:
+    """Integration tests for agent CRUD operations."""
+
+    def test_agent_create_and_retrieve(self, real_db: Database):
+        """Test creating and retrieving an agent."""
+        real_db.create_agent(
+            agent_id="test-agent-001",
+            agent_type="backend",
+            provider="anthropic",
+            maturity_level=AgentMaturity.D1,
+        )
+
+        agent = real_db.get_agent("test-agent-001")
+
+        assert agent is not None
+        assert agent["id"] == "test-agent-001"
+        assert agent["type"] == "backend"
+        assert agent["provider"] == "anthropic"
+        assert agent["maturity_level"] == AgentMaturity.D1.value
+
+    def test_agent_maturity_update(self, real_db: Database):
+        """Test updating agent maturity level."""
+        real_db.create_agent(
+            agent_id="maturity-agent",
+            agent_type="backend",
+            provider="anthropic",
+            maturity_level=AgentMaturity.D1,
+        )
+
+        # Update maturity
+        real_db.update_agent("maturity-agent", {
+            "maturity_level": AgentMaturity.D3.value,
+        })
+
+        agent = real_db.get_agent("maturity-agent")
+        assert agent["maturity_level"] == AgentMaturity.D3.value
+
+
+@pytest.mark.integration
+class TestDatabaseTokenUsage:
+    """Integration tests for token usage tracking."""
+
+    def test_token_usage_recording(self, integration_project, sample_task):
+        """Test recording token usage for a task."""
+        db = integration_project["db"]
+        task_id = sample_task["id"]
+        project_id = integration_project["project_id"]
+
+        # Record token usage using TokenUsage model
+        token_usage = TokenUsage(
+            task_id=task_id,
+            agent_id="token-agent",
+            project_id=project_id,
+            model_name="claude-sonnet-4-5",
+            input_tokens=1000,
+            output_tokens=500,
+            estimated_cost_usd=0.0045,
+            call_type=CallType.TASK_EXECUTION,
+        )
+        db.save_token_usage(token_usage)
+
+        # Verify recording
+        cursor = db.conn.cursor()
+        cursor.execute(
+            "SELECT * FROM token_usage WHERE task_id = ?", (task_id,)
+        )
+        row = cursor.fetchone()
+
+        assert row is not None
+        assert row["input_tokens"] == 1000
+        assert row["output_tokens"] == 500
+        assert row["model_name"] == "claude-sonnet-4-5"
+
+    def test_token_usage_aggregation_by_project(self, integration_project):
+        """Test aggregating token usage across a project."""
+        db = integration_project["db"]
+        project_id = integration_project["project_id"]
+        issue_id = integration_project["issue_id"]
+
+        # Create multiple tasks with token usage
+        for i in range(3):
+            task_id = db.create_task_with_issue(
+                project_id=project_id,
+                issue_id=issue_id,
+                task_number=f"AGG-{i+1:03d}",
+                parent_issue_number="INT-001",
+                title=f"Aggregate Task {i+1}",
+                description="Token aggregation test",
+                status=TaskStatus.COMPLETED,
+                priority=1,
+                workflow_step=i + 1,
+                can_parallelize=False,
+            )
+
+            token_usage = TokenUsage(
+                task_id=task_id,
+                agent_id="agg-agent",
+                project_id=project_id,
+                model_name="claude-sonnet-4-5",
+                input_tokens=(i + 1) * 100,
+                output_tokens=(i + 1) * 50,
+                estimated_cost_usd=0.001 * (i + 1),
+                call_type=CallType.TASK_EXECUTION,
+            )
+            db.save_token_usage(token_usage)
+
+        # Aggregate by project
+        cursor = db.conn.cursor()
+        cursor.execute(
+            """
+            SELECT
+                SUM(input_tokens) as total_input,
+                SUM(output_tokens) as total_output,
+                SUM(estimated_cost_usd) as total_cost
+            FROM token_usage WHERE project_id = ?
+            """,
+            (project_id,),
+        )
+        row = cursor.fetchone()
+
+        # 100 + 200 + 300 = 600 input
+        # 50 + 100 + 150 = 300 output
+        # 0.001 + 0.002 + 0.003 = 0.006 cost
+        assert row["total_input"] == 600
+        assert row["total_output"] == 300
+        assert abs(row["total_cost"] - 0.006) < 0.0001
+
+
+@pytest.mark.integration
+class TestDatabaseConcurrentAccess:
+    """Integration tests for concurrent database access."""
+
+    def test_concurrent_task_updates(self, integration_project):
+        """Test concurrent task updates don't cause race conditions."""
+        db = integration_project["db"]
+        project_id = integration_project["project_id"]
+        issue_id = integration_project["issue_id"]
+
+        # Create a task
+        task_id = db.create_task_with_issue(
+            project_id=project_id,
+            issue_id=issue_id,
+            task_number="CONC-001",
+            parent_issue_number="INT-001",
+            title="Concurrent Task",
+            description="Test concurrent updates",
+            status=TaskStatus.PENDING,
+            priority=1,
+            workflow_step=1,
+            can_parallelize=False,
+        )
+
+        update_count = [0]
+        errors = []
+
+        def update_task(priority: int):
+            try:
+                # All threads share the same db instance (SQLite handles locking)
+                db.update_task(task_id, {"priority": priority})
+                update_count[0] += 1
+            except Exception as e:
+                errors.append(e)
+
+        # Run 10 concurrent updates (priority must be 0-4 per DB constraint)
+        with ThreadPoolExecutor(max_workers=5) as executor:
+            futures = [executor.submit(update_task, i % 5) for i in range(10)]
+            for f in futures:
+                f.result()
+
+        assert len(errors) == 0, f"Concurrent update errors: {errors}"
+        assert update_count[0] == 10
+
+    def test_concurrent_project_reads(self, real_db: Database):
+        """Test concurrent project reads work correctly."""
+        # Create a project
+        project_id = real_db.create_project(
+            name="read-test",
+            description="Test concurrent reads",
+            source_type="empty",
+            workspace_path="/tmp/read-test",
+        )
+
+        results = []
+        errors = []
+
+        def read_project():
+            try:
+                project = real_db.get_project(project_id)
+                results.append(project)
+            except Exception as e:
+                errors.append(e)
+
+        # Run 20 concurrent reads
+        with ThreadPoolExecutor(max_workers=10) as executor:
+            futures = [executor.submit(read_project) for _ in range(20)]
+            for f in futures:
+                f.result()
+
+        assert len(errors) == 0, f"Concurrent read errors: {errors}"
+        assert len(results) == 20
+        assert all(r["name"] == "read-test" for r in results)
+
+
+@pytest.mark.integration
+class TestDatabaseTransactions:
+    """Integration tests for transaction handling."""
+
+    def test_transaction_rollback_on_error(self, real_db: Database):
+        """Test that transactions rollback on error."""
+        # Create initial project
+        project_id = real_db.create_project(
+            name="rollback-test",
+            description="Test rollback",
+            source_type="empty",
+            workspace_path="/tmp/rollback-test",
+        )
+
+        # Get initial state
+        original_project = real_db.get_project(project_id)
+
+        # Attempt invalid update that should fail
+        try:
+            # Try to update with invalid data type
+            cursor = real_db.conn.cursor()
+            cursor.execute("BEGIN TRANSACTION")
+            cursor.execute(
+                "UPDATE projects SET name = ? WHERE id = ?",
+                ("updated-name", project_id),
+            )
+            # Force an error
+            raise ValueError("Simulated error")
+        except ValueError:
+            real_db.conn.rollback()
+
+        # Verify rollback
+        project = real_db.get_project(project_id)
+        assert project["name"] == original_project["name"]
+
+
+@pytest.mark.integration
+class TestDatabaseBlockerOperations:
+    """Integration tests for blocker operations."""
+
+    def test_blocker_create_and_resolve(self, integration_project, sample_task):
+        """Test creating and resolving a blocker."""
+        db = integration_project["db"]
+        task_id = sample_task["id"]
+        project_id = integration_project["project_id"]
+
+        # Create agent for blocker
+        db.create_agent(
+            agent_id="blocker-agent",
+            agent_type="backend",
+            provider="anthropic",
+            maturity_level=AgentMaturity.D2,
+        )
+
+        # Create blocker (requires agent_id and project_id)
+        blocker_id = db.create_blocker(
+            agent_id="blocker-agent",
+            project_id=project_id,
+            task_id=task_id,
+            blocker_type="SYNC",
+            question="How should we handle authentication?",
+        )
+
+        # Verify blocker exists (query directly since no get_blockers_by_task method)
+        cursor = db.conn.cursor()
+        cursor.execute("SELECT * FROM blockers WHERE task_id = ?", (task_id,))
+        rows = cursor.fetchall()
+        assert len(rows) == 1
+        assert rows[0]["question"] == "How should we handle authentication?"
+        assert rows[0]["status"] == "PENDING"  # Status is uppercase
+
+        # Resolve blocker
+        db.resolve_blocker(
+            blocker_id,
+            answer="Use JWT tokens with refresh mechanism",
+        )
+
+        # Verify resolution
+        cursor.execute("SELECT * FROM blockers WHERE task_id = ?", (task_id,))
+        rows = cursor.fetchall()
+        assert len(rows) == 1
+        assert rows[0]["status"] == "RESOLVED"
+        assert rows[0]["answer"] == "Use JWT tokens with refresh mechanism"
+
+    def test_active_blockers_query(self, integration_project):
+        """Test querying active (unresolved) blockers."""
+        db = integration_project["db"]
+        project_id = integration_project["project_id"]
+        issue_id = integration_project["issue_id"]
+
+        # Create agent for blockers
+        db.create_agent(
+            agent_id="active-blocker-agent",
+            agent_type="backend",
+            provider="anthropic",
+            maturity_level=AgentMaturity.D2,
+        )
+
+        # Create multiple tasks with blockers
+        for i in range(3):
+            task_id = db.create_task_with_issue(
+                project_id=project_id,
+                issue_id=issue_id,
+                task_number=f"BLOCK-{i+1:03d}",
+                parent_issue_number="INT-001",
+                title=f"Blocked Task {i+1}",
+                description="Has blocker",
+                status=TaskStatus.IN_PROGRESS,
+                priority=1,
+                workflow_step=i + 1,
+                can_parallelize=False,
+            )
+
+            db.create_blocker(
+                agent_id="active-blocker-agent",
+                project_id=project_id,
+                task_id=task_id,
+                blocker_type="SYNC",
+                question=f"Question {i+1}",
+            )
+
+        # Get all active blockers (status is uppercase)
+        cursor = db.conn.cursor()
+        cursor.execute(
+            "SELECT COUNT(*) as count FROM blockers WHERE status = 'PENDING'"
+        )
+        count = cursor.fetchone()["count"]
+
+        assert count == 3
+
+
+@pytest.mark.integration
+class TestDatabaseFilePersistence:
+    """Integration tests for file-based database persistence."""
+
+    def test_data_persists_across_connections(self, tmp_path: Path):
+        """Test that data persists when reopening database file."""
+        db_path = tmp_path / "persist_test.db"
+
+        # First connection - create data
+        db1 = Database(str(db_path))
+        db1.initialize()
+        project_id = db1.create_project(
+            name="persistent-project",
+            description="Should persist",
+            source_type="empty",
+            workspace_path="/tmp/persist",
+        )
+        db1.conn.close()
+
+        # Second connection - verify data
+        db2 = Database(str(db_path))
+        db2.initialize()
+        project = db2.get_project(project_id)
+        db2.conn.close()
+
+        assert project is not None
+        assert project["name"] == "persistent-project"
+
+    def test_schema_migration_on_reopen(self, tmp_path: Path):
+        """Test that schema is properly initialized on reopen."""
+        db_path = tmp_path / "schema_test.db"
+
+        # Create initial database
+        db1 = Database(str(db_path))
+        db1.initialize()
+        db1.conn.close()
+
+        # Reopen and verify tables exist
+        db2 = Database(str(db_path))
+        db2.initialize()
+
+        cursor = db2.conn.cursor()
+        cursor.execute(
+            "SELECT name FROM sqlite_master WHERE type='table'"
+        )
+        tables = {row["name"] for row in cursor.fetchall()}
+        db2.conn.close()
+
+        # Verify essential tables exist
+        assert "projects" in tables
+        assert "tasks" in tables
+        assert "issues" in tables
+        assert "blockers" in tables
+        assert "agents" in tables
+        assert "token_usage" in tables
diff --git a/tests/integration/test_multi_agent_execution.py b/tests/integration/test_multi_agent_execution.py
new file mode 100644
index 00000000..dedb7f6d
--- /dev/null
+++ b/tests/integration/test_multi_agent_execution.py
@@ -0,0 +1,669 @@
+"""
+Integration tests for multi-agent coordination and execution.
+
+These tests verify real multi-agent behavior with:
+- Real SQLite database for task tracking
+- Real agent pool management
+- Real task assignment and status updates
+- Only external LLM APIs are mocked
+
+Key scenarios tested:
+- Parallel task execution with multiple agents
+- Task dependency resolution
+- Agent reuse after task completion
+- Error recovery and retry logic
+- WebSocket broadcast integration
+"""
+
+import asyncio
+import os
+from pathlib import Path
+from unittest.mock import AsyncMock, Mock, patch
+
+import pytest
+
+from codeframe.agents.worker_agent import WorkerAgent
+from codeframe.core.models import AgentMaturity, CallType, TaskStatus, TokenUsage
+from codeframe.persistence.database import Database
+
+
+@pytest.mark.integration
+class TestMultiAgentTaskExecution:
+    """Integration tests for multi-agent parallel task execution."""
+
+    @pytest.mark.asyncio
+    async def test_three_agents_execute_tasks_in_parallel(
+        self, real_db: Database, test_workspace: Path
+    ):
+        """Test three agents executing tasks in parallel with real database tracking."""
+        # Setup project
+        project_id = real_db.create_project(
+            name="parallel-test",
+            description="Test parallel execution",
+            source_type="empty",
+            workspace_path=str(test_workspace),
+        )
+        issue_id = real_db.create_issue({
+            "project_id": project_id,
+            "issue_number": "PAR-001",
+            "title": "Parallel Issue",
+            "description": "Test",
+            "priority": 1,
+            "workflow_step": 1,
+        })
+
+        # Create three tasks
+        task_ids = []
+        for i in range(3):
+            task_id = real_db.create_task_with_issue(
+                project_id=project_id,
+                issue_id=issue_id,
+                task_number=f"PAR-001-{i+1}",
+                parent_issue_number="PAR-001",
+                title=f"Parallel Task {i+1}",
+                description=f"Task {i+1} for parallel execution",
+                status=TaskStatus.PENDING,
+                priority=1,
+                workflow_step=i + 1,
+                can_parallelize=True,
+            )
+            task_ids.append(task_id)
+
+        # Register three agents
+        agents = []
+        for i in range(3):
+            agent_id = f"parallel-agent-{i+1}"
+            real_db.create_agent(
+                agent_id=agent_id,
+                agent_type="backend",
+                provider="anthropic",
+                maturity_level=AgentMaturity.D2,
+            )
+            agent = WorkerAgent(
+                agent_id=agent_id,
+                agent_type="backend",
+                provider="anthropic",
+                db=real_db,
+            )
+            agents.append(agent)
+
+        # Assign tasks to agents
+        for i, task_id in enumerate(task_ids):
+            real_db.update_task(task_id, {
+                "assigned_to": agents[i].agent_id,
+                "status": TaskStatus.ASSIGNED.value,
+            })
+
+        # Execute tasks in parallel with mocked LLM
+        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test-key"}):
+            with patch("codeframe.agents.worker_agent.AsyncAnthropic") as mock_api:
+                mock_response = Mock()
+                mock_response.content = [Mock(text="Task completed")]
+                mock_response.usage = Mock(input_tokens=100, output_tokens=50)
+                mock_api.return_value.messages.create = AsyncMock(
+                    return_value=mock_response
+                )
+
+                # Execute all tasks in parallel
+                tasks = []
+                for i, agent in enumerate(agents):
+                    task = real_db.get_task(task_ids[i])
+                    tasks.append(agent.execute_task(task))
+
+                results = await asyncio.gather(*tasks)
+
+        # Verify all tasks completed
+        assert all(r["status"] == "completed" for r in results)
+
+        # Simulate orchestrator updating task status based on results
+        for i, result in enumerate(results):
+            if result["status"] == "completed":
+                real_db.update_task(task_ids[i], {"status": TaskStatus.COMPLETED.value})
+
+        # Verify database shows all tasks completed
+        for task_id in task_ids:
+            task = real_db.get_task(task_id)
+            assert task.status == TaskStatus.COMPLETED
+
+        # Verify token usage recorded for all tasks
+        cursor = real_db.conn.cursor()
+        cursor.execute(
+            "SELECT COUNT(*) as count FROM token_usage WHERE project_id = ?",
+            (project_id,),
+        )
+        count = cursor.fetchone()["count"]
+        assert count == 3
+
+    @pytest.mark.asyncio
+    async def test_task_dependency_blocking(self, real_db: Database, test_workspace: Path):
+        """Test that dependent tasks wait for dependencies to complete."""
+        # Setup project
+        project_id = real_db.create_project(
+            name="dependency-test",
+            description="Test dependency blocking",
+            source_type="empty",
+            workspace_path=str(test_workspace),
+        )
+        issue_id = real_db.create_issue({
+            "project_id": project_id,
+            "issue_number": "DEP-001",
+            "title": "Dependency Issue",
+            "description": "Test",
+            "priority": 1,
+            "workflow_step": 1,
+        })
+
+        # Create parent task
+        parent_task_id = real_db.create_task_with_issue(
+            project_id=project_id,
+            issue_id=issue_id,
+            task_number="DEP-001-1",
+            parent_issue_number="DEP-001",
+            title="Parent Task",
+            description="This must complete first",
+            status=TaskStatus.PENDING,
+            priority=1,
+            workflow_step=1,
+            can_parallelize=False,
+        )
+
+        # Create dependent task (depends_on is tracked via workflow_step ordering)
+        dependent_task_id = real_db.create_task_with_issue(
+            project_id=project_id,
+            issue_id=issue_id,
+            task_number="DEP-001-2",
+            parent_issue_number="DEP-001",
+            title="Dependent Task",
+            description="This depends on parent task",
+            status=TaskStatus.PENDING,
+            priority=1,
+            workflow_step=2,  # Higher workflow_step indicates dependency order
+            can_parallelize=False,
+        )
+
+        # Get tasks for execution
+        parent_task = real_db.get_task(parent_task_id)
+        dependent_task = real_db.get_task(dependent_task_id)
+
+        # Verify workflow ordering (parent has lower step)
+        assert parent_task.workflow_step < dependent_task.workflow_step
+
+        # Register agents
+        real_db.create_agent(
+            agent_id="dep-agent-1",
+            agent_type="backend",
+            provider="anthropic",
+            maturity_level=AgentMaturity.D2,
+        )
+        real_db.create_agent(
+            agent_id="dep-agent-2",
+            agent_type="backend",
+            provider="anthropic",
+            maturity_level=AgentMaturity.D2,
+        )
+
+        # Complete parent task first
+        agent1 = WorkerAgent(
+            agent_id="dep-agent-1",
+            agent_type="backend",
+            provider="anthropic",
+            db=real_db,
+        )
+
+        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test-key"}):
+            with patch("codeframe.agents.worker_agent.AsyncAnthropic") as mock_api:
+                mock_response = Mock()
+                mock_response.content = [Mock(text="Done")]
+                mock_response.usage = Mock(input_tokens=100, output_tokens=50)
+                mock_api.return_value.messages.create = AsyncMock(
+                    return_value=mock_response
+                )
+
+                # Execute parent task
+                result = await agent1.execute_task(parent_task)
+                assert result["status"] == "completed"
+
+        # Simulate orchestrator updating task status based on result
+        real_db.update_task(parent_task_id, {"status": TaskStatus.COMPLETED.value})
+
+        # Verify parent completed
+        updated_parent = real_db.get_task(parent_task_id)
+        assert updated_parent.status == TaskStatus.COMPLETED
+
+        # Now dependent task can execute
+        agent2 = WorkerAgent(
+            agent_id="dep-agent-2",
+            agent_type="backend",
+            provider="anthropic",
+            db=real_db,
+        )
+
+        dependent_task = real_db.get_task(dependent_task_id)
+
+        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test-key"}):
+            with patch("codeframe.agents.worker_agent.AsyncAnthropic") as mock_api:
+                mock_response = Mock()
+                mock_response.content = [Mock(text="Dependent done")]
+                mock_response.usage = Mock(input_tokens=100, output_tokens=50)
+                mock_api.return_value.messages.create = AsyncMock(
+                    return_value=mock_response
+                )
+
+                result = await agent2.execute_task(dependent_task)
+                assert result["status"] == "completed"
+
+
+@pytest.mark.integration
+class TestAgentPoolManagement:
+    """Integration tests for agent pool management."""
+
+    def test_agent_pool_tracks_multiple_agents(self, real_db: Database):
+        """Test that agent pool correctly tracks multiple agents."""
+        # Create project
+        project_id = real_db.create_project(
+            name="pool-test",
+            description="Test agent pool",
+            source_type="empty",
+            workspace_path="/tmp/pool-test",
+        )
+
+        # Register multiple agents with different types
+        agent_configs = [
+            ("pool-backend-1", "backend", AgentMaturity.D2),
+            ("pool-backend-2", "backend", AgentMaturity.D3),
+            ("pool-frontend-1", "frontend", AgentMaturity.D1),
+            ("pool-test-1", "test", AgentMaturity.D2),
+        ]
+
+        for agent_id, agent_type, maturity in agent_configs:
+            real_db.create_agent(
+                agent_id=agent_id,
+                agent_type=agent_type,
+                provider="anthropic",
+                maturity_level=maturity,
+            )
+
+        # Verify all agents registered
+        cursor = real_db.conn.cursor()
+        cursor.execute("SELECT COUNT(*) as count FROM agents")
+        count = cursor.fetchone()["count"]
+        assert count == 4
+
+        # Verify agent types (column is 'type' not 'agent_type')
+        cursor.execute(
+            "SELECT type, COUNT(*) as count FROM agents GROUP BY type"
+        )
+        type_counts = {row["type"]: row["count"] for row in cursor.fetchall()}
+        assert type_counts["backend"] == 2
+        assert type_counts["frontend"] == 1
+        assert type_counts["test"] == 1
+
+    @pytest.mark.asyncio
+    async def test_agent_reuse_after_task_completion(
+        self, real_db: Database, test_workspace: Path
+    ):
+        """Test that agents can be reused for multiple tasks."""
+        # Setup project
+        project_id = real_db.create_project(
+            name="reuse-test",
+            description="Test agent reuse",
+            source_type="empty",
+            workspace_path=str(test_workspace),
+        )
+        issue_id = real_db.create_issue({
+            "project_id": project_id,
+            "issue_number": "REUSE-001",
+            "title": "Reuse Issue",
+            "description": "Test",
+            "priority": 1,
+            "workflow_step": 1,
+        })
+
+        # Create multiple tasks
+        task_ids = []
+        for i in range(3):
+            task_id = real_db.create_task_with_issue(
+                project_id=project_id,
+                issue_id=issue_id,
+                task_number=f"REUSE-001-{i+1}",
+                parent_issue_number="REUSE-001",
+                title=f"Reuse Task {i+1}",
+                description=f"Task {i+1}",
+                status=TaskStatus.PENDING,
+                priority=1,
+                workflow_step=i + 1,
+                can_parallelize=False,
+            )
+            task_ids.append(task_id)
+
+        # Create single agent
+        real_db.create_agent(
+            agent_id="reuse-agent",
+            agent_type="backend",
+            provider="anthropic",
+            maturity_level=AgentMaturity.D2,
+        )
+
+        agent = WorkerAgent(
+            agent_id="reuse-agent",
+            agent_type="backend",
+            provider="anthropic",
+            db=real_db,
+        )
+
+        # Execute all tasks sequentially with the same agent
+        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test-key"}):
+            with patch("codeframe.agents.worker_agent.AsyncAnthropic") as mock_api:
+                mock_response = Mock()
+                mock_response.content = [Mock(text="Done")]
+                mock_response.usage = Mock(input_tokens=100, output_tokens=50)
+                mock_api.return_value.messages.create = AsyncMock(
+                    return_value=mock_response
+                )
+
+                for task_id in task_ids:
+                    task = real_db.get_task(task_id)
+                    result = await agent.execute_task(task)
+                    assert result["status"] == "completed"
+
+        # Verify all tasks assigned to same agent
+        cursor = real_db.conn.cursor()
+        for task_id in task_ids:
+            cursor.execute(
+                "SELECT assigned_to FROM tasks WHERE id = ?", (task_id,)
+            )
+            row = cursor.fetchone()
+            # Note: assigned_to might not be set by execute_task, depends on implementation
+            # The important thing is all tasks were completed by the same agent
+
+        # Verify token usage shows all calls from same agent
+        cursor.execute(
+            "SELECT agent_id, COUNT(*) as count FROM token_usage "
+            "WHERE project_id = ? GROUP BY agent_id",
+            (project_id,),
+        )
+        usage = cursor.fetchall()
+        assert len(usage) == 1
+        assert usage[0]["agent_id"] == "reuse-agent"
+        assert usage[0]["count"] == 3
+
+
+@pytest.mark.integration
+class TestErrorRecoveryAndRetry:
+    """Integration tests for error recovery and retry logic."""
+
+    @pytest.mark.asyncio
+    async def test_task_retry_after_transient_failure(
+        self, real_db: Database, test_workspace: Path
+    ):
+        """Test that tasks retry after transient API failures."""
+        # Setup
+        project_id = real_db.create_project(
+            name="retry-test",
+            description="Test retry logic",
+            source_type="empty",
+            workspace_path=str(test_workspace),
+        )
+        issue_id = real_db.create_issue({
+            "project_id": project_id,
+            "issue_number": "RETRY-001",
+            "title": "Retry Issue",
+            "description": "Test",
+            "priority": 1,
+            "workflow_step": 1,
+        })
+        task_id = real_db.create_task_with_issue(
+            project_id=project_id,
+            issue_id=issue_id,
+            task_number="RETRY-001-1",
+            parent_issue_number="RETRY-001",
+            title="Retry Task",
+            description="Test retry after failure",
+            status=TaskStatus.PENDING,
+            priority=1,
+            workflow_step=1,
+            can_parallelize=False,
+        )
+        task = real_db.get_task(task_id)
+
+        # Register agent
+        real_db.create_agent(
+            agent_id="retry-agent",
+            agent_type="backend",
+            provider="anthropic",
+            maturity_level=AgentMaturity.D2,
+        )
+
+        agent = WorkerAgent(
+            agent_id="retry-agent",
+            agent_type="backend",
+            provider="anthropic",
+            db=real_db,
+        )
+
+        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test-key"}):
+            with patch("codeframe.agents.worker_agent.AsyncAnthropic") as mock_api:
+                from anthropic import APIConnectionError
+
+                # First 2 calls fail, third succeeds
+                success_response = Mock()
+                success_response.content = [Mock(text="Success after retry")]
+                success_response.usage = Mock(input_tokens=100, output_tokens=50)
+
+                mock_api.return_value.messages.create = AsyncMock(
+                    side_effect=[
+                        APIConnectionError(request=Mock()),
+                        APIConnectionError(request=Mock()),
+                        success_response,
+                    ]
+                )
+
+                result = await agent.execute_task(task)
+
+        # Should succeed after retries
+        assert result["status"] == "completed"
+
+        # Verify API was called 3 times
+        assert mock_api.return_value.messages.create.call_count == 3
+
+    @pytest.mark.asyncio
+    async def test_task_fails_after_max_retries(
+        self, real_db: Database, test_workspace: Path
+    ):
+        """Test that tasks fail after exhausting retry attempts."""
+        # Setup
+        project_id = real_db.create_project(
+            name="max-retry-test",
+            description="Test max retries",
+            source_type="empty",
+            workspace_path=str(test_workspace),
+        )
+        issue_id = real_db.create_issue({
+            "project_id": project_id,
+            "issue_number": "MAX-001",
+            "title": "Max Retry Issue",
+            "description": "Test",
+            "priority": 1,
+            "workflow_step": 1,
+        })
+        task_id = real_db.create_task_with_issue(
+            project_id=project_id,
+            issue_id=issue_id,
+            task_number="MAX-001-1",
+            parent_issue_number="MAX-001",
+            title="Max Retry Task",
+            description="Should fail after max retries",
+            status=TaskStatus.PENDING,
+            priority=1,
+            workflow_step=1,
+            can_parallelize=False,
+        )
+        task = real_db.get_task(task_id)
+
+        real_db.create_agent(
+            agent_id="max-retry-agent",
+            agent_type="backend",
+            provider="anthropic",
+            maturity_level=AgentMaturity.D2,
+        )
+
+        agent = WorkerAgent(
+            agent_id="max-retry-agent",
+            agent_type="backend",
+            provider="anthropic",
+            db=real_db,
+        )
+
+        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test-key"}):
+            with patch("codeframe.agents.worker_agent.AsyncAnthropic") as mock_api:
+                from anthropic import APIConnectionError
+
+                # All calls fail
+                mock_api.return_value.messages.create = AsyncMock(
+                    side_effect=APIConnectionError(request=Mock())
+                )
+
+                result = await agent.execute_task(task)
+
+        # Should fail
+        assert result["status"] == "failed"
+        assert "retry" in result["output"].lower()
+
+        # Simulate orchestrator updating task status based on failure result
+        real_db.update_task(task_id, {"status": TaskStatus.FAILED.value})
+
+        # Verify task status in database
+        updated_task = real_db.get_task(task_id)
+        assert updated_task.status == TaskStatus.FAILED
+
+
+@pytest.mark.integration
+class TestDatabaseConsistency:
+    """Integration tests for database consistency during multi-agent operations."""
+
+    @pytest.mark.asyncio
+    async def test_batch_task_updates_no_data_loss(
+        self, real_db: Database, test_workspace: Path
+    ):
+        """Test that batch task updates don't cause data loss."""
+        # Setup
+        project_id = real_db.create_project(
+            name="batch-test",
+            description="Test batch updates",
+            source_type="empty",
+            workspace_path=str(test_workspace),
+        )
+        issue_id = real_db.create_issue({
+            "project_id": project_id,
+            "issue_number": "BATCH-001",
+            "title": "Batch Issue",
+            "description": "Test",
+            "priority": 1,
+            "workflow_step": 1,
+        })
+
+        # Create multiple tasks
+        task_ids = []
+        for i in range(10):
+            task_id = real_db.create_task_with_issue(
+                project_id=project_id,
+                issue_id=issue_id,
+                task_number=f"BATCH-001-{i+1:02d}",
+                parent_issue_number="BATCH-001",
+                title=f"Batch Task {i+1}",
+                description=f"Task {i+1}",
+                status=TaskStatus.PENDING,
+                priority=1,
+                workflow_step=i + 1,
+                can_parallelize=True,
+            )
+            task_ids.append(task_id)
+
+        # Update all tasks sequentially
+        for i, task_id in enumerate(task_ids):
+            status = TaskStatus.COMPLETED.value if i % 2 == 0 else TaskStatus.FAILED.value
+            real_db.update_task(task_id, {"status": status})
+
+        # Verify all updates persisted correctly
+        completed_count = 0
+        failed_count = 0
+        for task_id in task_ids:
+            task = real_db.get_task(task_id)
+            if task.status == TaskStatus.COMPLETED:
+                completed_count += 1
+            elif task.status == TaskStatus.FAILED:
+                failed_count += 1
+
+        assert completed_count == 5  # Even indices
+        assert failed_count == 5  # Odd indices
+        assert completed_count + failed_count == 10
+
+    @pytest.mark.asyncio
+    async def test_token_usage_consistency_under_load(
+        self, real_db: Database, test_workspace: Path
+    ):
+        """Test that token usage is correctly recorded under concurrent load."""
+        # Setup
+        project_id = real_db.create_project(
+            name="token-load-test",
+            description="Test token recording under load",
+            source_type="empty",
+            workspace_path=str(test_workspace),
+        )
+
+        # Record many token usage entries concurrently
+        import threading
+
+        errors = []
+        record_count = [0]
+        lock = threading.Lock()
+
+        def record_usage(i: int):
+            try:
+                token_usage = TokenUsage(
+                    task_id=None,  # No task, just project-level
+                    agent_id=f"load-agent-{i}",
+                    project_id=project_id,
+                    model_name="claude-sonnet-4-5",
+                    input_tokens=100 + i,
+                    output_tokens=50 + i,
+                    estimated_cost_usd=0.001 * (i + 1),
+                    call_type=CallType.TASK_EXECUTION,
+                )
+                real_db.save_token_usage(token_usage)
+                with lock:
+                    record_count[0] += 1
+            except Exception as e:
+                errors.append(str(e))
+
+        # Run concurrent recordings
+        threads = []
+        for i in range(20):
+            t = threading.Thread(target=record_usage, args=(i,))
+            threads.append(t)
+            t.start()
+
+        for t in threads:
+            t.join()
+
+        # Verify no errors
+        assert len(errors) == 0, f"Token recording errors: {errors}"
+        assert record_count[0] == 20
+
+        # Verify all records exist
+        cursor = real_db.conn.cursor()
+        cursor.execute(
+            "SELECT COUNT(*) as count FROM token_usage WHERE project_id = ?",
+            (project_id,),
+        )
+        count = cursor.fetchone()["count"]
+        assert count == 20
+
+        # Verify totals are correct
+        cursor.execute(
+            "SELECT SUM(input_tokens) as total FROM token_usage WHERE project_id = ?",
+            (project_id,),
+        )
+        total = cursor.fetchone()["total"]
+        expected_total = sum(100 + i for i in range(20))
+        assert total == expected_total
diff --git a/tests/integration/test_worker_agent_execution.py b/tests/integration/test_worker_agent_execution.py
new file mode 100644
index 00000000..25213345
--- /dev/null
+++ b/tests/integration/test_worker_agent_execution.py
@@ -0,0 +1,724 @@
+"""
+Integration tests for Worker Agent task execution.
+
+These tests verify real agent behavior with:
+- Real SQLite database operations
+- Real file system operations
+- Real token tracking
+- Real quality gate subprocess execution (where safe)
+- Only external LLM API is mocked
+
+Key difference from unit tests:
+- Unit tests: Mock database, file ops, and internal methods to test logic
+- Integration tests: Use real components, mock only external services
+"""
+
+import json
+import os
+from pathlib import Path
+from unittest.mock import AsyncMock, Mock, patch
+
+import pytest
+
+from codeframe.agents.worker_agent import WorkerAgent
+from codeframe.agents.backend_worker_agent import BackendWorkerAgent
+from codeframe.core.models import AgentMaturity, CallType, TaskStatus
+from codeframe.indexing.codebase_index import CodebaseIndex
+from codeframe.persistence.database import Database
+
+
+@pytest.mark.integration
+class TestWorkerAgentTokenTracking:
+    """Integration tests for token usage tracking with real database."""
+
+    @pytest.mark.asyncio
+    async def test_token_usage_recorded_in_database(self, real_db: Database):
+        """Test that token usage is actually saved to the database after task execution."""
+        # Setup - create project and task in real database
+        project_id = real_db.create_project(
+            name="token-tracking-test",
+            description="Test token tracking",
+            source_type="empty",
+            workspace_path="/tmp/test-token-tracking",
+        )
+        issue_id = real_db.create_issue({
+            "project_id": project_id,
+            "issue_number": "TOK-001",
+            "title": "Token Tracking Issue",
+            "description": "Test",
+            "priority": 1,
+            "workflow_step": 1,
+        })
+        task_id = real_db.create_task_with_issue(
+            project_id=project_id,
+            issue_id=issue_id,
+            task_number="TOK-001-1",
+            parent_issue_number="TOK-001",
+            title="Test Token Recording",
+            description="Simple task to test token recording",
+            status=TaskStatus.PENDING,
+            priority=1,
+            workflow_step=1,
+            can_parallelize=False,
+        )
+        task = real_db.get_task(task_id)
+
+        # Create agent with real database
+        agent = WorkerAgent(
+            agent_id="test-token-agent",
+            agent_type="backend",
+            provider="anthropic",
+            db=real_db,
+            model_name="claude-sonnet-4-5",
+        )
+
+        # Mock only the external Anthropic API
+        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test-key"}):
+            with patch("codeframe.agents.worker_agent.AsyncAnthropic") as mock_anthropic:
+                mock_response = Mock()
+                mock_response.content = [Mock(text="Task completed successfully.")]
+                mock_response.usage = Mock(input_tokens=1500, output_tokens=750)
+                mock_anthropic.return_value.messages.create = AsyncMock(
+                    return_value=mock_response
+                )
+
+                # Execute task
+                result = await agent.execute_task(task)
+
+        # Verify - check real database for token usage record
+        assert result["status"] == "completed"
+
+        cursor = real_db.conn.cursor()
+        cursor.execute(
+            "SELECT * FROM token_usage WHERE task_id = ?", (task_id,)
+        )
+        usage_row = cursor.fetchone()
+
+        assert usage_row is not None, "Token usage was not recorded in database"
+        assert usage_row["input_tokens"] == 1500
+        assert usage_row["output_tokens"] == 750
+        assert usage_row["model_name"] == "claude-sonnet-4-5"
+        assert usage_row["agent_id"] == "test-token-agent"
+        assert usage_row["call_type"] == CallType.TASK_EXECUTION.value
+
+    @pytest.mark.asyncio
+    async def test_multiple_tasks_accumulate_token_usage(self, real_db: Database):
+        """Test that multiple task executions properly accumulate token usage."""
+        # Setup project with multiple tasks
+        project_id = real_db.create_project(
+            name="multi-task-test",
+            description="Test multiple task token tracking",
+            source_type="empty",
+            workspace_path="/tmp/test-multi-task",
+        )
+        issue_id = real_db.create_issue({
+            "project_id": project_id,
+            "issue_number": "MULTI-001",
+            "title": "Multi Task Issue",
+            "description": "Test",
+            "priority": 1,
+            "workflow_step": 1,
+        })
+
+        # Create 3 tasks
+        task_ids = []
+        for i in range(3):
+            task_id = real_db.create_task_with_issue(
+                project_id=project_id,
+                issue_id=issue_id,
+                task_number=f"MULTI-001-{i+1}",
+                parent_issue_number="MULTI-001",
+                title=f"Task {i+1}",
+                description=f"Task {i+1} description",
+                status=TaskStatus.PENDING,
+                priority=1,
+                workflow_step=i + 1,
+                can_parallelize=False,
+            )
+            task_ids.append(task_id)
+
+        agent = WorkerAgent(
+            agent_id="test-multi-agent",
+            agent_type="backend",
+            provider="anthropic",
+            db=real_db,
+        )
+
+        # Execute all tasks with different token counts
+        token_counts = [(500, 200), (800, 400), (1200, 600)]
+
+        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test-key"}):
+            with patch("codeframe.agents.worker_agent.AsyncAnthropic") as mock_anthropic:
+                for i, task_id in enumerate(task_ids):
+                    task = real_db.get_task(task_id)
+                    input_tokens, output_tokens = token_counts[i]
+
+                    mock_response = Mock()
+                    mock_response.content = [Mock(text=f"Task {i+1} done")]
+                    mock_response.usage = Mock(
+                        input_tokens=input_tokens, output_tokens=output_tokens
+                    )
+                    mock_anthropic.return_value.messages.create = AsyncMock(
+                        return_value=mock_response
+                    )
+
+                    await agent.execute_task(task)
+
+        # Verify total token usage in database
+        cursor = real_db.conn.cursor()
+        cursor.execute(
+            "SELECT SUM(input_tokens) as total_input, SUM(output_tokens) as total_output "
+            "FROM token_usage WHERE project_id = ?",
+            (project_id,),
+        )
+        row = cursor.fetchone()
+
+        expected_input = sum(t[0] for t in token_counts)
+        expected_output = sum(t[1] for t in token_counts)
+
+        assert row["total_input"] == expected_input
+        assert row["total_output"] == expected_output
+
+
+@pytest.mark.integration
+class TestWorkerAgentTaskExecution:
+    """Integration tests for complete task execution workflow."""
+
+    @pytest.mark.asyncio
+    async def test_task_execution_returns_success_result(self, real_db: Database):
+        """Test that task execution returns success and caller can update status.
+
+        Note: WorkerAgent.execute_task() returns results but doesn't update
+        task status directly - the orchestrator (LeadAgent/API) does that.
+        This test verifies the execution + manual status update flow.
+        """
+        # Setup
+        project_id = real_db.create_project(
+            name="status-test",
+            description="Test status transitions",
+            source_type="empty",
+            workspace_path="/tmp/test-status",
+        )
+        issue_id = real_db.create_issue({
+            "project_id": project_id,
+            "issue_number": "ST-001",
+            "title": "Status Issue",
+            "description": "Test",
+            "priority": 1,
+            "workflow_step": 1,
+        })
+        task_id = real_db.create_task_with_issue(
+            project_id=project_id,
+            issue_id=issue_id,
+            task_number="ST-001-1",
+            parent_issue_number="ST-001",
+            title="Status Test Task",
+            description="Test status transitions",
+            status=TaskStatus.PENDING,
+            priority=1,
+            workflow_step=1,
+            can_parallelize=False,
+        )
+
+        # Verify initial status
+        task = real_db.get_task(task_id)
+        assert task.status == TaskStatus.PENDING
+
+        agent = WorkerAgent(
+            agent_id="test-status-agent",
+            agent_type="backend",
+            provider="anthropic",
+            db=real_db,
+        )
+
+        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test-key"}):
+            with patch("codeframe.agents.worker_agent.AsyncAnthropic") as mock_anthropic:
+                mock_response = Mock()
+                mock_response.content = [Mock(text="Complete")]
+                mock_response.usage = Mock(input_tokens=100, output_tokens=50)
+                mock_anthropic.return_value.messages.create = AsyncMock(
+                    return_value=mock_response
+                )
+
+                result = await agent.execute_task(task)
+
+        # Verify execution result indicates success
+        assert result["status"] == "completed"
+        assert result["output"] == "Complete"
+
+        # Simulate orchestrator updating task status based on result
+        real_db.update_task(task_id, {"status": TaskStatus.COMPLETED.value})
+
+        # Verify status updated in database
+        updated_task = real_db.get_task(task_id)
+        assert updated_task.status == TaskStatus.COMPLETED
+
+    @pytest.mark.asyncio
+    async def test_task_execution_returns_failure_result(self, real_db: Database):
+        """Test that task execution returns failure and caller can update status.
+
+        Note: WorkerAgent.execute_task() returns failure results but doesn't
+        update task status directly - the orchestrator handles that.
+        """
+        # Setup
+        project_id = real_db.create_project(
+            name="failure-test",
+            description="Test failure recording",
+            source_type="empty",
+            workspace_path="/tmp/test-failure",
+        )
+        issue_id = real_db.create_issue({
+            "project_id": project_id,
+            "issue_number": "FAIL-001",
+            "title": "Failure Issue",
+            "description": "Test",
+            "priority": 1,
+            "workflow_step": 1,
+        })
+        task_id = real_db.create_task_with_issue(
+            project_id=project_id,
+            issue_id=issue_id,
+            task_number="FAIL-001-1",
+            parent_issue_number="FAIL-001",
+            title="Failure Test Task",
+            description="This task should fail",
+            status=TaskStatus.PENDING,
+            priority=1,
+            workflow_step=1,
+            can_parallelize=False,
+        )
+        task = real_db.get_task(task_id)
+
+        agent = WorkerAgent(
+            agent_id="test-failure-agent",
+            agent_type="backend",
+            provider="anthropic",
+            db=real_db,
+        )
+
+        # Simulate API failure
+        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test-key"}):
+            with patch("codeframe.agents.worker_agent.AsyncAnthropic") as mock_anthropic:
+                from anthropic import APIConnectionError
+
+                mock_anthropic.return_value.messages.create = AsyncMock(
+                    side_effect=APIConnectionError(request=Mock())
+                )
+
+                result = await agent.execute_task(task)
+
+        # Verify failure result
+        assert result["status"] == "failed"
+        assert "error" in result or "output" in result
+
+        # Simulate orchestrator updating task status based on result
+        real_db.update_task(task_id, {"status": TaskStatus.FAILED.value})
+
+        # Verify status updated in database
+        updated_task = real_db.get_task(task_id)
+        assert updated_task.status == TaskStatus.FAILED
+
+
+@pytest.mark.integration
+class TestBackendWorkerAgentFileOperations:
+    """Integration tests for backend worker file operations."""
+
+    @pytest.mark.asyncio
+    async def test_file_creation_with_real_filesystem(
+        self, real_db: Database, test_workspace: Path
+    ):
+        """Test that file creation actually writes to the filesystem."""
+        # Setup
+        project_id = real_db.create_project(
+            name="file-test",
+            description="Test file creation",
+            source_type="empty",
+            workspace_path=str(test_workspace),
+        )
+        issue_id = real_db.create_issue({
+            "project_id": project_id,
+            "issue_number": "FILE-001",
+            "title": "File Issue",
+            "description": "Test",
+            "priority": 1,
+            "workflow_step": 1,
+        })
+        task_id = real_db.create_task_with_issue(
+            project_id=project_id,
+            issue_id=issue_id,
+            task_number="FILE-001-1",
+            parent_issue_number="FILE-001",
+            title="Create User Model",
+            description="Create a User model class",
+            status=TaskStatus.PENDING,
+            priority=1,
+            workflow_step=1,
+            can_parallelize=False,
+        )
+
+        cursor = real_db.conn.cursor()
+        cursor.execute("SELECT * FROM tasks WHERE id = ?", (task_id,))
+        task = dict(cursor.fetchone())
+
+        # Create codebase index mock (only indexing, not file ops)
+        index = Mock(spec=CodebaseIndex)
+        index.search_pattern.return_value = []
+
+        agent = BackendWorkerAgent(
+            db=real_db,
+            codebase_index=index,
+            api_key="test-key",
+            project_root=test_workspace,
+            use_sdk=False,
+        )
+
+        # Mock only the LLM API response
+        llm_response = json.dumps({
+            "files": [
+                {
+                    "path": "src/models/user.py",
+                    "action": "create",
+                    "content": (
+                        'class User:\n'
+                        '    """User model."""\n'
+                        '    def __init__(self, name: str, email: str):\n'
+                        '        self.name = name\n'
+                        '        self.email = email\n'
+                    ),
+                },
+                {
+                    "path": "tests/test_user.py",
+                    "action": "create",
+                    "content": (
+                        'from src.models.user import User\n\n'
+                        'def test_user_creation():\n'
+                        '    user = User("Alice", "alice@example.com")\n'
+                        '    assert user.name == "Alice"\n'
+                    ),
+                },
+            ],
+            "explanation": "Created User model with tests",
+        })
+
+        with patch("anthropic.AsyncAnthropic") as mock_anthropic:
+            mock_response = Mock()
+            mock_response.content = [Mock(text=llm_response)]
+            mock_anthropic.return_value = Mock(
+                messages=Mock(create=AsyncMock(return_value=mock_response))
+            )
+
+            # Mock test runner to avoid actual test execution
+            with patch(
+                "codeframe.testing.test_runner.TestRunner.run_tests"
+            ) as mock_tests:
+                from codeframe.testing.models import TestResult
+
+                mock_tests.return_value = TestResult(
+                    status="passed",
+                    total=1,
+                    passed=1,
+                    failed=0,
+                    errors=0,
+                    skipped=0,
+                    duration=0.1,
+                )
+
+                result = await agent.execute_task(task)
+
+        # Verify files were actually created on disk
+        assert result["status"] == "completed"
+        assert (test_workspace / "src" / "models" / "user.py").exists()
+        assert (test_workspace / "tests" / "test_user.py").exists()
+
+        # Verify file contents
+        user_content = (test_workspace / "src" / "models" / "user.py").read_text()
+        assert "class User:" in user_content
+        assert "def __init__" in user_content
+        assert "self.name" in user_content
+
+    @pytest.mark.asyncio
+    async def test_file_modification_preserves_content(
+        self, real_db: Database, test_workspace: Path
+    ):
+        """Test that file modification correctly updates existing files."""
+        # Create initial file
+        (test_workspace / "src").mkdir(parents=True, exist_ok=True)
+        original_file = test_workspace / "src" / "app.py"
+        original_file.write_text("# Original content\ndef old_function():\n    pass\n")
+
+        # Setup database
+        project_id = real_db.create_project(
+            name="modify-test",
+            description="Test file modification",
+            source_type="empty",
+            workspace_path=str(test_workspace),
+        )
+        issue_id = real_db.create_issue({
+            "project_id": project_id,
+            "issue_number": "MOD-001",
+            "title": "Modify Issue",
+            "description": "Test",
+            "priority": 1,
+            "workflow_step": 1,
+        })
+        task_id = real_db.create_task_with_issue(
+            project_id=project_id,
+            issue_id=issue_id,
+            task_number="MOD-001-1",
+            parent_issue_number="MOD-001",
+            title="Update App",
+            description="Add new function",
+            status=TaskStatus.PENDING,
+            priority=1,
+            workflow_step=1,
+            can_parallelize=False,
+        )
+
+        cursor = real_db.conn.cursor()
+        cursor.execute("SELECT * FROM tasks WHERE id = ?", (task_id,))
+        task = dict(cursor.fetchone())
+
+        index = Mock(spec=CodebaseIndex)
+        index.search_pattern.return_value = []
+
+        agent = BackendWorkerAgent(
+            db=real_db,
+            codebase_index=index,
+            api_key="test-key",
+            project_root=test_workspace,
+            use_sdk=False,
+        )
+
+        # LLM response modifying the file
+        llm_response = json.dumps({
+            "files": [
+                {
+                    "path": "src/app.py",
+                    "action": "modify",
+                    "content": (
+                        "# Updated content\n"
+                        "def new_function():\n"
+                        "    return 'Hello, World!'\n"
+                    ),
+                }
+            ],
+            "explanation": "Updated app with new function",
+        })
+
+        with patch("anthropic.AsyncAnthropic") as mock_anthropic:
+            mock_response = Mock()
+            mock_response.content = [Mock(text=llm_response)]
+            mock_anthropic.return_value = Mock(
+                messages=Mock(create=AsyncMock(return_value=mock_response))
+            )
+
+            with patch(
+                "codeframe.testing.test_runner.TestRunner.run_tests"
+            ) as mock_tests:
+                from codeframe.testing.models import TestResult
+
+                mock_tests.return_value = TestResult(
+                    status="passed",
+                    total=0,
+                    passed=0,
+                    failed=0,
+                    errors=0,
+                    skipped=0,
+                    duration=0.0,
+                )
+
+                result = await agent.execute_task(task)
+
+        # Verify file was modified
+        assert result["status"] == "completed"
+        modified_content = (test_workspace / "src" / "app.py").read_text()
+        assert "new_function" in modified_content
+        assert "old_function" not in modified_content
+
+
+@pytest.mark.integration
+class TestWorkerAgentMaturityAssessment:
+    """Integration tests for agent maturity assessment with real database."""
+
+    def test_maturity_assessment_with_task_history(self, real_db: Database):
+        """Test maturity calculation based on actual task history in database."""
+        # Register agent
+        real_db.create_agent(
+            agent_id="maturity-test-agent",
+            agent_type="backend",
+            provider="anthropic",
+            maturity_level=AgentMaturity.D1,
+        )
+
+        # Create project and tasks
+        project_id = real_db.create_project(
+            name="maturity-test",
+            description="Test maturity assessment",
+            source_type="empty",
+            workspace_path="/tmp/test-maturity",
+        )
+        issue_id = real_db.create_issue({
+            "project_id": project_id,
+            "issue_number": "MAT-001",
+            "title": "Maturity Issue",
+            "description": "Test",
+            "priority": 1,
+            "workflow_step": 1,
+        })
+
+        # Create completed tasks (80% completion rate)
+        for i in range(10):
+            status = TaskStatus.COMPLETED if i < 8 else TaskStatus.PENDING
+            task_id = real_db.create_task_with_issue(
+                project_id=project_id,
+                issue_id=issue_id,
+                task_number=f"MAT-001-{i+1}",
+                parent_issue_number="MAT-001",
+                title=f"Task {i+1}",
+                description="Test task",
+                status=status,
+                priority=1,
+                workflow_step=i + 1,
+                can_parallelize=False,
+            )
+            real_db.update_task(task_id, {"assigned_to": "maturity-test-agent"})
+
+            # Add test results for completed tasks (75% pass rate)
+            if status == TaskStatus.COMPLETED:
+                real_db.create_test_result(
+                    task_id=task_id,
+                    status="passed" if i < 6 else "failed",
+                    passed=3 if i < 6 else 1,
+                    failed=1 if i < 6 else 3,
+                )
+
+        # Create agent and assess maturity
+        agent = WorkerAgent(
+            agent_id="maturity-test-agent",
+            agent_type="backend",
+            provider="anthropic",
+            db=real_db,
+        )
+
+        result = agent.assess_maturity()
+
+        # Verify maturity is calculated based on real data
+        assert result["maturity_level"] in [AgentMaturity.D2, AgentMaturity.D3]
+        assert result["metrics"]["task_count"] == 10
+        assert result["metrics"]["completion_rate"] == 0.8
+        assert result["metrics"]["tasks_with_tests"] == 8
+
+        # Verify database was updated
+        agent_data = real_db.get_agent("maturity-test-agent")
+        assert agent_data["maturity_level"] == result["maturity_level"].value
+
+
+@pytest.mark.integration
+class TestWorkerAgentSecurityValidation:
+    """Integration tests for security features with real validation."""
+
+    @pytest.mark.asyncio
+    async def test_api_key_validation_blocks_invalid_keys(self, real_db: Database):
+        """Test that invalid API keys are rejected before API call."""
+        project_id = real_db.create_project(
+            name="security-test",
+            description="Test security",
+            source_type="empty",
+            workspace_path="/tmp/test-security",
+        )
+        issue_id = real_db.create_issue({
+            "project_id": project_id,
+            "issue_number": "SEC-001",
+            "title": "Security Issue",
+            "description": "Test",
+            "priority": 1,
+            "workflow_step": 1,
+        })
+        task_id = real_db.create_task_with_issue(
+            project_id=project_id,
+            issue_id=issue_id,
+            task_number="SEC-001-1",
+            parent_issue_number="SEC-001",
+            title="Security Task",
+            description="Test security validation",
+            status=TaskStatus.PENDING,
+            priority=1,
+            workflow_step=1,
+            can_parallelize=False,
+        )
+        task = real_db.get_task(task_id)
+
+        agent = WorkerAgent(
+            agent_id="test-security-agent",
+            agent_type="backend",
+            provider="anthropic",
+            db=real_db,
+        )
+
+        # Test with invalid key format
+        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "invalid-format"}):
+            with pytest.raises(ValueError, match="Invalid ANTHROPIC_API_KEY format"):
+                await agent.execute_task(task)
+
+    @pytest.mark.asyncio
+    async def test_rate_limiting_enforced(self, real_db: Database):
+        """Test that rate limiting actually prevents excessive API calls."""
+        project_id = real_db.create_project(
+            name="rate-limit-test",
+            description="Test rate limiting",
+            source_type="empty",
+            workspace_path="/tmp/test-rate-limit",
+        )
+        issue_id = real_db.create_issue({
+            "project_id": project_id,
+            "issue_number": "RL-001",
+            "title": "Rate Limit Issue",
+            "description": "Test",
+            "priority": 1,
+            "workflow_step": 1,
+        })
+        task_id = real_db.create_task_with_issue(
+            project_id=project_id,
+            issue_id=issue_id,
+            task_number="RL-001-1",
+            parent_issue_number="RL-001",
+            title="Rate Limit Task",
+            description="Test rate limiting",
+            status=TaskStatus.PENDING,
+            priority=1,
+            workflow_step=1,
+            can_parallelize=False,
+        )
+        task = real_db.get_task(task_id)
+
+        # Set low rate limit for testing
+        with patch.dict(
+            os.environ,
+            {"ANTHROPIC_API_KEY": "sk-ant-test-key", "AGENT_RATE_LIMIT": "2"},
+        ):
+            agent = WorkerAgent(
+                agent_id="test-rate-agent",
+                agent_type="backend",
+                provider="anthropic",
+                db=real_db,
+            )
+
+            with patch("codeframe.agents.worker_agent.AsyncAnthropic") as mock_api:
+                mock_response = Mock()
+                mock_response.content = [Mock(text="Done")]
+                mock_response.usage = Mock(input_tokens=100, output_tokens=50)
+                mock_api.return_value.messages.create = AsyncMock(
+                    return_value=mock_response
+                )
+
+                # First 2 calls should succeed
+                result1 = await agent.execute_task(task)
+                assert result1["status"] == "completed"
+
+                result2 = await agent.execute_task(task)
+                assert result2["status"] == "completed"
+
+                # Third call should hit rate limit
+                result3 = await agent.execute_task(task)
+                assert result3["status"] == "failed"
+                assert "rate limit" in result3["output"].lower()
diff --git a/web-ui/src/components/Dashboard.tsx b/web-ui/src/components/Dashboard.tsx
index aadfe8cd..59082683 100644
--- a/web-ui/src/components/Dashboard.tsx
+++ b/web-ui/src/components/Dashboard.tsx
@@ -291,12 +291,13 @@ export default function Dashboard({ projectId }: DashboardProps) {
       {/* Tab Navigation (T009 - Feature 013) */}
       <div className="bg-card border-b border-border">
         <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
-          <nav className="-mb-px flex space-x-8" role="tablist" aria-label="Dashboard tabs">
+          <nav className="-mb-px flex space-x-8" role="tablist" aria-label="Dashboard tabs" data-testid="nav-menu">
             <button
               role="tab"
               aria-selected={activeTab === 'overview'}
               aria-controls="overview-panel"
               onClick={() => setActiveTab('overview')}
+              data-testid="overview-tab"
               className={`py-4 px-1 border-b-2 font-medium text-sm transition-colors ${
                 activeTab === 'overview'
                   ? 'border-primary text-primary'
@@ -310,6 +311,7 @@ export default function Dashboard({ projectId }: DashboardProps) {
               aria-selected={activeTab === 'context'}
               aria-controls="context-panel"
               onClick={() => setActiveTab('context')}
+              data-testid="context-tab"
               className={`py-4 px-1 border-b-2 font-medium text-sm transition-colors ${
                 activeTab === 'context'
                   ? 'border-primary text-primary'