cleanup: remove obsolete code and unused fields

.gitignore

@@ -6,3 +6,6 @@
 .coverage
 __pycache__/
 *.pyc
+
+# Database
+db.sqlite3

SPEC-DEMO-GUI.md

@@ -94,7 +94,8 @@ wall-construction-gui/
 │   ├── pages/               # Page-level components
 │   │   ├── Dashboard.jsx
 │   │   ├── ProfileDetail.jsx
-│   │   ├── ProgressForm.jsx
+│   │   ├── SimulationForm.jsx
+│   │   ├── SimulationResults.jsx
 │   │   ├── DailyIceUsage.jsx
 │   │   └── CostAnalytics.jsx
 │   ├── hooks/               # Custom React hooks
@@ -354,9 +355,9 @@ export default function BarChart({ data, dataKey, xKey, color = '#10b981' }) {
 ### 1. Dashboard
 **File**: `src/pages/Dashboard.jsx`
 
-**Purpose**: Display all construction profiles as cards with summary statistics
+**Purpose**: Display simulation results overview with total statistics
 
-**Data Source**: `GET /api/profiles/` + parallel `GET /api/profiles/{id}/cost-overview/`
+**Data Source**: `GET /api/simulation/overview/total/`
 
 **Components**:
 - Grid of profile cards
@@ -373,9 +374,9 @@ export default function BarChart({ data, dataKey, xKey, color = '#10b981' }) {
 ### 2. ProfileDetail
 **File**: `src/pages/ProfileDetail.jsx`
 
-**Purpose**: Detailed view of a single profile with cost analytics and daily breakdown
+**Purpose**: Detailed view of simulation results by day
 
-**Data Source**: `GET /api/profiles/{id}/cost-overview/?start_date=X&end_date=Y`
+**Data Source**: `GET /api/simulation/overview/{day}/` or `GET /api/simulation/overview/all-by-day/`
 
 **Components**:
 - Profile header (name, team lead)
@@ -391,30 +392,49 @@ export default function BarChart({ data, dataKey, xKey, color = '#10b981' }) {
 - Download CSV button (client-side generation)
 - Print-friendly layout
 
-### 3. ProgressForm
-**File**: `src/pages/ProgressForm.jsx`
+### 3. SimulationForm
+**File**: `src/pages/SimulationForm.jsx`
 
-**Purpose**: Record daily construction progress for a wall section
+**Purpose**: Run wall construction simulation with multi-profile configuration
 
-**Data Source**: `POST /api/profiles/{id}/progress/`
+**Data Source**: `POST /api/simulation/simulate/`
 
 **Components**:
-- Profile selector dropdown
-- Wall section selector
-- Date picker (default: today)
-- Feet built input (number)
-- Notes textarea (optional)
-- Real-time calculation display (ice usage, cost)
-- Submit button
+- Configuration textarea (multi-line input for wall heights)
+- Number of teams input (default: 10)
+- Run Simulation button
+- Example config link/tooltip
+- Results display area (summary statistics)
+- View Logs button (navigates to SimulationResults)
 
 **Key Features**:
-- Form validation (required fields, number validation)
-- Real-time calculations using constants (195 yd³/ft, 1,900 GD/yd³)
-- Success toast notification
-- Error handling with user-friendly messages
-- Clear form after submission
+- Config format validation (numbers only, range 0-30)
+- Example: "5, 10, 15" creates 3 profiles with heights 5, 10, 15
+- Real-time simulation execution
+- Summary display: total ice used, total cost, days to completion
+- Success/error notifications
+- Link to detailed logs and daily breakdown
 
-### 4. DailyIceUsage
+### 4. SimulationResults
+**File**: `src/pages/SimulationResults.jsx`
+
+**Purpose**: Display detailed simulation logs and daily progress
+
+**Data Source**: Read from `/logs/team_*.log` files or use `GET /api/simulation/overview/all-by-day/`
+
+**Components**:
+- Log viewer (scrollable text area with team logs)
+- Day-by-day summary table
+- Team status indicators (working/relieved)
+- Simulation summary statistics
+
+**Key Features**:
+- Syntax-highlighted log display
+- Filter logs by team number
+- Download logs button
+- Refresh simulation button
+
+### 5. DailyIceUsage
 **File**: `src/pages/DailyIceUsage.jsx`
 
 **Purpose**: Breakdown of ice usage by wall section for a specific date
@@ -434,12 +454,12 @@ export default function BarChart({ data, dataKey, xKey, color = '#10b981' }) {
 - Sortable table columns
 - Export to CSV
 
-### 5. CostAnalytics
+### 6. CostAnalytics
 **File**: `src/pages/CostAnalytics.jsx`
 
 **Purpose**: Multi-chart cost analytics dashboard
 
-**Data Source**: `GET /api/profiles/{id}/cost-overview/?start_date=X&end_date=Y`
+**Data Source**: `GET /api/simulation/overview/all-by-day/`
 
 **Components**:
 - Date range selector
@@ -507,7 +527,7 @@ async function request(endpoint, options = {}) {
 }
 
 export const api = {
-  // Profiles
+  // Profiles (CRUD endpoints for manual management)
   getProfiles: () => request('/profiles/'),
   getProfile: (id) => request(`/profiles/${id}/`),
   createProfile: (data) => request('/profiles/', {
@@ -515,18 +535,16 @@ export const api = {
     body: JSON.stringify(data)
   }),
 
-  // Progress
-  recordProgress: (profileId, data) => request(`/profiles/${profileId}/progress/`, {
+  // Simulation
+  runSimulation: (config, numTeams = 10) => request('/simulation/simulate/', {
     method: 'POST',
-    body: JSON.stringify(data)
+    body: JSON.stringify({ config, num_teams: numTeams })
   }),
 
   // Analytics
-  getDailyIceUsage: (profileId, date) =>
-    request(`/profiles/${profileId}/daily-ice-usage/?date=${date}`),
-
-  getCostOverview: (profileId, startDate, endDate) =>
-    request(`/profiles/${profileId}/cost-overview/?start_date=${startDate}&end_date=${endDate}`)
+  getOverviewTotal: () => request('/simulation/overview/total/'),
+  getOverviewByDay: (day) => request(`/simulation/overview/${day}/`),
+  getOverviewAllByDay: () => request('/simulation/overview/all-by-day/')
 }
 ```
 
@@ -649,7 +667,8 @@ Only add React Context if:
 import { useState, useEffect } from 'react'
 import Dashboard from './pages/Dashboard'
 import ProfileDetail from './pages/ProfileDetail'
-import ProgressForm from './pages/ProgressForm'
+import SimulationForm from './pages/SimulationForm'
+import SimulationResults from './pages/SimulationResults'
 
 function App() {
   const [route, setRoute] = useState(window.location.hash.slice(1) || 'dashboard')
@@ -688,9 +707,13 @@ function App() {
               className={route === 'dashboard' ? 'font-bold' : ''}>
               Dashboard
             </button>
-            <button onClick={() => navigate('progress')}
-              className={route === 'progress' ? 'font-bold' : ''}>
-              Record Progress
+            <button onClick={() => navigate('simulation')}
+              className={route === 'simulation' ? 'font-bold' : ''}>
+              Run Simulation
+            </button>
+            <button onClick={() => navigate('results')}
+              className={route === 'results' ? 'font-bold' : ''}>
+              View Results
             </button>
           </div>
         </div>
@@ -699,7 +722,8 @@ function App() {
       <main className="max-w-7xl mx-auto px-4">
         {route === 'dashboard' && <Dashboard navigate={navigate} />}
         {route === 'profile' && <ProfileDetail profileId={params.id} navigate={navigate} />}
-        {route === 'progress' && <ProgressForm navigate={navigate} />}
+        {route === 'simulation' && <SimulationForm navigate={navigate} />}
+        {route === 'results' && <SimulationResults navigate={navigate} />}
       </main>
     </div>
   )
@@ -712,8 +736,8 @@ export default App
 ```
 /#dashboard
 /#profile?id=1
-/#profile?id=1&start=2025-10-01&end=2025-10-20
-/#progress
+/#simulation
+/#results
 /#ice-usage?id=1&date=2025-10-15
 ```
 

SPEC-DEMO-TDD.md

@@ -1,1399 +0,0 @@
-# Wall Construction API - Test-Driven Development Specification
-
-## Philosophy: Test-First Development
-
-This specification defines a comprehensive test-driven development (TDD) strategy for the Wall Construction API. Every feature begins with tests, follows the Red-Green-Refactor cycle, and maintains high code coverage without sacrificing code quality.
-
-**Core Principle**: Write the test first, watch it fail, make it pass, then refactor. No production code without a failing test.
-
----
-
-## TDD Cycle
-
-### The Red-Green-Refactor Loop
-
-```
-1. 🔴 RED:    Write a failing test
-              ↓
-2. 🟢 GREEN:  Write minimal code to pass
-              ↓
-3. 🔵 REFACTOR: Improve code quality
-              ↓
-              (repeat)
-```
-
-### Workflow Example
-
-```python
-# Step 1: RED - Write failing test
-def test_ice_usage_calculation():
-    calculator = IceUsageCalculator()
-    result = calculator.calculate_ice_usage(Decimal("10.0"))
-    assert result == Decimal("1950.00")  # 10 feet * 195 yd³/ft
-
-# Run test → FAIL (IceUsageCalculator doesn't exist)
-
-# Step 2: GREEN - Minimal implementation
-class IceUsageCalculator:
-    ICE_PER_FOOT = Decimal("195")
-
-    def calculate_ice_usage(self, feet_built):
-        return feet_built * self.ICE_PER_FOOT
-
-# Run test → PASS
-
-# Step 3: REFACTOR - Improve (if needed)
-# Add type hints, docstrings, extract constants
-```
-
----
-
-## Test Pyramid
-
-```
-         ╱╲
-        ╱  ╲
-       ╱ E2E ╲        ← Few: Full user flows (10%)
-      ╱────────╲
-     ╱          ╲
-    ╱ Integration╲    ← Some: API endpoints (30%)
-   ╱──────────────╲
-  ╱                ╲
- ╱  Unit Tests      ╲  ← Many: Models, services, utils (60%)
-╱────────────────────╲
-```
-
-### Test Distribution
-
-- **Unit Tests (60%)**: Fast, isolated, test single functions/methods
-- **Integration Tests (30%)**: Test component interactions (API + DB)
-- **E2E Tests (10%)**: Full workflows from HTTP request to response
-
----
-
-## Test Stack
-
-### Dependencies
-
-**Required**:
-```toml
-[project.optional-dependencies]
-test = [
-  "pytest==8.4.2",
-  "pytest-django==4.9.0",
-  "pytest-xdist==3.6.1",       # Parallel test execution
-  "factory-boy==3.3.1",
-  "Faker==33.3.0",
-]
-```
-
-**Optional (Coverage)**:
-```toml
-coverage = [
-  "pytest-cov==6.0.0",
-  "coverage[toml]==7.6.0",
-]
-```
-
-### Why These Tools?
-
-- **pytest**: Modern test runner, better fixtures than unittest
-- **pytest-django**: Django integration (@pytest.mark.django_db)
-- **factory-boy**: Test data factories (replaces fixtures.json)
-- **Faker**: Realistic fake data (names, dates, text)
-- **pytest-xdist**: Run tests in parallel (faster CI)
-- **pytest-cov**: Code coverage reporting
-
----
-
-## Project Structure
-
-```
-wall-construction-api/
-├── apps/
-│   ├── profiles/
-│   │   ├── models.py
-│   │   ├── serializers.py
-│   │   ├── views.py
-│   │   ├── services.py
-│   │   └── repositories.py
-│   └── progress/
-│       ├── models.py
-│       ├── serializers.py
-│       └── views.py
-├── tests/
-│   ├── conftest.py              # Shared fixtures
-│   ├── factories.py             # Model factories
-│   ├── unit/
-│   │   ├── __init__.py
-│   │   ├── test_models.py       # Model tests
-│   │   ├── test_services.py     # Service layer tests
-│   │   ├── test_repositories.py # Repository tests
-│   │   └── test_utils.py        # Utility function tests
-│   ├── integration/
-│   │   ├── __init__.py
-│   │   ├── test_api_profiles.py
-│   │   ├── test_api_progress.py
-│   │   └── test_api_analytics.py
-│   └── e2e/
-│       ├── __init__.py
-│       └── test_workflows.py    # Full user workflows
-├── pytest.ini
-└── pyproject.toml
-```
-
----
-
-## Configuration
-
-### pytest.ini
-
-```ini
-[pytest]
-DJANGO_SETTINGS_MODULE = config.settings.test
-python_files = test_*.py
-python_classes = Test*
-python_functions = test_*
-
-# Enable django-db access
-addopts =
-    --strict-markers
-    --tb=short
-    --reuse-db
-    --nomigrations
-    -v
-
-# Coverage settings
-    --cov=apps
-    --cov-report=term-missing:skip-covered
-    --cov-report=html
-    --cov-fail-under=90
-
-markers =
-    unit: Unit tests (fast, isolated)
-    integration: Integration tests (API + DB)
-    e2e: End-to-end tests (full workflows)
-    slow: Slow tests (run separately)
-
-# Parallel execution
-    -n auto
-
-# Django settings
-testpaths = tests
-```
-
-### pyproject.toml (test settings)
-
-```toml
-[tool.coverage.run]
-omit = [
-    "*/migrations/*",
-    "*/tests/*",
-    "*/admin.py",
-    "*/apps.py",
-    "manage.py",
-]
-
-[tool.coverage.report]
-exclude_lines = [
-    "pragma: no cover",
-    "def __repr__",
-    "raise AssertionError",
-    "raise NotImplementedError",
-    "if TYPE_CHECKING:",
-]
-```
-
----
-
-## Fixtures and Factories
-
-### conftest.py (Shared Fixtures)
-
-```python
-# tests/conftest.py
-import pytest
-from rest_framework.test import APIClient
-from decimal import Decimal
-
-# ============================================================================
-# API Client Fixtures
-# ============================================================================
-
-@pytest.fixture
-def api_client():
-    """Unauthenticated API client."""
-    return APIClient()
-
-
-@pytest.fixture
-def authenticated_client(api_client, profile_factory):
-    """Authenticated API client (if auth is added later)."""
-    # For now, no auth required
-    return api_client
-
-
-# ============================================================================
-# Constants Fixtures
-# ============================================================================
-
-@pytest.fixture
-def ice_per_foot():
-    """Ice consumption constant: 195 cubic yards per foot."""
-    return Decimal("195")
-
-
-@pytest.fixture
-def cost_per_yard():
-    """Ice cost constant: 1,900 Gold Dragons per cubic yard."""
-    return Decimal("1900")
-
-
-# ============================================================================
-# Date Fixtures
-# ============================================================================
-
-@pytest.fixture
-def today():
-    """Today's date."""
-    from datetime.date import today
-    return today()
-
-
-@pytest.fixture
-def date_range():
-    """Sample date range for testing."""
-    from datetime import date
-    return {
-        "start": date(2025, 10, 1),
-        "end": date(2025, 10, 15)
-    }
-```
-
-### factories.py (Model Factories)
-
-```python
-# tests/factories.py
-import factory
-from factory.django import DjangoModelFactory
-from faker import Faker
-from decimal import Decimal
-from datetime import date
-
-from apps.profiles.models import Profile, WallSection, DailyProgress
-
-fake = Faker()
-
-# ============================================================================
-# Profile Factory
-# ============================================================================
-
-class ProfileFactory(DjangoModelFactory):
-    """Factory for creating Profile instances."""
-
-    class Meta:
-        model = Profile
-        django_get_or_create = ("name",)  # Avoid unique constraint errors
-
-    name = factory.Sequence(lambda n: f"Profile {n}")
-    team_lead = factory.Faker("name")
-    is_active = True
-
-
-# ============================================================================
-# WallSection Factory
-# ============================================================================
-
-class WallSectionFactory(DjangoModelFactory):
-    """Factory for creating WallSection instances."""
-
-    class Meta:
-        model = WallSection
-        django_get_or_create = ("profile", "section_name")
-
-    profile = factory.SubFactory(ProfileFactory)
-    section_name = factory.Sequence(lambda n: f"Section {n}")
-    start_position = factory.Faker(
-        "pydecimal",
-        left_digits=4,
-        right_digits=2,
-        positive=True
-    )
-    target_length_feet = factory.Faker(
-        "pydecimal",
-        left_digits=4,
-        right_digits=2,
-        positive=True,
-        min_value=100,
-        max_value=1000
-    )
-
-
-# ============================================================================
-# DailyProgress Factory
-# ============================================================================
-
-class DailyProgressFactory(DjangoModelFactory):
-    """Factory for creating DailyProgress instances."""
-
-    class Meta:
-        model = DailyProgress
-        django_get_or_create = ("wall_section", "date")
-
-    wall_section = factory.SubFactory(WallSectionFactory)
-    date = factory.LazyFunction(date.today)
-    feet_built = factory.Faker(
-        "pydecimal",
-        left_digits=3,
-        right_digits=2,
-        positive=True,
-        min_value=1,
-        max_value=50
-    )
-
-    # Auto-calculate ice and cost based on feet_built
-    ice_cubic_yards = factory.LazyAttribute(
-        lambda obj: obj.feet_built * Decimal("195")
-    )
-    cost_gold_dragons = factory.LazyAttribute(
-        lambda obj: obj.ice_cubic_yards * Decimal("1900")
-    )
-
-    notes = factory.Faker("sentence")
-
-
-# ============================================================================
-# Factory Traits (Variants)
-# ============================================================================
-
-class ProfileFactory_Inactive(ProfileFactory):
-    """Inactive profile variant."""
-    is_active = False
-
-
-class DailyProgressFactory_ZeroProgress(DailyProgressFactory):
-    """Zero progress variant (edge case)."""
-    feet_built = Decimal("0.00")
-    ice_cubic_yards = Decimal("0.00")
-    cost_gold_dragons = Decimal("0.00")
-    notes = "No work done today"
-```
-
----
-
-## Unit Tests
-
-### Test Models
-
-```python
-# tests/unit/test_models.py
-import pytest
-from decimal import Decimal
-from datetime import date
-
-from apps.profiles.models import Profile, WallSection, DailyProgress
-from tests.factories import (
-    ProfileFactory,
-    WallSectionFactory,
-    DailyProgressFactory
-)
-
-# ============================================================================
-# Profile Model Tests
-# ============================================================================
-
-@pytest.mark.unit
-@pytest.mark.django_db
-class TestProfileModel:
-    """Test Profile model validation and behavior."""
-
-    def test_create_profile_with_valid_data(self):
-        """Should create profile with valid data."""
-        profile = ProfileFactory(
-            name="Northern Watch",
-            team_lead="Jon Snow"
-        )
-
-        assert profile.id is not None
-        assert profile.name == "Northern Watch"
-        assert profile.team_lead == "Jon Snow"
-        assert profile.is_active is True
-
-    def test_profile_name_must_be_unique(self):
-        """Should raise error when creating duplicate profile name."""
-        ProfileFactory(name="Northern Watch")
-
-        with pytest.raises(Exception):  # IntegrityError
-            ProfileFactory(name="Northern Watch")
-
-    def test_profile_ordering_by_created_at_desc(self):
-        """Should order profiles by created_at descending."""
-        profile1 = ProfileFactory(name="First")
-        profile2 = ProfileFactory(name="Second")
-        profile3 = ProfileFactory(name="Third")
-
-        profiles = Profile.objects.all()
-        assert profiles[0] == profile3  # Most recent first
-        assert profiles[1] == profile2
-        assert profiles[2] == profile1
-
-    def test_profile_string_representation(self):
-        """Should return profile name as string."""
-        profile = ProfileFactory(name="Northern Watch")
-        assert str(profile) == "Northern Watch"
-
-
-# ============================================================================
-# WallSection Model Tests
-# ============================================================================
-
-@pytest.mark.unit
-@pytest.mark.django_db
-class TestWallSectionModel:
-    """Test WallSection model validation and behavior."""
-
-    def test_create_wall_section_with_valid_data(self):
-        """Should create wall section with valid data."""
-        profile = ProfileFactory()
-        section = WallSectionFactory(
-            profile=profile,
-            section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00")
-        )
-
-        assert section.id is not None
-        assert section.profile == profile
-        assert section.section_name == "Tower 1-2"
-
-    def test_unique_together_profile_section_name(self):
-        """Should enforce unique constraint on (profile, section_name)."""
-        profile = ProfileFactory()
-        WallSectionFactory(profile=profile, section_name="Tower 1-2")
-
-        with pytest.raises(Exception):  # IntegrityError
-            WallSectionFactory(profile=profile, section_name="Tower 1-2")
-
-    def test_different_profiles_can_have_same_section_name(self):
-        """Different profiles can use the same section name."""
-        profile1 = ProfileFactory(name="Profile 1")
-        profile2 = ProfileFactory(name="Profile 2")
-
-        section1 = WallSectionFactory(profile=profile1, section_name="Tower 1")
-        section2 = WallSectionFactory(profile=profile2, section_name="Tower 1")
-
-        assert section1.section_name == section2.section_name
-        assert section1.profile != section2.profile
-
-    def test_cascade_delete_when_profile_deleted(self):
-        """Should delete wall sections when profile is deleted."""
-        profile = ProfileFactory()
-        section = WallSectionFactory(profile=profile)
-        section_id = section.id
-
-        profile.delete()
-
-        assert not WallSection.objects.filter(id=section_id).exists()
-
-
-# ============================================================================
-# DailyProgress Model Tests
-# ============================================================================
-
-@pytest.mark.unit
-@pytest.mark.django_db
-class TestDailyProgressModel:
-    """Test DailyProgress model validation and calculations."""
-
-    def test_create_daily_progress_with_valid_data(self):
-        """Should create daily progress with valid data."""
-        section = WallSectionFactory()
-        progress = DailyProgressFactory(
-            wall_section=section,
-            date=date(2025, 10, 15),
-            feet_built=Decimal("12.50"),
-            ice_cubic_yards=Decimal("2437.50"),
-            cost_gold_dragons=Decimal("4631250.00")
-        )
-
-        assert progress.id is not None
-        assert progress.feet_built == Decimal("12.50")
-        assert progress.ice_cubic_yards == Decimal("2437.50")
-        assert progress.cost_gold_dragons == Decimal("4631250.00")
-
-    def test_unique_together_wall_section_date(self):
-        """Should enforce unique constraint on (wall_section, date)."""
-        section = WallSectionFactory()
-        today = date.today()
-
-        DailyProgressFactory(wall_section=section, date=today)
-
-        with pytest.raises(Exception):  # IntegrityError
-            DailyProgressFactory(wall_section=section, date=today)
-
-    def test_ordering_by_date_descending(self):
-        """Should order progress by date descending."""
-        section = WallSectionFactory()
-        progress1 = DailyProgressFactory(
-            wall_section=section,
-            date=date(2025, 10, 1)
-        )
-        progress2 = DailyProgressFactory(
-            wall_section=section,
-            date=date(2025, 10, 15)
-        )
-
-        progress_list = DailyProgress.objects.filter(wall_section=section)
-        assert progress_list[0] == progress2  # Most recent first
-        assert progress_list[1] == progress1
-
-    @pytest.mark.parametrize("feet,expected_ice", [
-        (Decimal("10.00"), Decimal("1950.00")),
-        (Decimal("0.00"), Decimal("0.00")),
-        (Decimal("1.00"), Decimal("195.00")),
-        (Decimal("100.50"), Decimal("19597.50")),
-    ])
-    def test_ice_calculation_formula(self, feet, expected_ice):
-        """Should correctly calculate ice usage (195 yd³ per foot)."""
-        calculated_ice = feet * Decimal("195")
-        assert calculated_ice == expected_ice
-
-    @pytest.mark.parametrize("ice,expected_cost", [
-        (Decimal("195.00"), Decimal("370500.00")),
-        (Decimal("0.00"), Decimal("0.00")),
-        (Decimal("1950.00"), Decimal("3705000.00")),
-    ])
-    def test_cost_calculation_formula(self, ice, expected_cost):
-        """Should correctly calculate cost (1900 GD per yd³)."""
-        calculated_cost = ice * Decimal("1900")
-        assert calculated_cost == expected_cost
-```
-
-### Test Services
-
-```python
-# tests/unit/test_services.py
-import pytest
-from decimal import Decimal
-from datetime import date
-
-from apps.profiles.services import IceUsageCalculator, CostAggregator
-from tests.factories import ProfileFactory, WallSectionFactory, DailyProgressFactory
-
-# ============================================================================
-# IceUsageCalculator Tests
-# ============================================================================
-
-@pytest.mark.unit
-class TestIceUsageCalculator:
-    """Test IceUsageCalculator service."""
-
-    @pytest.fixture
-    def calculator(self):
-        return IceUsageCalculator()
-
-    def test_calculate_ice_usage_standard_value(self, calculator):
-        """Should calculate ice usage for standard value."""
-        result = calculator.calculate_ice_usage(Decimal("10.0"))
-        expected = Decimal("1950.00")
-        assert result == expected
-
-    def test_calculate_ice_usage_zero_feet(self, calculator):
-        """Should return zero for zero feet built."""
-        result = calculator.calculate_ice_usage(Decimal("0.00"))
-        assert result == Decimal("0.00")
-
-    def test_calculate_ice_usage_decimal_precision(self, calculator):
-        """Should handle decimal precision correctly."""
-        result = calculator.calculate_ice_usage(Decimal("12.50"))
-        expected = Decimal("2437.50")
-        assert result == expected
-
-    def test_calculate_cost_standard_value(self, calculator):
-        """Should calculate cost for standard ice amount."""
-        ice = Decimal("1950.00")
-        result = calculator.calculate_cost(ice)
-        expected = Decimal("3705000.00")
-        assert result == expected
-
-    def test_calculate_cost_zero_ice(self, calculator):
-        """Should return zero cost for zero ice."""
-        result = calculator.calculate_cost(Decimal("0.00"))
-        assert result == Decimal("0.00")
-
-    def test_calculate_full_cost_returns_tuple(self, calculator):
-        """Should return (ice, cost) tuple."""
-        ice, cost = calculator.calculate_full_cost(Decimal("10.00"))
-        assert ice == Decimal("1950.00")
-        assert cost == Decimal("3705000.00")
-
-    def test_constants_are_correct(self, calculator):
-        """Should have correct constant values."""
-        assert calculator.ICE_PER_FOOT == Decimal("195")
-        assert calculator.COST_PER_CUBIC_YARD == Decimal("1900")
-
-
-# ============================================================================
-# CostAggregator Tests
-# ============================================================================
-
-@pytest.mark.unit
-@pytest.mark.django_db
-class TestCostAggregator:
-    """Test CostAggregator service."""
-
-    @pytest.fixture
-    def aggregator(self):
-        return CostAggregator(max_workers=2)
-
-    def test_calculate_profile_cost_single_progress(self, aggregator):
-        """Should calculate cost for single progress entry."""
-        profile = ProfileFactory()
-        section = WallSectionFactory(profile=profile)
-        DailyProgressFactory(
-            wall_section=section,
-            date=date(2025, 10, 15),
-            feet_built=Decimal("10.00"),
-            ice_cubic_yards=Decimal("1950.00"),
-            cost_gold_dragons=Decimal("3705000.00")
-        )
-
-        result = aggregator.calculate_profile_cost(
-            profile.id,
-            "2025-10-15",
-            "2025-10-15"
-        )
-
-        assert result["total_feet_built"] == "10.00"
-        assert result["total_ice_cubic_yards"] == "1950.00"
-        assert result["total_cost_gold_dragons"] == "3705000.00"
-
-    def test_calculate_multi_profile_costs_parallel(self, aggregator):
-        """Should calculate costs for multiple profiles in parallel."""
-        profile1 = ProfileFactory(name="Profile 1")
-        profile2 = ProfileFactory(name="Profile 2")
-
-        section1 = WallSectionFactory(profile=profile1)
-        section2 = WallSectionFactory(profile=profile2)
-
-        DailyProgressFactory(wall_section=section1, feet_built=Decimal("10.00"))
-        DailyProgressFactory(wall_section=section2, feet_built=Decimal("20.00"))
-
-        results = aggregator.calculate_multi_profile_costs(
-            [profile1.id, profile2.id],
-            "2025-10-01",
-            "2025-10-31"
-        )
-
-        assert len(results) == 2
-        assert all("total_cost_gold_dragons" in r for r in results)
-
-    def test_shutdown_executor(self, aggregator):
-        """Should gracefully shutdown thread pool."""
-        aggregator.shutdown()
-        # No exception should be raised
-```
-
-### Test Repositories
-
-```python
-# tests/unit/test_repositories.py
-import pytest
-from decimal import Decimal
-from datetime import date
-
-from apps.profiles.repositories import DailyProgressRepository
-from tests.factories import ProfileFactory, WallSectionFactory, DailyProgressFactory
-
-@pytest.mark.unit
-@pytest.mark.django_db
-class TestDailyProgressRepository:
-    """Test DailyProgressRepository data access layer."""
-
-    @pytest.fixture
-    def repository(self):
-        return DailyProgressRepository()
-
-    def test_get_by_date_returns_progress_for_date(self, repository):
-        """Should return all progress for a specific date."""
-        profile = ProfileFactory()
-        section1 = WallSectionFactory(profile=profile, section_name="Section 1")
-        section2 = WallSectionFactory(profile=profile, section_name="Section 2")
-
-        target_date = date(2025, 10, 15)
-        other_date = date(2025, 10, 14)
-
-        progress1 = DailyProgressFactory(wall_section=section1, date=target_date)
-        progress2 = DailyProgressFactory(wall_section=section2, date=target_date)
-        DailyProgressFactory(wall_section=section1, date=other_date)  # Should not be returned
-
-        results = repository.get_by_date(profile.id, target_date)
-
-        assert results.count() == 2
-        assert progress1 in results
-        assert progress2 in results
-
-    def test_get_aggregates_by_profile_sums_correctly(self, repository):
-        """Should aggregate totals correctly."""
-        profile = ProfileFactory()
-        section = WallSectionFactory(profile=profile)
-
-        DailyProgressFactory(
-            wall_section=section,
-            date=date(2025, 10, 1),
-            feet_built=Decimal("10.00"),
-            ice_cubic_yards=Decimal("1950.00"),
-            cost_gold_dragons=Decimal("3705000.00")
-        )
-        DailyProgressFactory(
-            wall_section=section,
-            date=date(2025, 10, 2),
-            feet_built=Decimal("15.00"),
-            ice_cubic_yards=Decimal("2925.00"),
-            cost_gold_dragons=Decimal("5557500.00")
-        )
-
-        result = repository.get_aggregates_by_profile(
-            profile.id,
-            "2025-10-01",
-            "2025-10-02"
-        )
-
-        assert result["total_feet"] == Decimal("25.00")
-        assert result["total_ice"] == Decimal("4875.00")
-        assert result["total_cost"] == Decimal("9262500.00")
-        assert result["record_count"] == 2
-
-    def test_get_aggregates_empty_queryset_returns_zeros(self, repository):
-        """Should return zeros for empty queryset."""
-        profile = ProfileFactory()
-
-        result = repository.get_aggregates_by_profile(
-            profile.id,
-            "2025-10-01",
-            "2025-10-31"
-        )
-
-        assert result["total_feet"] == Decimal("0")
-        assert result["total_ice"] == Decimal("0")
-        assert result["total_cost"] == Decimal("0")
-        assert result["record_count"] == 0
-```
-
----
-
-## Integration Tests (API)
-
-### Test Profile API
-
-```python
-# tests/integration/test_api_profiles.py
-import pytest
-from rest_framework import status
-from django.urls import reverse
-
-from tests.factories import ProfileFactory
-
-@pytest.mark.integration
-@pytest.mark.django_db
-class TestProfileListAPI:
-    """Test GET /api/profiles/ endpoint."""
-
-    @pytest.fixture
-    def url(self):
-        return reverse("profile-list")
-
-    def test_list_profiles_returns_200(self, api_client, url):
-        """Should return 200 OK."""
-        response = api_client.get(url)
-        assert response.status_code == status.HTTP_200_OK
-
-    def test_list_profiles_returns_pagination(self, api_client, url):
-        """Should return paginated response."""
-        ProfileFactory.create_batch(5)
-
-        response = api_client.get(url)
-        data = response.json()
-
-        assert "count" in data
-        assert "results" in data
-        assert data["count"] == 5
-        assert len(data["results"]) == 5
-
-    def test_list_profiles_filters_by_active(self, api_client, url):
-        """Should filter by is_active parameter."""
-        ProfileFactory(name="Active", is_active=True)
-        ProfileFactory(name="Inactive", is_active=False)
-
-        response = api_client.get(url, {"is_active": "true"})
-        data = response.json()
-
-        assert data["count"] == 1
-        assert data["results"][0]["name"] == "Active"
-
-    def test_list_profiles_ordered_by_created_desc(self, api_client, url):
-        """Should order profiles by created_at descending."""
-        profile1 = ProfileFactory(name="First")
-        profile2 = ProfileFactory(name="Second")
-        profile3 = ProfileFactory(name="Third")
-
-        response = api_client.get(url)
-        data = response.json()
-
-        assert data["results"][0]["name"] == "Third"
-        assert data["results"][1]["name"] == "Second"
-        assert data["results"][2]["name"] == "First"
-
-
-@pytest.mark.integration
-@pytest.mark.django_db
-class TestProfileCreateAPI:
-    """Test POST /api/profiles/ endpoint."""
-
-    @pytest.fixture
-    def url(self):
-        return reverse("profile-list")
-
-    def test_create_profile_with_valid_data(self, api_client, url):
-        """Should create profile with valid data."""
-        payload = {
-            "name": "Northern Watch",
-            "team_lead": "Jon Snow",
-            "is_active": True
-        }
-
-        response = api_client.post(url, payload, format="json")
-
-        assert response.status_code == status.HTTP_201_CREATED
-        data = response.json()
-        assert data["name"] == "Northern Watch"
-        assert data["team_lead"] == "Jon Snow"
-        assert data["is_active"] is True
-        assert "id" in data
-
-    def test_create_profile_with_duplicate_name_fails(self, api_client, url):
-        """Should return 400 for duplicate name."""
-        ProfileFactory(name="Northern Watch")
-
-        payload = {
-            "name": "Northern Watch",
-            "team_lead": "Jon Snow"
-        }
-
-        response = api_client.post(url, payload, format="json")
-        assert response.status_code == status.HTTP_400_BAD_REQUEST
-
-    def test_create_profile_with_missing_name_fails(self, api_client, url):
-        """Should return 400 for missing required field."""
-        payload = {
-            "team_lead": "Jon Snow"
-        }
-
-        response = api_client.post(url, payload, format="json")
-        assert response.status_code == status.HTTP_400_BAD_REQUEST
-        assert "name" in response.json()
-```
-
-### Test Progress API
-
-```python
-# tests/integration/test_api_progress.py
-import pytest
-from decimal import Decimal
-from datetime import date
-from rest_framework import status
-from django.urls import reverse
-
-from tests.factories import ProfileFactory, WallSectionFactory, DailyProgressFactory
-
-@pytest.mark.integration
-@pytest.mark.django_db
-class TestRecordProgressAPI:
-    """Test POST /api/profiles/{id}/progress/ endpoint."""
-
-    def test_record_progress_with_valid_data(self, api_client):
-        """Should record progress and auto-calculate ice/cost."""
-        profile = ProfileFactory()
-        section = WallSectionFactory(profile=profile)
-
-        url = reverse("profile-progress", kwargs={"pk": profile.id})
-        payload = {
-            "wall_section_id": section.id,
-            "date": "2025-10-15",
-            "feet_built": "12.50",
-            "notes": "Good progress today"
-        }
-
-        response = api_client.post(url, payload, format="json")
-
-        assert response.status_code == status.HTTP_201_CREATED
-        data = response.json()
-        assert data["feet_built"] == "12.50"
-        assert data["ice_cubic_yards"] == "2437.50"  # 12.5 * 195
-        assert data["cost_gold_dragons"] == "4631250.00"  # 2437.5 * 1900
-
-    def test_record_progress_for_same_section_and_date_fails(self, api_client):
-        """Should return 400 for duplicate (section, date)."""
-        profile = ProfileFactory()
-        section = WallSectionFactory(profile=profile)
-        today = date.today()
-
-        DailyProgressFactory(wall_section=section, date=today)
-
-        url = reverse("profile-progress", kwargs={"pk": profile.id})
-        payload = {
-            "wall_section_id": section.id,
-            "date": str(today),
-            "feet_built": "10.00"
-        }
-
-        response = api_client.post(url, payload, format="json")
-        assert response.status_code == status.HTTP_400_BAD_REQUEST
-
-    def test_record_progress_with_zero_feet_allowed(self, api_client):
-        """Should allow zero feet built (no work day)."""
-        profile = ProfileFactory()
-        section = WallSectionFactory(profile=profile)
-
-        url = reverse("profile-progress", kwargs={"pk": profile.id})
-        payload = {
-            "wall_section_id": section.id,
-            "date": "2025-10-15",
-            "feet_built": "0.00",
-            "notes": "No work today"
-        }
-
-        response = api_client.post(url, payload, format="json")
-
-        assert response.status_code == status.HTTP_201_CREATED
-        data = response.json()
-        assert data["feet_built"] == "0.00"
-        assert data["ice_cubic_yards"] == "0.00"
-        assert data["cost_gold_dragons"] == "0.00"
-```
-
-### Test Analytics API
-
-```python
-# tests/integration/test_api_analytics.py
-import pytest
-from decimal import Decimal
-from datetime import date
-from rest_framework import status
-from django.urls import reverse
-
-from tests.factories import ProfileFactory, WallSectionFactory, DailyProgressFactory
-
-@pytest.mark.integration
-@pytest.mark.django_db
-class TestDailyIceUsageAPI:
-    """Test GET /api/profiles/{id}/daily-ice-usage/?date=YYYY-MM-DD"""
-
-    def test_daily_ice_usage_returns_breakdown(self, api_client):
-        """Should return daily ice usage breakdown by section."""
-        profile = ProfileFactory()
-        section1 = WallSectionFactory(profile=profile, section_name="Tower 1-2")
-        section2 = WallSectionFactory(profile=profile, section_name="Tower 2-3")
-
-        target_date = date(2025, 10, 15)
-        DailyProgressFactory(
-            wall_section=section1,
-            date=target_date,
-            feet_built=Decimal("12.50"),
-            ice_cubic_yards=Decimal("2437.50")
-        )
-        DailyProgressFactory(
-            wall_section=section2,
-            date=target_date,
-            feet_built=Decimal("16.25"),
-            ice_cubic_yards=Decimal("3168.75")
-        )
-
-        url = reverse("profile-daily-ice-usage", kwargs={"pk": profile.id})
-        response = api_client.get(url, {"date": "2025-10-15"})
-
-        assert response.status_code == status.HTTP_200_OK
-        data = response.json()
-        assert data["total_feet_built"] == "28.75"
-        assert data["total_ice_cubic_yards"] == "5606.25"
-        assert len(data["sections"]) == 2
-
-
-@pytest.mark.integration
-@pytest.mark.django_db
-class TestCostOverviewAPI:
-    """Test GET /api/profiles/{id}/cost-overview/?start_date&end_date"""
-
-    def test_cost_overview_returns_summary_and_breakdown(self, api_client):
-        """Should return summary stats and daily breakdown."""
-        profile = ProfileFactory()
-        section = WallSectionFactory(profile=profile)
-
-        DailyProgressFactory(
-            wall_section=section,
-            date=date(2025, 10, 1),
-            feet_built=Decimal("10.00"),
-            ice_cubic_yards=Decimal("1950.00"),
-            cost_gold_dragons=Decimal("3705000.00")
-        )
-        DailyProgressFactory(
-            wall_section=section,
-            date=date(2025, 10, 2),
-            feet_built=Decimal("15.00"),
-            ice_cubic_yards=Decimal("2925.00"),
-            cost_gold_dragons=Decimal("5557500.00")
-        )
-
-        url = reverse("profile-cost-overview", kwargs={"pk": profile.id})
-        response = api_client.get(url, {
-            "start_date": "2025-10-01",
-            "end_date": "2025-10-02"
-        })
-
-        assert response.status_code == status.HTTP_200_OK
-        data = response.json()
-
-        assert data["summary"]["total_feet_built"] == "25.00"
-        assert data["summary"]["total_ice_cubic_yards"] == "4875.00"
-        assert data["summary"]["total_cost_gold_dragons"] == "9262500.00"
-        assert len(data["daily_breakdown"]) == 2
-
-    def test_cost_overview_requires_date_parameters(self, api_client):
-        """Should return 400 if date parameters missing."""
-        profile = ProfileFactory()
-        url = reverse("profile-cost-overview", kwargs={"pk": profile.id})
-
-        response = api_client.get(url)
-        assert response.status_code == status.HTTP_400_BAD_REQUEST
-```
-
----
-
-## End-to-End Tests
-
-```python
-# tests/e2e/test_workflows.py
-import pytest
-from decimal import Decimal
-from datetime import date
-from rest_framework import status
-from django.urls import reverse
-
-@pytest.mark.e2e
-@pytest.mark.django_db
-class TestFullConstructionWorkflow:
-    """Test complete user workflow from profile creation to analytics."""
-
-    def test_complete_workflow(self, api_client):
-        """
-        Complete workflow:
-        1. Create profile
-        2. Create wall section
-        3. Record daily progress (3 days)
-        4. Query cost overview
-        5. Query daily ice usage
-        """
-
-        # Step 1: Create profile
-        profile_url = reverse("profile-list")
-        profile_payload = {
-            "name": "Northern Watch",
-            "team_lead": "Jon Snow",
-            "is_active": True
-        }
-        response = api_client.post(profile_url, profile_payload, format="json")
-        assert response.status_code == status.HTTP_201_CREATED
-        profile_id = response.json()["id"]
-
-        # Step 2: Create wall section (assume endpoint exists)
-        section_payload = {
-            "section_name": "Tower 1-2",
-            "start_position": "0.00",
-            "target_length_feet": "500.00"
-        }
-        # ... create section via API
-
-        # Step 3: Record progress for 3 days
-        progress_url = reverse("profile-progress", kwargs={"pk": profile_id})
-
-        for day in [1, 2, 3]:
-            payload = {
-                "wall_section_id": 1,  # Assuming ID 1
-                "date": f"2025-10-{day:02d}",
-                "feet_built": str(Decimal("10.00") + Decimal(day)),
-                "notes": f"Day {day} progress"
-            }
-            response = api_client.post(progress_url, payload, format="json")
-            assert response.status_code == status.HTTP_201_CREATED
-
-        # Step 4: Query cost overview
-        overview_url = reverse("profile-cost-overview", kwargs={"pk": profile_id})
-        response = api_client.get(overview_url, {
-            "start_date": "2025-10-01",
-            "end_date": "2025-10-03"
-        })
-
-        assert response.status_code == status.HTTP_200_OK
-        data = response.json()
-        assert data["summary"]["total_days"] == 3
-        assert Decimal(data["summary"]["total_feet_built"]) > Decimal("30.00")
-
-        # Step 5: Query daily ice usage
-        ice_url = reverse("profile-daily-ice-usage", kwargs={"pk": profile_id})
-        response = api_client.get(ice_url, {"date": "2025-10-02"})
-
-        assert response.status_code == status.HTTP_200_OK
-        assert "total_ice_cubic_yards" in response.json()
-```
-
----
-
-## Running Tests
-
-### Basic Commands
-
-```bash
-# Run all tests
-pytest
-
-# Run specific test file
-pytest tests/unit/test_models.py
-
-# Run specific test class
-pytest tests/unit/test_models.py::TestProfileModel
-
-# Run specific test function
-pytest tests/unit/test_models.py::TestProfileModel::test_create_profile_with_valid_data
-
-# Run tests by marker
-pytest -m unit        # Only unit tests
-pytest -m integration # Only integration tests
-pytest -m "not slow"  # Skip slow tests
-
-# Run with coverage
-pytest --cov=apps --cov-report=html
-
-# Run in parallel (faster)
-pytest -n auto
-
-# Run with verbose output
-pytest -v
-
-# Stop on first failure
-pytest -x
-
-# Re-run only failed tests
-pytest --lf
-```
-
-### CI/CD Pipeline
-
-```yaml
-# .github/workflows/tests.yml
-name: Tests
-
-on: [push, pull_request]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Set up Python
-        uses: actions/setup-python@v4
-        with:
-          python-version: '3.12'
-
-      - name: Install dependencies
-        run: |
-          pip install -r requirements.txt
-          pip install -r requirements-test.txt
-
-      - name: Run tests
-        run: |
-          pytest --cov=apps --cov-report=xml -n auto
-
-      - name: Upload coverage
-        uses: codecov/codecov-action@v3
-        with:
-          file: ./coverage.xml
-```
-
----
-
-## Best Practices
-
-### Arrange-Act-Assert Pattern
-
-```python
-def test_calculate_ice_usage():
-    # Arrange: Set up test data
-    calculator = IceUsageCalculator()
-    feet_built = Decimal("10.00")
-
-    # Act: Execute the code under test
-    result = calculator.calculate_ice_usage(feet_built)
-
-    # Assert: Verify the result
-    expected = Decimal("1950.00")
-    assert result == expected
-```
-
-### Descriptive Test Names
-
-```python
-# Good
-def test_create_profile_with_duplicate_name_returns_400():
-    ...
-
-# Bad
-def test_profile_creation():
-    ...
-```
-
-### One Assertion Per Test (Generally)
-
-```python
-# Good - focused test
-def test_profile_has_name():
-    profile = ProfileFactory(name="Test")
-    assert profile.name == "Test"
-
-def test_profile_has_team_lead():
-    profile = ProfileFactory(team_lead="Jon")
-    assert profile.team_lead == "Jon"
-
-# Acceptable - related assertions
-def test_create_profile_returns_complete_data():
-    profile = ProfileFactory(name="Test", team_lead="Jon")
-    assert profile.name == "Test"
-    assert profile.team_lead == "Jon"
-    assert profile.is_active is True
-```
-
-### Test Isolation
-
-```python
-# Each test should be independent
-@pytest.mark.django_db
-def test_one():
-    profile = ProfileFactory()
-    assert profile.is_active
-
-@pytest.mark.django_db
-def test_two():
-    # Database is reset between tests
-    assert Profile.objects.count() == 0  # Fresh DB
-```
-
-### Use Fixtures for Reusable Setup
-
-```python
-@pytest.fixture
-def profile_with_sections():
-    """Profile with 3 wall sections."""
-    profile = ProfileFactory()
-    sections = WallSectionFactory.create_batch(3, profile=profile)
-    return profile, sections
-
-def test_profile_has_sections(profile_with_sections):
-    profile, sections = profile_with_sections
-    assert profile.wall_sections.count() == 3
-```
-
----
-
-## Coverage Requirements
-
-### Minimum Coverage: 90%
-
-```bash
-# Check coverage
-pytest --cov=apps --cov-report=term-missing
-
-# Fail if below threshold
-pytest --cov=apps --cov-fail-under=90
-```
-
-### What to Test
-
-✅ **Test**:
-- Business logic (calculations, validations)
-- API endpoints (status codes, response data)
-- Model methods and properties
-- Service layer functions
-- Repository queries
-
-❌ **Don't Test**:
-- Django's built-in functionality
-- Third-party libraries
-- Simple getters/setters
-- Auto-generated admin code
-
----
-
-## TDD Workflow Example
-
-### Feature: Add Profile Deactivation
-
-**Step 1: Write Failing Test**
-```python
-def test_deactivate_profile_sets_is_active_false():
-    profile = ProfileFactory(is_active=True)
-    profile.deactivate()
-    assert profile.is_active is False
-```
-
-**Run**: `pytest tests/unit/test_models.py::test_deactivate_profile_sets_is_active_false`
-**Result**: ❌ FAIL (AttributeError: 'Profile' object has no attribute 'deactivate')
-
-**Step 2: Minimal Implementation**
-```python
-class Profile(models.Model):
-    # ... existing fields
-
-    def deactivate(self):
-        self.is_active = False
-        self.save()
-```
-
-**Run**: `pytest tests/unit/test_models.py::test_deactivate_profile_sets_is_active_false`
-**Result**: ✅ PASS
-
-**Step 3: Refactor (if needed)**
-```python
-# Add additional test for edge case
-def test_deactivate_already_inactive_profile_is_idempotent():
-    profile = ProfileFactory(is_active=False)
-    profile.deactivate()
-    assert profile.is_active is False  # No error
-```
-
-**Step 4: Add API Test**
-```python
-def test_deactivate_profile_via_api(api_client):
-    profile = ProfileFactory(is_active=True)
-    url = reverse("profile-deactivate", kwargs={"pk": profile.id})
-    response = api_client.post(url)
-
-    assert response.status_code == status.HTTP_200_OK
-    profile.refresh_from_db()
-    assert profile.is_active is False
-```
-
----
-
-## Summary
-
-This TDD specification provides:
-
-✅ **Complete test stack**: pytest + factory_boy + Faker
-✅ **Test structure**: Unit, integration, E2E tests
-✅ **Code examples**: Models, services, repositories, API
-✅ **Best practices**: AAA pattern, descriptive names, isolation
-✅ **CI/CD ready**: Parallel execution, coverage reporting
-✅ **TDD workflow**: Red-Green-Refactor cycle
-
-**Philosophy**: Every line of production code has a test that drove its creation.

SPEC-DEMO.md

@@ -2,45 +2,49 @@
 
 ## Problem Overview
 
-The Great Wall of Westeros requires a tracking system for multi-profile wall construction operations. Each construction profile must track daily progress, ice material consumption, and associated costs.
+The Great Wall of Westeros requires a simulation system for multi-profile wall construction operations. The system must parse configuration files specifying wall sections with varying heights, simulate concurrent team construction, and track daily progress with ice consumption and cost metrics.
 
 ### Business Rules
 
 - **Ice Consumption**: 195 cubic yards per linear foot of wall
 - **Ice Cost**: 1,900 Gold Dragons per cubic yard
 - **Daily Cost Formula**: `feet_built × 195 yd³/ft × 1,900 GD/yd³ = daily_cost`
+- **Target Height**: All sections must reach 30 feet
+- **Daily Build Rate**: 1 foot per team per day
+- **Team Assignment**: Round-robin across active sections
 
 ### Requirements
 
-1. Track multiple construction profiles simultaneously
-2. Record daily wall construction progress (feet built per day)
-3. Calculate daily ice usage for each profile
-4. Provide cost overview reports with date range filtering
-5. Support multi-threaded computation for aggregations
+1. Parse multi-profile configuration (heights per section per profile)
+2. Simulate concurrent wall construction with configurable team count
+3. Track daily progress with automatic ice/cost calculations
+4. Generate team activity logs to file system
+5. Provide simulation overview endpoints
 6. Run in HuggingFace Docker Space (file-based, no external services)
 
 ## Technology Stack
 
 ### Core Framework
-- **Django 5.2.7 LTS** (released April 2, 2025)
-  - Python 3.10-3.14 support
+- **Django 5.2.7** (Python 3.12.3)
   - SQLite database (file-based persistence)
   - Built-in ORM with transaction support
+  - Migration system
 
-- **Django REST Framework 3.16** (released March 28, 2025)
-  - ViewSets for CRUD operations
+- **Django REST Framework 3.16**
+  - ViewSets for CRUD and custom actions
   - Serializers for data validation
-  - Pagination and filtering support
+  - Pagination support
 
 ### Multi-Threading
 - **Python concurrent.futures.ThreadPoolExecutor**
-  - No external broker dependencies (Celery-free)
-  - Configurable worker pool size
-  - Suitable for CPU-bound aggregations
+  - Parallel wall section processing during simulation
+  - No external broker dependencies
+  - Configurable worker pool (default: 10 workers)
 
 ### Deployment
 - **HuggingFace Docker Space Compatible**
   - SQLite database file (`db.sqlite3`)
+  - File-based team logs (`logs/team_*.log`)
   - No PostgreSQL, Redis, or RabbitMQ required
   - Single container deployment
 
@@ -50,75 +54,49 @@ The Great Wall of Westeros requires a tracking system for multi-profile wall con
 ┌─────────────────────────────────────────────────────────────┐
 │                     REST API Layer (DRF)                    │
 │  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐     │
-│  │  Profile     │  │  Progress    │  │  Analytics   │     │
-│  │  ViewSet     │  │  ViewSet     │  │  ViewSet     │     │
-│  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘     │
-└─────────┼──────────────────┼──────────────────┼─────────────┘
-          │                  │                  │
-          ▼                  ▼                  ▼
+│  │  Profile     │  │  WallSection │  │  Daily       │     │
+│  │  ViewSet     │  │  ViewSet     │  │  Progress    │     │
+│  │  + simulate  │  │  (CRUD)      │  │  ViewSet     │     │
+│  │  + overview  │  │              │  │  (CRUD)      │     │
+│  └──────┬───────┘  └──────────────┘  └──────────────┘     │
+└─────────┼──────────────────────────────────────────────────┘
+          │
+          ▼
 ┌─────────────────────────────────────────────────────────────┐
-│                      Service Layer                          │
-│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐     │
-│  │  Profile     │  │  Ice Usage   │  │  Cost        │     │
-│  │  Service     │  │  Calculator  │  │  Aggregator  │     │
-│  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘     │
-└─────────┼──────────────────┼──────────────────┼─────────────┘
-          │                  │                  │
-          ▼                  ▼                  ▼
-┌─────────────────────────────────────────────────────────────┐
-│                    Repository Layer                         │
-│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐     │
-│  │  Profile     │  │  Wall        │  │  Daily       │     │
-│  │  Repository  │  │  Section     │  │  Progress    │     │
-│  │              │  │  Repository  │  │  Repository  │     │
-│  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘     │
-└─────────┼──────────────────┼──────────────────┼─────────────┘
-          │                  │                  │
-          ▼                  ▼                  ▼
+│                  Simulation Engine                          │
+│  ┌──────────────┐  ┌──────────────┐                        │
+│  │  Config      │  │  Wall        │                        │
+│  │  Parser      │  │  Simulator   │                        │
+│  │              │  │ +ThreadPool  │                        │
+│  └──────────────┘  └──────┬───────┘                        │
+└──────────────────────────┼──────────────────────────────────┘
+                            │
+                            ▼
 ┌─────────────────────────────────────────────────────────────┐
 │               Django ORM + SQLite Database                  │
 │  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐     │
 │  │  Profile     │  │  WallSection │  │  Daily       │     │
-│  │  Model       │  │  Model       │  │  Progress    │     │
-│  │              │  │              │  │  Model       │     │
+│  │              │──│              │──│  Progress    │     │
+│  │  - name      │  │  - profile   │  │  - section   │     │
+│  │  - lead      │  │  - name      │  │  - date      │     │
+│  │  - active    │  │  - initial_h │  │  - feet      │     │
+│  │              │  │  - current_h │  │  - ice       │     │
+│  │              │  │              │  │  - cost      │     │
 │  └──────────────┘  └──────────────┘  └──────────────┘     │
 └─────────────────────────────────────────────────────────────┘
 ```
 
-### ThreadPoolExecutor Integration
-
-```python
-from concurrent.futures import ThreadPoolExecutor
-from django.conf import settings
-
-# services/cost_aggregator.py
-class CostAggregator:
-    def __init__(self):
-        self.executor = ThreadPoolExecutor(
-            max_workers=settings.WORKER_POOL_SIZE
-        )
-
-    def calculate_parallel_costs(self, profiles, date_range):
-        futures = [
-            self.executor.submit(self._calculate_cost, profile, date_range)
-            for profile in profiles
-        ]
-        return [f.result() for f in futures]
-```
-
 ## Data Models
 
 ### Profile Model
 ```python
-from django.db import models
-
 class Profile(models.Model):
     """Construction profile for wall building operations."""
     name = models.CharField(max_length=255, unique=True)
     team_lead = models.CharField(max_length=255)
+    is_active = models.BooleanField(default=True)
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
-    is_active = models.BooleanField(default=True)
 
     class Meta:
         db_table = 'profiles'
@@ -135,8 +113,16 @@ class WallSection(models.Model):
         related_name='wall_sections'
     )
     section_name = models.CharField(max_length=255)
-    start_position = models.DecimalField(max_digits=10, decimal_places=2)
-    target_length_feet = models.DecimalField(max_digits=10, decimal_places=2)
+    initial_height = models.IntegerField(
+        null=True,
+        blank=True,
+        help_text="Initial height in feet (0-30) for simulation"
+    )
+    current_height = models.IntegerField(
+        null=True,
+        blank=True,
+        help_text="Current height in feet during simulation"
+    )
     created_at = models.DateTimeField(auto_now_add=True)
 
     class Meta:
@@ -178,6 +164,31 @@ class DailyProgress(models.Model):
         ]
 ```
 
+## Configuration Format
+
+### Multi-Profile Config
+```
+21 25 28
+17
+17 22 17 19 17
+```
+
+**Rules:**
+- Each line = 1 profile
+- Space-separated integers = wall section heights (0-30 feet)
+- Max 2000 sections per profile
+- Empty lines ignored
+- Whitespace trimmed
+
+### Example
+```
+5 10 15
+```
+Creates:
+- 1 profile ("Profile 1", "Team Lead 1")
+- 3 wall sections at heights 5ft, 10ft, 15ft
+- Each must reach 30ft
+
 ## API Endpoints
 
 ### Base URL
@@ -185,380 +196,367 @@ class DailyProgress(models.Model):
 http://localhost:8000/api/
 ```
 
-### 1. List Profiles
+### 1. Run Simulation
 ```http
-GET /api/profiles/
+POST /api/profiles/simulate/
+Content-Type: application/json
+
+{
+  "config": "21 25 28\n17\n17 22 17 19 17",
+  "num_teams": 10,
+  "start_date": "2025-10-20"
+}
 ```
 
-**Response**
+**Response (201 Created)**
 ```json
 {
-  "count": 2,
-  "next": null,
-  "previous": null,
-  "results": [
-    {
-      "id": 1,
-      "name": "Northern Watch",
-      "team_lead": "Jon Snow",
-      "is_active": true,
-      "created_at": "2025-10-01T08:00:00Z"
-    }
-  ]
+  "total_profiles": 3,
+  "total_sections": 9,
+  "total_days": 15,
+  "total_ice_cubic_yards": "82875.00",
+  "total_cost_gold_dragons": "157462500.00"
 }
 ```
 
-### 2. Create Profile
+**Validation:**
+- `config`: Required, non-empty string
+- `num_teams`: Optional integer (default: 10)
+- `start_date`: Optional YYYY-MM-DD (default: today)
+
+### 2. Daily Ice Usage
 ```http
-POST /api/profiles/
-Content-Type: application/json
+GET /api/profiles/{profile_id}/days/{day}/
+```
 
+**Response**
+```json
 {
-  "name": "Eastern Defense",
-  "team_lead": "Tormund Giantsbane",
-  "is_active": true
+  "day": 3,
+  "total_feet_built": "10.00",
+  "total_ice_cubic_yards": "1950.00",
+  "sections": [
+    {
+      "section_name": "Section 1",
+      "feet_built": "1.00",
+      "ice_cubic_yards": "195.00"
+    }
+  ]
 }
 ```
 
-### 3. Record Daily Progress
+### 3. Overview by Day (Single Profile)
 ```http
-POST /api/profiles/{profile_id}/progress/
-Content-Type: application/json
-
-{
-  "wall_section_id": 5,
-  "date": "2025-10-15",
-  "feet_built": 12.5,
-  "notes": "Clear weather, good progress"
-}
+GET /api/profiles/{profile_id}/overview/{day}/
 ```
 
 **Response**
 ```json
 {
-  "id": 42,
-  "wall_section_id": 5,
-  "date": "2025-10-15",
-  "feet_built": "12.50",
-  "ice_cubic_yards": "2437.50",
-  "cost_gold_dragons": "4631250.00",
-  "notes": "Clear weather, good progress",
-  "created_at": "2025-10-15T14:30:00Z"
+  "day": 5,
+  "cost": "92625000.00"
 }
 ```
 
-**Calculation**
-- Ice usage: 12.5 feet × 195 yd³/ft = 2,437.5 yd³
-- Cost: 2,437.5 yd³ × 1,900 GD/yd³ = 4,631,250 GD
-
-### 4. Daily Ice Usage by Profile
+### 4. Overview by Day (All Profiles)
 ```http
-GET /api/profiles/{profile_id}/daily-ice-usage/?date=2025-10-15
+GET /api/profiles/overview/{day}/
 ```
 
 **Response**
 ```json
 {
-  "profile_id": 1,
-  "profile_name": "Northern Watch",
-  "date": "2025-10-15",
-  "total_feet_built": "28.75",
-  "total_ice_cubic_yards": "5606.25",
-  "sections": [
-    {
-      "section_name": "Tower 1-2",
-      "feet_built": "12.50",
-      "ice_cubic_yards": "2437.50"
-    },
-    {
-      "section_name": "Tower 2-3",
-      "feet_built": "16.25",
-      "ice_cubic_yards": "3168.75"
-    }
-  ]
+  "day": 10,
+  "cost": "157462500.00"
 }
 ```
 
-### 5. Cost Overview with Date Range
+### 5. Total Overview
 ```http
-GET /api/profiles/{profile_id}/cost-overview/?start_date=2025-10-01&end_date=2025-10-15
+GET /api/profiles/overview/
 ```
 
 **Response**
 ```json
 {
-  "profile_id": 1,
-  "profile_name": "Northern Watch",
-  "date_range": {
-    "start": "2025-10-01",
-    "end": "2025-10-15"
-  },
-  "summary": {
-    "total_days": 15,
-    "total_feet_built": "425.50",
-    "total_ice_cubic_yards": "82972.50",
-    "total_cost_gold_dragons": "157647750.00",
-    "average_feet_per_day": "28.37",
-    "average_cost_per_day": "10509850.00"
-  },
-  "daily_breakdown": [
-    {
-      "date": "2025-10-15",
-      "feet_built": "28.75",
-      "ice_cubic_yards": "5606.25",
-      "cost_gold_dragons": "10651875.00"
-    },
-    {
-      "date": "2025-10-14",
-      "feet_built": "31.00",
-      "ice_cubic_yards": "6045.00",
-      "cost_gold_dragons": "11485500.00"
-    }
-  ]
+  "day": null,
+  "cost": "157462500.00"
 }
 ```
 
-## Multi-Threading Implementation
+### CRUD Endpoints
+
+**Profiles**
+- `GET /api/profiles/` - List all
+- `POST /api/profiles/` - Create
+- `GET /api/profiles/{id}/` - Retrieve
+- `PUT /api/profiles/{id}/` - Update
+- `PATCH /api/profiles/{id}/` - Partial update
+- `DELETE /api/profiles/{id}/` - Delete
+
+**WallSections**
+- `GET /api/wallsections/` - List all
+- `POST /api/wallsections/` - Create
+- `GET /api/wallsections/{id}/` - Retrieve
+- `PUT /api/wallsections/{id}/` - Update
+- `DELETE /api/wallsections/{id}/` - Delete
+- Query param: `?profile={id}` - Filter by profile
+
+**DailyProgress**
+- `GET /api/progress/` - List all
+- `POST /api/progress/` - Create (auto-calculates ice/cost)
+- `GET /api/progress/{id}/` - Retrieve
+- `PUT /api/progress/{id}/` - Update
+- `DELETE /api/progress/{id}/` - Delete
+
+## Simulation Engine
 
-### Cost Aggregation Service
+### ConfigParser
 
 ```python
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from decimal import Decimal
-from django.conf import settings
-from django.db import transaction
-from django.db.models import Sum
+@dataclass
+class ProfileConfig:
+    """Configuration for a single profile's wall sections."""
+    profile_num: int
+    heights: list[int]
 
-class CostAggregatorService:
-    """
-    Service for parallel cost calculations across multiple profiles.
-    Uses ThreadPoolExecutor for CPU-bound aggregation tasks.
-    """
+class ConfigParser:
+    """Parse multi-profile wall construction configuration."""
 
-    def __init__(self, max_workers: int | None = None):
-        self.max_workers = max_workers or settings.WORKER_POOL_SIZE
-        self.executor = ThreadPoolExecutor(max_workers=self.max_workers)
+    MAX_HEIGHT = 30
+    MAX_SECTIONS_PER_PROFILE = 2000
+
+    @classmethod
+    def parse(cls, config_text: str) -> list[ProfileConfig]:
+        """Parse config string into ProfileConfig objects."""
+        profiles: list[ProfileConfig] = []
+        lines = config_text.strip().split("\n")
+
+        for line_num, raw_line in enumerate(lines, 1):
+            line_text = raw_line.strip()
+            if not line_text:
+                continue  # Skip empty lines
 
-    def calculate_multi_profile_costs(
-        self,
-        profile_ids: list[int],
-        start_date: str,
-        end_date: str
-    ) -> list[dict]:
-        """
-        Calculate costs for multiple profiles in parallel.
-
-        Args:
-            profile_ids: List of profile IDs to process
-            start_date: Start date (YYYY-MM-DD)
-            end_date: End date (YYYY-MM-DD)
-
-        Returns:
-            List of cost summaries per profile
-        """
-        futures = {
-            self.executor.submit(
-                self._calculate_profile_cost,
-                profile_id,
-                start_date,
-                end_date
-            ): profile_id
-            for profile_id in profile_ids
-        }
-
-        results = []
-        for future in as_completed(futures):
-            profile_id = futures[future]
             try:
-                result = future.result()
-                results.append(result)
-            except Exception as exc:
-                # Log error and continue with other profiles
-                logger.error(
-                    f"Profile {profile_id} cost calculation failed: {exc}"
+                heights = [int(h) for h in line_text.split()]
+            except ValueError as e:
+                raise ValueError(f"Line {line_num}: Invalid number format") from e
+
+            for height in heights:
+                if not 0 <= height <= cls.MAX_HEIGHT:
+                    raise ValueError(
+                        f"Line {line_num}: Height {height} out of range"
+                    )
+
+            if len(heights) > cls.MAX_SECTIONS_PER_PROFILE:
+                raise ValueError(
+                    f"Line {line_num}: Too many sections (max {cls.MAX_SECTIONS_PER_PROFILE})"
                 )
-                results.append({
-                    "profile_id": profile_id,
-                    "error": str(exc)
-                })
-
-        return results
 
-    def _calculate_profile_cost(
-        self,
-        profile_id: int,
-        start_date: str,
-        end_date: str
-    ) -> dict:
-        """Calculate cost summary for a single profile."""
-        from .repositories import DailyProgressRepository
-
-        repo = DailyProgressRepository()
-
-        # Use Django ORM aggregation for efficient DB queries
-        aggregates = repo.get_aggregates_by_profile(
-            profile_id,
-            start_date,
-            end_date
-        )
+            profiles.append(ProfileConfig(profile_num=line_num, heights=heights))
 
-        return {
-            "profile_id": profile_id,
-            "total_feet_built": str(aggregates["total_feet"]),
-            "total_ice_cubic_yards": str(aggregates["total_ice"]),
-            "total_cost_gold_dragons": str(aggregates["total_cost"]),
-            "calculation_thread": threading.current_thread().name
-        }
+        if not profiles:
+            raise ValueError("Config must contain at least one profile")
 
-    def shutdown(self):
-        """Gracefully shutdown the thread pool."""
-        self.executor.shutdown(wait=True)
+        return profiles
 ```
 
-### Configuration
+### WallSimulator
 
 ```python
-# settings.py
-WORKER_POOL_SIZE = 4  # Configurable based on container resources
-```
+class WallSimulator:
+    """Simulate wall construction with parallel processing."""
 
-### Usage in ViewSet
+    TARGET_HEIGHT = 30
+    FEET_PER_DAY = 1
 
-```python
-from rest_framework import viewsets
-from rest_framework.decorators import action
-from rest_framework.response import Response
+    def __init__(self, num_teams: int = 10):
+        self.num_teams = num_teams
+        self.executor = ThreadPoolExecutor(max_workers=num_teams)
 
-class ProfileViewSet(viewsets.ModelViewSet):
+    def simulate(
+        self,
+        profiles_config: list[ProfileConfig],
+        start_date: date
+    ) -> SimulationSummary:
+        """Run simulation from config."""
 
-    @action(detail=False, methods=['get'])
-    def bulk_cost_overview(self, request):
-        """Calculate costs for multiple profiles in parallel."""
-        profile_ids = request.query_params.getlist('profile_ids[]')
-        start_date = request.query_params.get('start_date')
-        end_date = request.query_params.get('end_date')
+        # 1. Initialize profiles and sections in database
+        section_data = self._initialize_profiles(profiles_config)
 
-        aggregator = CostAggregatorService()
-        try:
-            results = aggregator.calculate_multi_profile_costs(
-                profile_ids,
-                start_date,
-                end_date
-            )
-            return Response({"results": results})
-        finally:
-            aggregator.shutdown()
-```
+        # 2. Simulate day-by-day until all sections reach 30ft
+        day = 1
+        current_date = start_date
 
-## Service Layer Design
+        while any(s.current_height < self.TARGET_HEIGHT for s in section_data):
+            # 3. Assign work (round-robin up to num_teams)
+            sections_to_process = self._assign_work(section_data)
 
-### IceUsageCalculator
+            if not sections_to_process:
+                break  # No more work to assign
 
-```python
-from decimal import Decimal
+            # 4. Process sections in parallel using ThreadPoolExecutor
+            results = self._process_day(sections_to_process, day)
 
-class IceUsageCalculator:
-    """Business logic for ice usage calculations."""
+            # 5. Save progress to database
+            self._save_progress(results, current_date)
 
-    ICE_PER_FOOT = Decimal("195")  # cubic yards per foot
-    COST_PER_CUBIC_YARD = Decimal("1900")  # Gold Dragons
+            # 6. Update section heights
+            self._update_heights(section_data, results)
 
-    @classmethod
-    def calculate_ice_usage(cls, feet_built: Decimal) -> Decimal:
-        """Calculate ice usage in cubic yards."""
-        return feet_built * cls.ICE_PER_FOOT
+            day += 1
+            current_date += timedelta(days=1)
 
-    @classmethod
-    def calculate_cost(cls, ice_cubic_yards: Decimal) -> Decimal:
-        """Calculate cost in Gold Dragons."""
-        return ice_cubic_yards * cls.COST_PER_CUBIC_YARD
+        # 7. Calculate totals
+        return self._calculate_summary(section_data, day - 1)
 
-    @classmethod
-    def calculate_full_cost(cls, feet_built: Decimal) -> tuple[Decimal, Decimal]:
-        """Calculate both ice usage and cost."""
-        ice = cls.calculate_ice_usage(feet_built)
-        cost = cls.calculate_cost(ice)
-        return ice, cost
+    def _process_day(
+        self,
+        sections: list[SectionData],
+        day: int
+    ) -> list[ProcessingResult]:
+        """Process sections in parallel."""
+        futures = [
+            self.executor.submit(self._process_section, section, day)
+            for section in sections
+        ]
+        return [f.result() for f in futures]
+
+    def _process_section(
+        self,
+        section: SectionData,
+        day: int
+    ) -> ProcessingResult:
+        """Process single section (runs in thread)."""
+        feet_built = self.FEET_PER_DAY
+        remaining = self.TARGET_HEIGHT - section.current_height
+
+        if feet_built > remaining:
+            feet_built = remaining
+
+        ice = Decimal(str(feet_built)) * ICE_PER_FOOT
+        cost = ice * COST_PER_CUBIC_YARD
+
+        # Write team log
+        self._write_log(section.team_num, day, section.section_num, feet_built)
+
+        return ProcessingResult(
+            section_id=section.id,
+            feet_built=Decimal(str(feet_built)),
+            ice_cubic_yards=ice,
+            cost_gold_dragons=cost
+        )
 ```
 
-## Repository Layer Design
+## Multi-Threading Details
 
-### DailyProgressRepository
+### ThreadPoolExecutor Usage
 
 ```python
-from django.db.models import Sum, Avg, Count
-from decimal import Decimal
-
-class DailyProgressRepository:
-    """Data access layer for DailyProgress model."""
+# Initialization (in WallSimulator.__init__)
+self.executor = ThreadPoolExecutor(max_workers=num_teams)
+
+# Parallel section processing (in _process_day)
+futures = [
+    self.executor.submit(self._process_section, section, day)
+    for section in sections_to_process
+]
+results = [f.result() for f in futures]
+```
 
-    def get_by_date(self, profile_id: int, date: str):
-        """Retrieve all progress records for a profile on a specific date."""
-        return DailyProgress.objects.filter(
-            wall_section__profile_id=profile_id,
-            date=date
-        ).select_related('wall_section')
+**Benefits:**
+- Each wall section processed in separate thread
+- Up to `num_teams` sections processed concurrently
+- Simulates real concurrent construction
+- No GIL contention (I/O-bound file writes)
 
-    def get_aggregates_by_profile(
-        self,
-        profile_id: int,
-        start_date: str,
-        end_date: str
-    ) -> dict:
-        """Get aggregated statistics for a profile within date range."""
-        result = DailyProgress.objects.filter(
-            wall_section__profile_id=profile_id,
-            date__gte=start_date,
-            date__lte=end_date
-        ).aggregate(
-            total_feet=Sum('feet_built'),
-            total_ice=Sum('ice_cubic_yards'),
-            total_cost=Sum('cost_gold_dragons'),
-            avg_feet=Avg('feet_built'),
-            record_count=Count('id')
-        )
+### Log File Output
 
-        # Handle None values for empty querysets
-        return {
-            "total_feet": result["total_feet"] or Decimal("0"),
-            "total_ice": result["total_ice"] or Decimal("0"),
-            "total_cost": result["total_cost"] or Decimal("0"),
-            "avg_feet": result["avg_feet"] or Decimal("0"),
-            "record_count": result["record_count"]
-        }
+Team logs written to `logs/team_{N}.log`:
+```
+Team 1: working on Profile 1, Section 1, building 1.00ft
+Team 1: working on Profile 1, Section 2, building 1.00ft
+Team 1: Section 3 completed!
+Team 1: relieved
 ```
 
-## HuggingFace Space Deployment
+## Database Calculations
 
-### Requirements
+### Auto-Calculated Fields (DailyProgressSerializer)
 
 ```python
-# requirements.txt
-Django==5.2.7
-djangorestframework==3.16.0
+def create(self, validated_data):
+    """Auto-calculate ice and cost from feet_built."""
+    feet_built = validated_data['feet_built']
+
+    ice_cubic_yards = feet_built * ICE_PER_FOOT  # 195 yd³/ft
+    cost_gold_dragons = ice_cubic_yards * COST_PER_CUBIC_YARD  # 1900 GD/yd³
+
+    return DailyProgress.objects.create(
+        **validated_data,
+        ice_cubic_yards=ice_cubic_yards,
+        cost_gold_dragons=cost_gold_dragons
+    )
+```
+
+### Aggregations (Overview Endpoints)
+
+```python
+# Total cost across all progress records
+daily_progress = DailyProgress.objects.all()
+aggregates = daily_progress.aggregate(total_cost=Sum("cost_gold_dragons"))
+total_cost = aggregates["total_cost"] or Decimal("0.00")
+```
+
+## Testing
+
+### Test Coverage
+- **73 tests** across unit/integration/edge cases
+- **98.41% code coverage**
+- **0 MyPy/Ruff errors**
+
+### Test Categories
+
+**Unit Tests:**
+- Model validation and constraints
+- ConfigParser edge cases
+- WallSimulator logic
+- Serializer auto-calculations
+
+**Integration Tests:**
+- Full simulation workflow
+- API endpoint responses
+- Database persistence
+- CRUD operations
+
+**Edge Cases:**
+- Invalid date format handling
+- Profile with no simulation data
+- Empty database queries
+- Config parsing errors
+
+### Running Tests
+```bash
+./scripts/run_tests.py
 ```
 
-### Dockerfile
+## Deployment
 
+### HuggingFace Space
+
+**Dockerfile**
 ```dockerfile
 FROM python:3.12-slim
-
 WORKDIR /app
-
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
-
 COPY . .
-
-# Run migrations and start server
 CMD python manage.py migrate && \
     python manage.py runserver 0.0.0.0:7860
 ```
 
-### Space Configuration
-
+**Space Configuration (README.md)**
 ```yaml
-# README.md (HuggingFace Space header)
 ---
 title: Wall Construction API
 emoji: 🏰
@@ -569,99 +567,63 @@ app_port: 7860
 ---
 ```
 
-### Database Persistence
-
-- SQLite database file: `db.sqlite3`
-- Persisted in HuggingFace Space persistent storage
-- Automatic migrations on container startup
-- No external database service required
-
-## Error Handling
-
-### Standard Error Response
-
-```json
-{
-  "error": "validation_error",
-  "message": "Invalid date format",
-  "details": {
-    "date": ["Date must be in YYYY-MM-DD format"]
-  }
-}
-```
-
-### HTTP Status Codes
+### Persistence
+- **Database**: `db.sqlite3` (auto-created, migrations applied on startup)
+- **Logs**: `logs/team_*.log` (created during simulation)
+- **No external services**: Self-contained deployment
 
-- `200 OK` - Successful GET request
-- `201 Created` - Successful POST request
-- `400 Bad Request` - Validation error
-- `404 Not Found` - Resource not found
-- `500 Internal Server Error` - Server error
-
-## Testing Strategy
-
-### Unit Tests
-- Service layer: IceUsageCalculator calculations
-- Repository layer: Query correctness
-- Model layer: Validation rules
-
-### Integration Tests
-- API endpoints with test database
-- ThreadPoolExecutor parallel execution
-- Full request/response cycle
-
-### Test Data
-- Sample profiles with known outputs
-- Edge cases: zero feet built, large numbers
-- Date range boundaries
-
-## Performance Considerations
+## Performance
 
 ### Database Optimization
-- Indexes on `date` and `wall_section_id` fields
-- `select_related()` for FK queries
-- `aggregate()` for sum/avg calculations
-- Database connection pooling (built into Django)
+- Indexes on `date` and `wall_section_id`
+- `select_related()` for foreign key queries
+- `aggregate()` for sum calculations
+- Single atomic transactions per simulation
 
 ### Thread Pool Sizing
-- Default: 4 workers
-- Configurable via `WORKER_POOL_SIZE` setting
-- Balance between parallelism and resource usage
-- HuggingFace Space constraints: 2-4 workers recommended
+- Default: 10 workers (configurable via `num_teams` param)
+- Each worker processes 1 section per day
+- I/O-bound (file writes), minimal CPU contention
+- Suitable for HuggingFace Space resource limits
+
+## Constants
 
-### Query Optimization
 ```python
-# Good: Single query with aggregation
-DailyProgress.objects.filter(...).aggregate(Sum('cost_gold_dragons'))
+# constants.py
+from decimal import Decimal
 
-# Bad: Multiple queries in loop
-for progress in DailyProgress.objects.filter(...):
-    total += progress.cost_gold_dragons
+TARGET_HEIGHT = 30  # feet
+ICE_PER_FOOT = Decimal("195")  # cubic yards
+COST_PER_CUBIC_YARD = Decimal("1900")  # Gold Dragons
 ```
 
-## Future Enhancements
-
-1. **Caching Layer**: Redis cache for frequently accessed aggregations
-2. **Async Views**: Upgrade to Django 5.x async views when DRF adds native support
-3. **Background Tasks**: True Celery integration for long-running reports
-4. **PostgreSQL**: Upgrade to PostgreSQL for production deployments
-5. **Metrics Dashboard**: Real-time construction progress visualization
-6. **Export Features**: CSV/PDF report generation
-7. **Authentication**: Token-based API authentication
-8. **Rate Limiting**: Throttling for cost-intensive aggregations
-
-## Appendix: Constants
+## Example Workflow
 
 ```python
-# constants.py
-from decimal import Decimal
+# 1. POST simulation config
+POST /api/profiles/simulate/
+{
+  "config": "5 10 15",
+  "num_teams": 10
+}
+
+# 2. Check total cost
+GET /api/profiles/overview/
+→ {"day": null, "cost": "16965000.00"}
 
-# Wall Construction Constants
-ICE_CUBIC_YARDS_PER_FOOT = Decimal("195")
-GOLD_DRAGONS_PER_CUBIC_YARD = Decimal("1900")
+# 3. Check day 5 progress
+GET /api/profiles/overview/5/
+→ {"day": 5, "cost": "9262500.00"}
 
-# Calculated Constants
-GOLD_DRAGONS_PER_FOOT = (
-    ICE_CUBIC_YARDS_PER_FOOT * GOLD_DRAGONS_PER_CUBIC_YARD
-)  # 370,500 GD per foot
+# 4. List all profiles
+GET /api/profiles/
+→ [{"id": 1, "name": "Profile 1", "team_lead": "Team Lead 1"}]
+
+# 5. View section details
+GET /api/wallsections/?profile=1
+→ [
+    {"section_name": "Section 1", "initial_height": 5, "current_height": 30},
+    {"section_name": "Section 2", "initial_height": 10, "current_height": 30},
+    {"section_name": "Section 3", "initial_height": 15, "current_height": 30}
+  ]
 ```

apps/profiles/constants.py

@@ -0,0 +1,9 @@
+"""Centralized constants for wall construction calculations."""
+
+from __future__ import annotations
+
+from decimal import Decimal
+
+ICE_PER_FOOT = Decimal("195")  # cubic yards per linear foot
+COST_PER_CUBIC_YARD = Decimal("1900")  # Gold Dragons per cubic yard
+TARGET_HEIGHT = 30  # feet - maximum wall height

apps/profiles/migrations/0003_remove_wallsection_start_position_and_more.py

@@ -0,0 +1,20 @@
+# Generated by Django 5.2.7 on 2025-10-20 23:05
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("profiles", "0002_add_simulation_fields"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="wallsection",
+            name="start_position",
+        ),
+        migrations.RemoveField(
+            model_name="wallsection",
+            name="target_length_feet",
+        ),
+    ]

apps/profiles/models.py

@@ -2,8 +2,6 @@
 
 from __future__ import annotations
 
-from decimal import Decimal
-
 from django.db import models
 
 
@@ -34,8 +32,6 @@ class WallSection(models.Model):
         related_name="wall_sections",
     )
     section_name = models.CharField(max_length=255)
-    start_position = models.DecimalField(max_digits=10, decimal_places=2)
-    target_length_feet = models.DecimalField(max_digits=10, decimal_places=2)
     initial_height = models.IntegerField(
         null=True,
         blank=True,
@@ -61,9 +57,6 @@ class WallSection(models.Model):
 class DailyProgress(models.Model):
     """Daily construction progress for a wall section."""
 
-    ICE_PER_FOOT = Decimal("195")  # cubic yards per linear foot
-    COST_PER_CUBIC_YARD = Decimal("1900")  # Gold Dragons per cubic yard
-
     wall_section = models.ForeignKey(
         WallSection,
         on_delete=models.CASCADE,

apps/profiles/repositories.py

@@ -1,64 +0,0 @@
-"""Repository layer for Profile app data access."""
-
-from __future__ import annotations
-
-from datetime import date
-from decimal import Decimal
-
-from django.db.models import Avg, Count, QuerySet, Sum
-
-from apps.profiles.models import DailyProgress
-
-
-class DailyProgressRepository:
-    """Data access layer for DailyProgress model."""
-
-    def get_by_date(self, profile_id: int, target_date: date) -> QuerySet[DailyProgress]:
-        """Retrieve all progress records for a profile on a specific date.
-
-        Args:
-            profile_id: Profile ID to filter by
-            target_date: Date to retrieve progress for
-
-        Returns:
-            QuerySet of DailyProgress records with wall_section pre-fetched
-        """
-        return DailyProgress.objects.filter(wall_section__profile_id=profile_id, date=target_date).select_related("wall_section")
-
-    def get_aggregates_by_profile(self, profile_id: int, start_date: date, end_date: date) -> dict[str, Decimal | int]:
-        """Get aggregated statistics for a profile within date range.
-
-        Args:
-            profile_id: Profile ID to aggregate for
-            start_date: Start date of range (inclusive)
-            end_date: End date of range (inclusive)
-
-        Returns:
-            Dictionary with aggregated statistics:
-                - total_feet: Sum of feet_built
-                - total_ice: Sum of ice_cubic_yards
-                - total_cost: Sum of cost_gold_dragons
-                - avg_feet: Average feet_built per day
-                - record_count: Number of records in range
-        """
-        result = DailyProgress.objects.filter(
-            wall_section__profile_id=profile_id,
-            date__gte=start_date,
-            date__lte=end_date,
-        ).aggregate(
-            total_feet=Sum("feet_built"),
-            total_ice=Sum("ice_cubic_yards"),
-            total_cost=Sum("cost_gold_dragons"),
-            avg_feet=Avg("feet_built"),
-            record_count=Count("id"),
-        )
-
-        # Normalize all decimals to 2 decimal places
-        two_places = Decimal("0.01")
-        return {
-            "total_feet": (Decimal("0") if result["total_feet"] is None else result["total_feet"]).quantize(two_places),
-            "total_ice": (Decimal("0") if result["total_ice"] is None else result["total_ice"]).quantize(two_places),
-            "total_cost": (Decimal("0") if result["total_cost"] is None else result["total_cost"]).quantize(two_places),
-            "avg_feet": (Decimal("0") if result["avg_feet"] is None else result["avg_feet"]).quantize(two_places),
-            "record_count": result["record_count"],
-        }

apps/profiles/serializers.py

@@ -7,8 +7,8 @@ from typing import cast
 
 from rest_framework import serializers
 
+from apps.profiles.constants import COST_PER_CUBIC_YARD, ICE_PER_FOOT
 from apps.profiles.models import DailyProgress, Profile, WallSection
-from apps.profiles.services.calculators import IceUsageCalculator
 
 
 class ProfileSerializer(serializers.ModelSerializer[Profile]):
@@ -29,8 +29,8 @@ class WallSectionSerializer(serializers.ModelSerializer[WallSection]):
             "id",
             "profile",
             "section_name",
-            "start_position",
-            "target_length_feet",
+            "initial_height",
+            "current_height",
             "created_at",
         ]
         read_only_fields = ["id", "created_at"]
@@ -55,11 +55,9 @@ class DailyProgressSerializer(serializers.ModelSerializer[DailyProgress]):
 
     def create(self, validated_data: dict[str, object]) -> DailyProgress:
         """Create DailyProgress with auto-calculated ice_cubic_yards and cost_gold_dragons."""
-        calculator = IceUsageCalculator()
-
         feet_built = cast(Decimal, validated_data["feet_built"])
-        ice_cubic_yards = calculator.calculate_ice_usage(feet_built)
-        cost_gold_dragons = calculator.calculate_daily_cost(ice_cubic_yards)
+        ice_cubic_yards = feet_built * ICE_PER_FOOT
+        cost_gold_dragons = ice_cubic_yards * COST_PER_CUBIC_YARD
 
         validated_data["ice_cubic_yards"] = ice_cubic_yards
         validated_data["cost_gold_dragons"] = cost_gold_dragons

apps/profiles/services/aggregators.py

@@ -1,124 +0,0 @@
-"""Service for cost calculations across multiple profiles."""
-
-from __future__ import annotations
-
-from concurrent.futures import Future, as_completed
-from datetime import date, datetime
-
-from apps.profiles.repositories import DailyProgressRepository
-
-
-class SynchronousExecutor:
-    """Executor that runs tasks synchronously in the same thread.
-
-    Provides ThreadPoolExecutor-compatible interface for SQLite compatibility.
-    SQLite with Django test transactions requires same-thread execution.
-    """
-
-    def submit(self, fn, *args, **kwargs) -> Future[dict[str, int | str]]:  # type: ignore[no-untyped-def]
-        """Submit a callable to be executed synchronously."""
-        future: Future[dict[str, int | str]] = Future()
-        try:
-            result = fn(*args, **kwargs)
-            future.set_result(result)
-        except Exception as e:
-            future.set_exception(e)
-        return future
-
-    def shutdown(self) -> None:
-        """Shutdown executor - synchronous execution requires no cleanup."""
-        return
-
-
-class CostAggregatorService:
-    """Service for cost calculations across multiple profiles.
-
-    Uses synchronous executor for SQLite database compatibility.
-    Processes profiles serially in the same thread to avoid database
-    locking issues with SQLite transactions in Django tests.
-    """
-
-    def __init__(self) -> None:
-        """Initialize service with synchronous executor."""
-        self.executor = SynchronousExecutor()
-
-    def calculate_multi_profile_costs(
-        self,
-        profile_ids: list[int],
-        start_date: str,
-        end_date: str,
-    ) -> list[dict[str, int | str]]:
-        """Calculate costs for multiple profiles.
-
-        Args:
-            profile_ids: List of profile IDs to process
-            start_date: Start date (YYYY-MM-DD)
-            end_date: End date (YYYY-MM-DD)
-
-        Returns:
-            List of cost summaries per profile
-
-        Raises:
-            ValueError: If date format is invalid
-            Exception: Any exception raised during profile cost calculation
-        """
-        # Convert string dates to date objects (can raise ValueError)
-        start_date_obj = datetime.strptime(start_date, "%Y-%m-%d").date()
-        end_date_obj = datetime.strptime(end_date, "%Y-%m-%d").date()
-
-        futures = {
-            self.executor.submit(
-                self._calculate_profile_cost,
-                profile_id,
-                start_date_obj,
-                end_date_obj,
-            ): profile_id
-            for profile_id in profile_ids
-        }
-
-        results = []
-        for future in as_completed(futures):
-            profile_id = futures[future]
-            try:
-                result = future.result()
-                results.append(result)
-            except Exception as e:
-                raise RuntimeError(f"Failed to calculate costs for profile {profile_id}") from e
-
-        return results
-
-    def shutdown(self) -> None:
-        """Shutdown the executor."""
-        self.executor.shutdown()
-
-    def _calculate_profile_cost(
-        self,
-        profile_id: int,
-        start_date_obj: date,
-        end_date_obj: date,
-    ) -> dict[str, int | str]:
-        """Calculate cost summary for a single profile.
-
-        Args:
-            profile_id: Profile ID to calculate for
-            start_date_obj: Start date object
-            end_date_obj: End date object
-
-        Returns:
-            Dictionary with profile cost summary
-        """
-        repo = DailyProgressRepository()
-
-        # Use Django ORM aggregation for efficient DB queries
-        aggregates = repo.get_aggregates_by_profile(
-            profile_id,
-            start_date_obj,
-            end_date_obj,
-        )
-
-        return {
-            "profile_id": profile_id,
-            "total_feet_built": str(aggregates["total_feet"]),
-            "total_ice_cubic_yards": str(aggregates["total_ice"]),
-            "total_cost_gold_dragons": str(aggregates["total_cost"]),
-        }

apps/profiles/services/calculators.py

@@ -1,34 +0,0 @@
-"""Calculator services for ice usage and cost calculations."""
-
-from __future__ import annotations
-
-from decimal import Decimal
-
-
-class IceUsageCalculator:
-    """Calculate ice usage and costs for wall construction."""
-
-    ICE_PER_FOOT = Decimal("195")  # cubic yards per linear foot
-    COST_PER_CUBIC_YARD = Decimal("1900")  # Gold Dragons per cubic yard
-
-    def calculate_ice_usage(self, feet_built: Decimal) -> Decimal:
-        """Calculate ice usage in cubic yards from feet built.
-
-        Args:
-            feet_built: Linear feet of wall built
-
-        Returns:
-            Ice usage in cubic yards (feet_built × 195)
-        """
-        return feet_built * self.ICE_PER_FOOT
-
-    def calculate_daily_cost(self, ice_cubic_yards: Decimal) -> Decimal:
-        """Calculate daily cost in Gold Dragons from ice usage.
-
-        Args:
-            ice_cubic_yards: Ice usage in cubic yards
-
-        Returns:
-            Daily cost in Gold Dragons (ice_cubic_yards × 1900)
-        """
-        return ice_cubic_yards * self.COST_PER_CUBIC_YARD

apps/profiles/services/simulator.py

@@ -9,6 +9,7 @@ from pathlib import Path
 
 from pydantic import BaseModel, ConfigDict
 
+from apps.profiles.constants import COST_PER_CUBIC_YARD, ICE_PER_FOOT, TARGET_HEIGHT
 from apps.profiles.models import DailyProgress, Profile, WallSection
 
 
@@ -59,10 +60,6 @@ class WallSimulator:
     SQLite compatibility through main-thread-only database operations.
     """
 
-    TARGET_HEIGHT = 30
-    ICE_PER_FOOT = Decimal("195")
-    COST_PER_CUBIC_YARD = Decimal("1900")
-
     def __init__(self, num_teams: int, log_dir: str = "logs"):
         """Initialize simulator with team pool.
 
@@ -97,7 +94,7 @@ class WallSimulator:
         current_date = start_date
         day = 1
 
-        while any(s.current_height < self.TARGET_HEIGHT for s in section_data):
+        while any(s.current_height < TARGET_HEIGHT for s in section_data):
             sections_to_process = self._assign_work(section_data)
 
             if not sections_to_process:
@@ -160,8 +157,6 @@ class WallSimulator:
                 section = WallSection.objects.create(
                     profile=profile,
                     section_name=f"Section {section_num}",
-                    start_position=Decimal(str(section_num - 1)),
-                    target_length_feet=Decimal("1.0"),
                     initial_height=height,
                     current_height=height,
                 )
@@ -190,7 +185,7 @@ class WallSimulator:
         Returns:
             Sections assigned to teams for this day
         """
-        incomplete_sections = [s for s in section_data if s.current_height < self.TARGET_HEIGHT]
+        incomplete_sections = [s for s in section_data if s.current_height < TARGET_HEIGHT]
 
         return incomplete_sections[: self.num_teams]
 
@@ -243,14 +238,14 @@ class WallSimulator:
             Processing result
         """
         feet_built = 1
-        ice = Decimal(str(feet_built)) * self.ICE_PER_FOOT
-        cost = ice * self.COST_PER_CUBIC_YARD
+        ice = Decimal(str(feet_built)) * ICE_PER_FOOT
+        cost = ice * COST_PER_CUBIC_YARD
 
         new_height = section.current_height + feet_built
 
         log_file = self.log_dir / f"team_{team_id}.log"
         with log_file.open("a") as f:
-            if new_height >= self.TARGET_HEIGHT:
+            if new_height >= TARGET_HEIGHT:
                 f.write(f"Day {day}: Team {team_id} completed {section.section_name} ({section.profile_name})\n")
             else:
                 f.write(f"Day {day}: Team {team_id} worked on {section.section_name} ({section.profile_name}) - {new_height}/30 ft\n")

apps/profiles/views.py

@@ -14,13 +14,11 @@ from rest_framework.response import Response
 
 from apps.profiles.models import DailyProgress, Profile, WallSection
 from apps.profiles.parsers import ConfigParser
-from apps.profiles.repositories import DailyProgressRepository
 from apps.profiles.serializers import (
     DailyProgressSerializer,
     ProfileSerializer,
     WallSectionSerializer,
 )
-from apps.profiles.services.aggregators import CostAggregatorService
 from apps.profiles.services.simulator import WallSimulator
 
 
@@ -30,233 +28,6 @@ class ProfileViewSet(viewsets.ModelViewSet[Profile]):
     queryset = Profile.objects.all()
     serializer_class = ProfileSerializer
 
-    @action(detail=True, methods=["get"], url_path="daily-ice-usage")
-    def daily_ice_usage(self, request: Request, pk: int) -> Response:
-        """Get daily ice usage aggregated by profile for a specific date."""
-        profile = get_object_or_404(Profile, pk=pk)
-        target_date = request.query_params.get("date")
-
-        if not target_date:
-            return Response(
-                {"error": "date parameter is required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Validate date format (YYYY-MM-DD)
-        try:
-            datetime.strptime(target_date, "%Y-%m-%d")
-        except ValueError:
-            return Response(
-                {"error": "date must be in YYYY-MM-DD format"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Get all wall sections for this profile
-        wall_sections = WallSection.objects.filter(profile=profile)
-
-        # Get daily progress for all sections on target date
-        daily_progress = DailyProgress.objects.filter(wall_section__in=wall_sections, date=target_date)
-
-        # Aggregate totals
-        aggregates = daily_progress.aggregate(
-            total_feet=Sum("feet_built"),
-            total_ice=Sum("ice_cubic_yards"),
-        )
-
-        # Explicit None checking with ternary operators
-        total_feet_built = Decimal("0.00") if aggregates["total_feet"] is None else aggregates["total_feet"]
-        total_ice_cubic_yards = Decimal("0.00") if aggregates["total_ice"] is None else aggregates["total_ice"]
-
-        # Build section breakdown
-        sections = []
-        for progress in daily_progress:
-            sections.append(
-                {
-                    "section_name": progress.wall_section.section_name,
-                    "feet_built": str(progress.feet_built),
-                    "ice_cubic_yards": str(progress.ice_cubic_yards),
-                }
-            )
-
-        return Response(
-            {
-                "profile_id": profile.id,
-                "profile_name": profile.name,
-                "date": target_date,
-                "total_feet_built": str(total_feet_built),
-                "total_ice_cubic_yards": str(total_ice_cubic_yards),
-                "sections": sections,
-            }
-        )
-
-    @action(detail=True, methods=["get"], url_path="cost-overview")
-    def cost_overview(self, request: Request, pk: int) -> Response:
-        """Get cost overview for a profile within a date range."""
-        profile = get_object_or_404(Profile, pk=pk)
-        start_date_str = request.query_params.get("start_date")
-        end_date_str = request.query_params.get("end_date")
-
-        if not start_date_str:
-            return Response(
-                {"error": "start_date parameter is required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        if not end_date_str:
-            return Response(
-                {"error": "end_date parameter is required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Validate date formats (YYYY-MM-DD)
-        try:
-            start_date = datetime.strptime(start_date_str, "%Y-%m-%d").date()
-        except ValueError:
-            return Response(
-                {"error": "start_date must be in YYYY-MM-DD format"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        try:
-            end_date = datetime.strptime(end_date_str, "%Y-%m-%d").date()
-        except ValueError:
-            return Response(
-                {"error": "end_date must be in YYYY-MM-DD format"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Get aggregated statistics using repository
-        repo = DailyProgressRepository()
-        aggregates = repo.get_aggregates_by_profile(profile.id, start_date, end_date)
-
-        # Calculate total days in range
-        total_days = (end_date - start_date).days + 1
-
-        # Calculate average cost per day
-        total_cost = Decimal(str(aggregates["total_cost"]))
-        record_count = aggregates["record_count"]
-        average_cost_per_day = (total_cost / record_count).quantize(Decimal("0.01")) if record_count > 0 else Decimal("0.00")
-
-        # Build daily breakdown - only include days with actual progress
-        daily_breakdown = []
-        current_date = start_date
-        while current_date <= end_date:
-            day_progress = repo.get_by_date(profile.id, current_date)
-            if day_progress.exists():
-                day_aggregates = day_progress.aggregate(
-                    total_feet=Sum("feet_built"),
-                    total_ice=Sum("ice_cubic_yards"),
-                    total_cost=Sum("cost_gold_dragons"),
-                )
-                # Since day_progress.exists() is True, aggregates cannot be None
-                daily_breakdown.append(
-                    {
-                        "date": current_date.isoformat(),
-                        "feet_built": str(day_aggregates["total_feet"]),
-                        "ice_cubic_yards": str(day_aggregates["total_ice"]),
-                        "cost_gold_dragons": str(day_aggregates["total_cost"]),
-                    }
-                )
-            current_date += timedelta(days=1)
-
-        return Response(
-            {
-                "profile_id": profile.id,
-                "profile_name": profile.name,
-                "date_range": {
-                    "start": start_date_str,
-                    "end": end_date_str,
-                },
-                "summary": {
-                    "total_days": total_days,
-                    "total_feet_built": str(aggregates["total_feet"]),
-                    "total_ice_cubic_yards": str(aggregates["total_ice"]),
-                    "total_cost_gold_dragons": str(aggregates["total_cost"]),
-                    "average_feet_per_day": str(aggregates["avg_feet"]),
-                    "average_cost_per_day": str(average_cost_per_day),
-                },
-                "daily_breakdown": daily_breakdown,
-            }
-        )
-
-    @action(detail=False, methods=["get"], url_path="bulk-cost-overview")
-    def bulk_cost_overview(self, request: Request) -> Response:
-        """Calculate costs for multiple profiles."""
-        profile_ids_str = request.query_params.get("profile_ids")
-        start_date = request.query_params.get("start_date")
-        end_date = request.query_params.get("end_date")
-
-        if not profile_ids_str:
-            return Response(
-                {"error": "profile_ids parameter is required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        if not start_date:
-            return Response(
-                {"error": "start_date parameter is required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        if not end_date:
-            return Response(
-                {"error": "end_date parameter is required"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Parse comma-separated profile IDs
-        try:
-            profile_ids = [int(pid.strip()) for pid in profile_ids_str.split(",")]
-        except ValueError:
-            return Response(
-                {"error": "profile_ids must be comma-separated integers"},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Use CostAggregatorService for parallel processing
-        aggregator = CostAggregatorService()
-        try:
-            results = aggregator.calculate_multi_profile_costs(profile_ids, start_date, end_date)
-            return Response({"results": results})
-        finally:
-            aggregator.shutdown()
-
-    @action(detail=True, methods=["post"], url_path="progress")
-    def create_progress(self, request: Request, pk: int) -> Response:
-        """Create daily progress for a wall section under this profile."""
-        profile = get_object_or_404(Profile, pk=pk)
-
-        wall_section_id = request.data.get("wall_section_id")
-
-        if not wall_section_id:
-            return Response(
-                {"wall_section_id": ["This field is required."]},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Validate wall_section belongs to this profile
-        wall_section = get_object_or_404(WallSection, pk=wall_section_id)
-        if wall_section.profile_id != profile.id:
-            return Response(
-                {"wall_section_id": ["Wall section does not belong to this profile."]},
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
-        # Prepare data for serializer (use wall_section instead of wall_section_id)
-        progress_data = {
-            "wall_section": wall_section_id,
-            "date": request.data.get("date"),
-            "feet_built": request.data.get("feet_built"),
-            "notes": request.data.get("notes", ""),
-        }
-
-        serializer = DailyProgressSerializer(data=progress_data)
-        if serializer.is_valid():
-            serializer.save()
-            return Response(serializer.data, status=status.HTTP_201_CREATED)
-
-        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
     @action(detail=False, methods=["post"], url_path="simulate")
     def simulate(self, request: Request) -> Response:
         """Trigger wall construction simulation from config.

scripts/run_tests.py

@@ -1,31 +1,43 @@
 #!/usr/bin/env python3
-"""Test runner for demo project."""
+"""Minimal test runner for demo project - no base dependencies."""
 
 from __future__ import annotations
 
-import logging
 import subprocess
 import sys
 from pathlib import Path
 
-logging.basicConfig(level=logging.INFO, format="%(message)s")
-
 
 def main() -> int:
-    """Run pytest with all command line arguments passed through."""
+    """Run pytest using demo's .venv."""
     demo_root = Path(__file__).resolve().parent.parent
-    tests_dir = demo_root / "tests"
+    venv_python = demo_root / ".venv" / "bin" / "python"
+
+    if not venv_python.exists():
+        sys.stderr.write(f"Error: {venv_python} not found. Run module_setup.py first.\n")
+        return 1
 
+    tests_dir = demo_root / "tests"
     if not tests_dir.exists():
-        logging.info(f"No tests directory found at {tests_dir}. Nothing to test.")
+        sys.stderr.write(f"No tests directory found at {tests_dir}. Nothing to test.\n")
         return 0
 
-    test_files = list(tests_dir.rglob("test_*.py")) + list(tests_dir.rglob("*_test.py"))
-    if not test_files:
-        logging.info("No test files found. Nothing to test.")
-        return 0
+    # Build pytest command with default args if none provided
+    cmd = [str(venv_python), "-m", "pytest"]
+
+    # Add default args only if no args provided
+    if len(sys.argv) == 1:
+        cmd.extend(
+            [
+                "tests/",
+                "-v",
+                "--cov=apps",
+                "--cov-report=term-missing",
+            ]
+        )
+    else:
+        cmd.extend(sys.argv[1:])
 
-    cmd = [sys.executable, "-m", "pytest"] + sys.argv[1:]
     try:
         subprocess.run(cmd, cwd=str(demo_root), check=True)
         return 0

tests/integration/test_edge_cases.py

@@ -0,0 +1,40 @@
+"""Integration tests for edge cases and error paths."""
+
+from __future__ import annotations
+
+import pytest
+from rest_framework import status
+from rest_framework.test import APIClient
+
+
+@pytest.mark.django_db
+@pytest.mark.integration
+class TestEdgeCases:
+    """Test edge cases and error handling paths."""
+
+    def test_simulate_with_invalid_start_date_format(self, api_client: APIClient) -> None:
+        """Test /simulate/ rejects invalid start_date format."""
+        response = api_client.post(
+            "/api/profiles/simulate/",
+            {"config": "5", "num_teams": 10, "start_date": "invalid-date"},
+            format="json",
+        )
+
+        assert response.status_code == status.HTTP_400_BAD_REQUEST
+        assert "start_date must be in YYYY-MM-DD format" in response.data["error"]
+
+    def test_overview_by_day_with_no_simulation_data(self, api_client: APIClient) -> None:
+        """Test profile-specific /overview/<day>/ returns 404 when profile has no simulation data."""
+        # Create a profile but run no simulation
+        profile_response = api_client.post(
+            "/api/profiles/",
+            {"name": "Test Profile", "team_lead": "Test Lead"},
+            format="json",
+        )
+        profile_id = profile_response.data["id"]
+
+        # Request overview for day 1
+        response = api_client.get(f"/api/profiles/{profile_id}/overview/1/")
+
+        assert response.status_code == status.HTTP_404_NOT_FOUND
+        assert "No simulation data for this profile" in response.data["error"]

tests/integration/test_profile_api.py

@@ -2,16 +2,11 @@
 
 from __future__ import annotations
 
-from datetime import date
-from decimal import Decimal
-
 import pytest
 from django.urls import reverse
 from rest_framework import status
 from rest_framework.test import APIClient
 
-from apps.profiles.models import DailyProgress, Profile, WallSection
-
 
 @pytest.mark.django_db
 @pytest.mark.integration
@@ -197,386 +192,3 @@ class TestProfileAPI:
 
         assert response.status_code == status.HTTP_201_CREATED
         assert response.data["is_active"] is True
-
-    def test_daily_ice_usage_success(self, api_client: APIClient) -> None:
-        """Test daily ice usage endpoint returns aggregated data."""
-        # Create profile
-        profile = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-
-        # Create wall sections
-        section1 = WallSection.objects.create(
-            profile=profile,
-            section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
-        )
-        section2 = WallSection.objects.create(
-            profile=profile,
-            section_name="Tower 2-3",
-            start_position=Decimal("500.00"),
-            target_length_feet=Decimal("500.00"),
-        )
-
-        # Create daily progress for same date
-        target_date = date(2025, 10, 15)
-        DailyProgress.objects.create(
-            wall_section=section1,
-            date=target_date,
-            feet_built=Decimal("12.50"),
-            ice_cubic_yards=Decimal("2437.50"),
-            cost_gold_dragons=Decimal("4631250.00"),
-        )
-        DailyProgress.objects.create(
-            wall_section=section2,
-            date=target_date,
-            feet_built=Decimal("16.25"),
-            ice_cubic_yards=Decimal("3168.75"),
-            cost_gold_dragons=Decimal("6020625.00"),
-        )
-
-        url = reverse("profile-daily-ice-usage", kwargs={"pk": profile.id})
-        response = api_client.get(url, {"date": "2025-10-15"})
-
-        assert response.status_code == status.HTTP_200_OK
-        assert response.data["profile_id"] == profile.id
-        assert response.data["profile_name"] == "Northern Watch"
-        assert response.data["date"] == "2025-10-15"
-        assert response.data["total_feet_built"] == "28.75"
-        assert response.data["total_ice_cubic_yards"] == "5606.25"
-        assert len(response.data["sections"]) == 2
-
-    def test_daily_ice_usage_no_data_for_date(self, api_client: APIClient) -> None:
-        """Test daily ice usage when no progress exists for given date."""
-        profile = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-
-        url = reverse("profile-daily-ice-usage", kwargs={"pk": profile.id})
-        response = api_client.get(url, {"date": "2025-10-15"})
-
-        assert response.status_code == status.HTTP_200_OK
-        assert response.data["total_feet_built"] == "0.00"
-        assert response.data["total_ice_cubic_yards"] == "0.00"
-        assert response.data["sections"] == []
-
-    def test_daily_ice_usage_invalid_profile(self, api_client: APIClient) -> None:
-        """Test daily ice usage with non-existent profile returns 404."""
-        url = reverse("profile-daily-ice-usage", kwargs={"pk": 9999})
-        response = api_client.get(url, {"date": "2025-10-15"})
-
-        assert response.status_code == status.HTTP_404_NOT_FOUND
-
-    def test_daily_ice_usage_missing_date_param(self, api_client: APIClient) -> None:
-        """Test daily ice usage without date parameter returns 400."""
-        profile = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-
-        url = reverse("profile-daily-ice-usage", kwargs={"pk": profile.id})
-        response = api_client.get(url)
-
-        assert response.status_code == status.HTTP_400_BAD_REQUEST
-
-    def test_cost_overview_success(self, api_client: APIClient) -> None:
-        """Test cost overview endpoint returns aggregated data for date range."""
-        profile = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-        section = WallSection.objects.create(
-            profile=profile,
-            section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
-        )
-
-        DailyProgress.objects.create(
-            wall_section=section,
-            date=date(2025, 10, 1),
-            feet_built=Decimal("10.00"),
-            ice_cubic_yards=Decimal("1950.00"),
-            cost_gold_dragons=Decimal("3705000.00"),
-        )
-        DailyProgress.objects.create(
-            wall_section=section,
-            date=date(2025, 10, 2),
-            feet_built=Decimal("15.00"),
-            ice_cubic_yards=Decimal("2925.00"),
-            cost_gold_dragons=Decimal("5557500.00"),
-        )
-        DailyProgress.objects.create(
-            wall_section=section,
-            date=date(2025, 10, 3),
-            feet_built=Decimal("20.00"),
-            ice_cubic_yards=Decimal("3900.00"),
-            cost_gold_dragons=Decimal("7410000.00"),
-        )
-
-        url = reverse("profile-cost-overview", kwargs={"pk": profile.id})
-        response = api_client.get(url, {"start_date": "2025-10-01", "end_date": "2025-10-03"})
-
-        assert response.status_code == status.HTTP_200_OK
-        assert response.data["profile_id"] == profile.id
-        assert response.data["profile_name"] == "Northern Watch"
-        assert response.data["date_range"]["start"] == "2025-10-01"
-        assert response.data["date_range"]["end"] == "2025-10-03"
-        assert response.data["summary"]["total_days"] == 3
-        assert response.data["summary"]["total_feet_built"] == "45.00"
-        assert response.data["summary"]["total_ice_cubic_yards"] == "8775.00"
-        assert response.data["summary"]["total_cost_gold_dragons"] == "16672500.00"
-        assert response.data["summary"]["average_feet_per_day"] == "15.00"
-        assert response.data["summary"]["average_cost_per_day"] == "5557500.00"
-        assert len(response.data["daily_breakdown"]) == 3
-
-    def test_cost_overview_no_data_for_range(self, api_client: APIClient) -> None:
-        """Test cost overview when no progress exists for given date range."""
-        profile = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-
-        url = reverse("profile-cost-overview", kwargs={"pk": profile.id})
-        response = api_client.get(url, {"start_date": "2025-10-01", "end_date": "2025-10-15"})
-
-        assert response.status_code == status.HTTP_200_OK
-        assert response.data["summary"]["total_feet_built"] == "0.00"
-        assert response.data["summary"]["total_ice_cubic_yards"] == "0.00"
-        assert response.data["summary"]["total_cost_gold_dragons"] == "0.00"
-        assert response.data["summary"]["average_feet_per_day"] == "0.00"
-        assert response.data["summary"]["average_cost_per_day"] == "0.00"
-        assert response.data["daily_breakdown"] == []
-
-    def test_cost_overview_invalid_profile(self, api_client: APIClient) -> None:
-        """Test cost overview with non-existent profile returns 404."""
-        url = reverse("profile-cost-overview", kwargs={"pk": 9999})
-        response = api_client.get(url, {"start_date": "2025-10-01", "end_date": "2025-10-15"})
-
-        assert response.status_code == status.HTTP_404_NOT_FOUND
-
-    def test_cost_overview_missing_start_date_param(self, api_client: APIClient) -> None:
-        """Test cost overview without start_date parameter returns 400."""
-        profile = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-
-        url = reverse("profile-cost-overview", kwargs={"pk": profile.id})
-        response = api_client.get(url, {"end_date": "2025-10-15"})
-
-        assert response.status_code == status.HTTP_400_BAD_REQUEST
-
-    def test_cost_overview_missing_end_date_param(self, api_client: APIClient) -> None:
-        """Test cost overview without end_date parameter returns 400."""
-        profile = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-
-        url = reverse("profile-cost-overview", kwargs={"pk": profile.id})
-        response = api_client.get(url, {"start_date": "2025-10-01"})
-
-        assert response.status_code == status.HTTP_400_BAD_REQUEST
-
-    def test_cost_overview_invalid_date_format(self, api_client: APIClient) -> None:
-        """Test cost overview with invalid date format returns 400."""
-        profile = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-
-        url = reverse("profile-cost-overview", kwargs={"pk": profile.id})
-        response = api_client.get(url, {"start_date": "2025/10/01", "end_date": "2025-10-15"})
-
-        assert response.status_code == status.HTTP_400_BAD_REQUEST
-
-    def test_bulk_cost_overview_success(self, api_client: APIClient) -> None:
-        """Test bulk cost overview endpoint processes multiple profiles in parallel."""
-        profile1 = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-        profile2 = Profile.objects.create(name="Eastern Defense", team_lead="Tormund")
-        section1 = WallSection.objects.create(
-            profile=profile1,
-            section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
-        )
-        section2 = WallSection.objects.create(
-            profile=profile2,
-            section_name="Tower 5-6",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
-        )
-
-        DailyProgress.objects.create(
-            wall_section=section1,
-            date=date(2025, 10, 1),
-            feet_built=Decimal("10.00"),
-            ice_cubic_yards=Decimal("1950.00"),
-            cost_gold_dragons=Decimal("3705000.00"),
-        )
-        DailyProgress.objects.create(
-            wall_section=section2,
-            date=date(2025, 10, 1),
-            feet_built=Decimal("20.00"),
-            ice_cubic_yards=Decimal("3900.00"),
-            cost_gold_dragons=Decimal("7410000.00"),
-        )
-
-        url = reverse("profile-bulk-cost-overview")
-        response = api_client.get(
-            url,
-            {
-                "profile_ids": f"{profile1.id},{profile2.id}",
-                "start_date": "2025-10-01",
-                "end_date": "2025-10-01",
-            },
-        )
-
-        assert response.status_code == status.HTTP_200_OK
-        assert len(response.data["results"]) == 2
-        profile_ids = {r["profile_id"] for r in response.data["results"]}
-        assert profile_ids == {profile1.id, profile2.id}
-
-    def test_bulk_cost_overview_single_profile(self, api_client: APIClient) -> None:
-        """Test bulk cost overview with single profile."""
-        profile = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-        section = WallSection.objects.create(
-            profile=profile,
-            section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
-        )
-
-        DailyProgress.objects.create(
-            wall_section=section,
-            date=date(2025, 10, 1),
-            feet_built=Decimal("10.00"),
-            ice_cubic_yards=Decimal("1950.00"),
-            cost_gold_dragons=Decimal("3705000.00"),
-        )
-
-        url = reverse("profile-bulk-cost-overview")
-        response = api_client.get(
-            url,
-            {"profile_ids": str(profile.id), "start_date": "2025-10-01", "end_date": "2025-10-01"},
-        )
-
-        assert response.status_code == status.HTTP_200_OK
-        assert len(response.data["results"]) == 1
-        assert response.data["results"][0]["profile_id"] == profile.id
-        assert response.data["results"][0]["total_feet_built"] == "10.00"
-
-    def test_bulk_cost_overview_missing_profile_ids(self, api_client: APIClient) -> None:
-        """Test bulk cost overview without profile_ids parameter returns 400."""
-        url = reverse("profile-bulk-cost-overview")
-        response = api_client.get(url, {"start_date": "2025-10-01", "end_date": "2025-10-01"})
-
-        assert response.status_code == status.HTTP_400_BAD_REQUEST
-
-    def test_bulk_cost_overview_missing_start_date(self, api_client: APIClient) -> None:
-        """Test bulk cost overview without start_date parameter returns 400."""
-        url = reverse("profile-bulk-cost-overview")
-        response = api_client.get(url, {"profile_ids": "1,2", "end_date": "2025-10-01"})
-
-        assert response.status_code == status.HTTP_400_BAD_REQUEST
-
-    def test_bulk_cost_overview_missing_end_date(self, api_client: APIClient) -> None:
-        """Test bulk cost overview without end_date parameter returns 400."""
-        url = reverse("profile-bulk-cost-overview")
-        response = api_client.get(url, {"profile_ids": "1,2", "start_date": "2025-10-01"})
-
-        assert response.status_code == status.HTTP_400_BAD_REQUEST
-
-    def test_create_progress_via_profile_success(self, api_client: APIClient) -> None:
-        """Test creating progress via profile nested endpoint returns 201 with auto-calculated values."""
-        profile = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-        wall_section = WallSection.objects.create(
-            profile=profile,
-            section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
-        )
-
-        url = reverse("profile-create-progress", kwargs={"pk": profile.id})
-        payload = {
-            "wall_section_id": wall_section.id,
-            "date": "2025-10-15",
-            "feet_built": 12.5,
-            "notes": "Clear weather, good progress",
-        }
-
-        response = api_client.post(url, payload, format="json")
-
-        assert response.status_code == status.HTTP_201_CREATED
-        assert "id" in response.data
-        assert response.data["wall_section"] == wall_section.id
-        assert response.data["date"] == "2025-10-15"
-        assert response.data["feet_built"] == "12.50"
-        assert response.data["ice_cubic_yards"] == "2437.50"
-        assert response.data["cost_gold_dragons"] == "4631250.00"
-        assert response.data["notes"] == "Clear weather, good progress"
-        assert "created_at" in response.data
-
-    def test_create_progress_via_profile_validates_wall_section_ownership(self, api_client: APIClient) -> None:
-        """Test creating progress fails when wall_section does not belong to profile."""
-        profile1 = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-        profile2 = Profile.objects.create(name="Eastern Defense", team_lead="Tormund")
-        wall_section = WallSection.objects.create(
-            profile=profile2,
-            section_name="Tower 5-6",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
-        )
-
-        url = reverse("profile-create-progress", kwargs={"pk": profile1.id})
-        payload = {
-            "wall_section_id": wall_section.id,
-            "date": "2025-10-15",
-            "feet_built": 12.5,
-        }
-
-        response = api_client.post(url, payload, format="json")
-
-        assert response.status_code == status.HTTP_400_BAD_REQUEST
-        assert "wall_section_id" in response.data
-
-    def test_create_progress_via_profile_missing_wall_section_id(self, api_client: APIClient) -> None:
-        """Test creating progress without wall_section_id returns 400."""
-        profile = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-
-        url = reverse("profile-create-progress", kwargs={"pk": profile.id})
-        payload = {
-            "date": "2025-10-15",
-            "feet_built": 12.5,
-        }
-
-        response = api_client.post(url, payload, format="json")
-
-        assert response.status_code == status.HTTP_400_BAD_REQUEST
-        assert "wall_section_id" in response.data
-
-    def test_create_progress_via_profile_invalid_date_format(self, api_client: APIClient) -> None:
-        """Test creating progress with invalid date format returns 400."""
-        profile = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-        wall_section = WallSection.objects.create(
-            profile=profile,
-            section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
-        )
-
-        url = reverse("profile-create-progress", kwargs={"pk": profile.id})
-        payload = {
-            "wall_section_id": wall_section.id,
-            "date": "2025/10/15",
-            "feet_built": 12.5,
-        }
-
-        response = api_client.post(url, payload, format="json")
-
-        assert response.status_code == status.HTTP_400_BAD_REQUEST
-        assert "date" in response.data
-
-    def test_create_progress_via_profile_auto_calculates_ice_and_cost(self, api_client: APIClient) -> None:
-        """Test creating progress auto-calculates ice_cubic_yards and cost_gold_dragons."""
-        profile = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-        wall_section = WallSection.objects.create(
-            profile=profile,
-            section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
-        )
-
-        url = reverse("profile-create-progress", kwargs={"pk": profile.id})
-        payload = {
-            "wall_section_id": wall_section.id,
-            "date": "2025-10-15",
-            "feet_built": 10.0,
-        }
-
-        response = api_client.post(url, payload, format="json")
-
-        assert response.status_code == status.HTTP_201_CREATED
-        assert response.data["feet_built"] == "10.00"
-        assert response.data["ice_cubic_yards"] == "1950.00"
-        assert response.data["cost_gold_dragons"] == "3705000.00"

tests/integration/test_wallsection_api.py

@@ -26,16 +26,12 @@ class TestWallSectionAPI:
         payload = {
             "profile": profile["id"],
             "section_name": "Tower 1-2",
-            "start_position": "0.00",
-            "target_length_feet": "500.00",
         }
 
         response = api_client.post(url, payload, format="json")
 
         assert response.status_code == status.HTTP_201_CREATED
         assert response.data["section_name"] == "Tower 1-2"
-        assert response.data["start_position"] == "0.00"
-        assert response.data["target_length_feet"] == "500.00"
         assert response.data["profile"] == profile["id"]
         assert "id" in response.data
         assert "created_at" in response.data
@@ -53,8 +49,6 @@ class TestWallSectionAPI:
         payload = {
             "profile": profile["id"],
             "section_name": "Tower 1-2",
-            "start_position": "0.00",
-            "target_length_feet": "500.00",
         }
 
         api_client.post(url, payload, format="json")
@@ -80,14 +74,10 @@ class TestWallSectionAPI:
         payload1 = {
             "profile": profile1["id"],
             "section_name": "Tower 1-2",
-            "start_position": "0.00",
-            "target_length_feet": "500.00",
         }
         payload2 = {
             "profile": profile2["id"],
             "section_name": "Tower 1-2",
-            "start_position": "0.00",
-            "target_length_feet": "500.00",
         }
 
         response1 = api_client.post(url, payload1, format="json")
@@ -111,8 +101,6 @@ class TestWallSectionAPI:
             {
                 "profile": profile["id"],
                 "section_name": "Tower 1-2",
-                "start_position": "0.00",
-                "target_length_feet": "500.00",
             },
             format="json",
         )
@@ -121,8 +109,6 @@ class TestWallSectionAPI:
             {
                 "profile": profile["id"],
                 "section_name": "Tower 2-3",
-                "start_position": "500.00",
-                "target_length_feet": "600.00",
             },
             format="json",
         )
@@ -153,8 +139,6 @@ class TestWallSectionAPI:
             {
                 "profile": profile1["id"],
                 "section_name": "Tower 1-2",
-                "start_position": "0.00",
-                "target_length_feet": "500.00",
             },
             format="json",
         )
@@ -163,8 +147,6 @@ class TestWallSectionAPI:
             {
                 "profile": profile2["id"],
                 "section_name": "Tower 3-4",
-                "start_position": "0.00",
-                "target_length_feet": "400.00",
             },
             format="json",
         )
@@ -190,8 +172,6 @@ class TestWallSectionAPI:
             {
                 "profile": profile["id"],
                 "section_name": "Tower 1-2",
-                "start_position": "0.00",
-                "target_length_feet": "500.00",
             },
             format="json",
         ).data
@@ -218,8 +198,6 @@ class TestWallSectionAPI:
             {
                 "profile": profile["id"],
                 "section_name": "Tower 1-2",
-                "start_position": "0.00",
-                "target_length_feet": "500.00",
             },
             format="json",
         ).data
@@ -228,14 +206,11 @@ class TestWallSectionAPI:
         updated_payload = {
             "profile": profile["id"],
             "section_name": "Tower 1-2 Extended",
-            "start_position": "0.00",
-            "target_length_feet": "750.00",
         }
         response = api_client.put(detail_url, updated_payload, format="json")
 
         assert response.status_code == status.HTTP_200_OK
         assert response.data["section_name"] == "Tower 1-2 Extended"
-        assert response.data["target_length_feet"] == "750.00"
 
     def test_delete_wall_section(self, api_client: APIClient) -> None:
         """Test deleting a wall section."""
@@ -252,8 +227,6 @@ class TestWallSectionAPI:
             {
                 "profile": profile["id"],
                 "section_name": "Tower 1-2",
-                "start_position": "0.00",
-                "target_length_feet": "500.00",
             },
             format="json",
         ).data
@@ -281,8 +254,6 @@ class TestWallSectionAPI:
             {
                 "profile": profile["id"],
                 "section_name": "Tower 1-2",
-                "start_position": "0.00",
-                "target_length_feet": "500.00",
             },
             format="json",
         ).data
@@ -299,8 +270,6 @@ class TestWallSectionAPI:
         url = reverse("wallsection-list")
         payload = {
             "section_name": "Tower 1-2",
-            "start_position": "0.00",
-            "target_length_feet": "500.00",
         }
 
         response = api_client.post(url, payload, format="json")
@@ -320,8 +289,6 @@ class TestWallSectionAPI:
         url = reverse("wallsection-list")
         payload = {
             "profile": profile["id"],
-            "start_position": "0.00",
-            "target_length_feet": "500.00",
         }
 
         response = api_client.post(url, payload, format="json")

tests/unit/test_aggregators.py

@@ -1,97 +0,0 @@
-"""Unit tests for CostAggregatorService."""
-
-from __future__ import annotations
-
-from datetime import date
-from decimal import Decimal
-
-import pytest
-
-from apps.profiles.models import DailyProgress, Profile, WallSection
-from apps.profiles.services.aggregators import CostAggregatorService
-
-
-@pytest.mark.django_db
-class TestCostAggregatorService:
-    """Test CostAggregatorService cost calculations."""
-
-    def test_calculate_multi_profile_costs_single_profile(self) -> None:
-        """Test calculating costs for a single profile."""
-        profile = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-        section = WallSection.objects.create(
-            profile=profile,
-            section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
-        )
-
-        DailyProgress.objects.create(
-            wall_section=section,
-            date=date(2025, 10, 1),
-            feet_built=Decimal("10.00"),
-            ice_cubic_yards=Decimal("1950.00"),
-            cost_gold_dragons=Decimal("3705000.00"),
-        )
-
-        aggregator = CostAggregatorService()
-        results = aggregator.calculate_multi_profile_costs([profile.id], "2025-10-01", "2025-10-01")
-        aggregator.shutdown()
-
-        assert len(results) == 1
-        assert results[0]["profile_id"] == profile.id
-        assert results[0]["total_feet_built"] == "10.00"
-        assert results[0]["total_ice_cubic_yards"] == "1950.00"
-        assert results[0]["total_cost_gold_dragons"] == "3705000.00"
-
-    def test_calculate_multi_profile_costs_multiple_profiles(self) -> None:
-        """Test calculating costs for multiple profiles."""
-        profile1 = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-        profile2 = Profile.objects.create(name="Eastern Defense", team_lead="Tormund")
-        section1 = WallSection.objects.create(
-            profile=profile1,
-            section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
-        )
-        section2 = WallSection.objects.create(
-            profile=profile2,
-            section_name="Tower 5-6",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
-        )
-
-        DailyProgress.objects.create(
-            wall_section=section1,
-            date=date(2025, 10, 1),
-            feet_built=Decimal("10.00"),
-            ice_cubic_yards=Decimal("1950.00"),
-            cost_gold_dragons=Decimal("3705000.00"),
-        )
-        DailyProgress.objects.create(
-            wall_section=section2,
-            date=date(2025, 10, 1),
-            feet_built=Decimal("20.00"),
-            ice_cubic_yards=Decimal("3900.00"),
-            cost_gold_dragons=Decimal("7410000.00"),
-        )
-
-        aggregator = CostAggregatorService()
-        results = aggregator.calculate_multi_profile_costs([profile1.id, profile2.id], "2025-10-01", "2025-10-01")
-        aggregator.shutdown()
-
-        assert len(results) == 2
-        profile_ids = {r["profile_id"] for r in results}
-        assert profile_ids == {profile1.id, profile2.id}
-
-    def test_calculate_multi_profile_costs_no_data(self) -> None:
-        """Test calculating costs when no progress data exists."""
-        profile = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-
-        aggregator = CostAggregatorService()
-        results = aggregator.calculate_multi_profile_costs([profile.id], "2025-10-01", "2025-10-01")
-        aggregator.shutdown()
-
-        assert len(results) == 1
-        assert results[0]["total_feet_built"] == "0.00"
-        assert results[0]["total_ice_cubic_yards"] == "0.00"
-        assert results[0]["total_cost_gold_dragons"] == "0.00"

tests/unit/test_calculators.py

@@ -1,63 +0,0 @@
-"""Unit tests for calculator services."""
-
-from __future__ import annotations
-
-from decimal import Decimal
-
-from apps.profiles.services.calculators import IceUsageCalculator
-
-
-class TestIceUsageCalculator:
-    """Test IceUsageCalculator service."""
-
-    def test_calculate_ice_usage_for_10_feet(self) -> None:
-        """Test ice usage calculation for 10 feet built."""
-        calculator = IceUsageCalculator()
-        result = calculator.calculate_ice_usage(Decimal("10.00"))
-
-        # 10 feet × 195 yd³/ft = 1950 yd³
-        assert result == Decimal("1950.00")
-
-    def test_calculate_ice_usage_for_zero_feet(self) -> None:
-        """Test ice usage calculation for zero feet built."""
-        calculator = IceUsageCalculator()
-        result = calculator.calculate_ice_usage(Decimal("0.00"))
-
-        assert result == Decimal("0.00")
-
-    def test_calculate_ice_usage_for_fractional_feet(self) -> None:
-        """Test ice usage calculation for fractional feet."""
-        calculator = IceUsageCalculator()
-        result = calculator.calculate_ice_usage(Decimal("12.5"))
-
-        # 12.5 feet × 195 yd³/ft = 2437.5 yd³
-        assert result == Decimal("2437.50")
-
-    def test_calculate_daily_cost_from_ice_usage(self) -> None:
-        """Test daily cost calculation from ice usage."""
-        calculator = IceUsageCalculator()
-        ice_cubic_yards = Decimal("1950.00")
-        result = calculator.calculate_daily_cost(ice_cubic_yards)
-
-        # 1950 yd³ × 1900 GD/yd³ = 3,705,000 GD
-        assert result == Decimal("3705000.00")
-
-    def test_calculate_daily_cost_for_zero_ice(self) -> None:
-        """Test daily cost calculation for zero ice usage."""
-        calculator = IceUsageCalculator()
-        result = calculator.calculate_daily_cost(Decimal("0.00"))
-
-        assert result == Decimal("0.00")
-
-    def test_full_calculation_pipeline(self) -> None:
-        """Test complete calculation from feet to cost."""
-        calculator = IceUsageCalculator()
-        feet_built = Decimal("12.5")
-
-        ice_usage = calculator.calculate_ice_usage(feet_built)
-        daily_cost = calculator.calculate_daily_cost(ice_usage)
-
-        # 12.5 feet × 195 yd³/ft = 2437.5 yd³
-        assert ice_usage == Decimal("2437.50")
-        # 2437.5 yd³ × 1900 GD/yd³ = 4,631,250 GD
-        assert daily_cost == Decimal("4631250.00")

tests/unit/test_models.py

@@ -8,8 +8,8 @@ from decimal import Decimal
 import pytest
 from django.db import IntegrityError
 
+from apps.profiles.constants import COST_PER_CUBIC_YARD, ICE_PER_FOOT
 from apps.profiles.models import DailyProgress, Profile, WallSection
-from apps.profiles.repositories import DailyProgressRepository
 
 
 @pytest.mark.django_db
@@ -55,15 +55,11 @@ class TestWallSectionModel:
         wall_section = WallSection.objects.create(
             profile=profile,
             section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
         )
 
         assert wall_section.id is not None
         assert wall_section.profile == profile
         assert wall_section.section_name == "Tower 1-2"
-        assert wall_section.start_position == Decimal("0.00")
-        assert wall_section.target_length_feet == Decimal("500.00")
 
     def test_wall_section_str_representation(self) -> None:
         """Test wall section string representation."""
@@ -71,8 +67,6 @@ class TestWallSectionModel:
         wall_section = WallSection.objects.create(
             profile=profile,
             section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
         )
 
         assert str(wall_section) == "Tower 1-2 (Northern Watch)"
@@ -88,13 +82,11 @@ class TestDailyProgressModel:
         wall_section = WallSection.objects.create(
             profile=profile,
             section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
         )
 
         feet_built = Decimal("10.00")
-        ice_cubic_yards = feet_built * DailyProgress.ICE_PER_FOOT  # 10 × 195 = 1950
-        cost_gold_dragons = ice_cubic_yards * DailyProgress.COST_PER_CUBIC_YARD  # 1950 × 1900 = 3,705,000
+        ice_cubic_yards = feet_built * ICE_PER_FOOT  # 10 × 195 = 1950
+        cost_gold_dragons = ice_cubic_yards * COST_PER_CUBIC_YARD  # 1950 × 1900 = 3,705,000
 
         progress = DailyProgress.objects.create(
             wall_section=wall_section,
@@ -113,8 +105,6 @@ class TestDailyProgressModel:
         wall_section = WallSection.objects.create(
             profile=profile,
             section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
         )
 
         DailyProgress.objects.create(
@@ -140,8 +130,6 @@ class TestDailyProgressModel:
         wall_section = WallSection.objects.create(
             profile=profile,
             section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
         )
 
         progress = DailyProgress.objects.create(
@@ -153,229 +141,3 @@ class TestDailyProgressModel:
         )
 
         assert str(progress) == "Tower 1-2: 10.00 ft on 2025-10-20"
-
-
-@pytest.mark.django_db
-class TestDailyProgressRepository:
-    """Test DailyProgressRepository data access methods."""
-
-    def test_get_by_date_returns_progress_for_profile_and_date(self) -> None:
-        """Test retrieving all progress records for a profile on a specific date."""
-        repo = DailyProgressRepository()
-        profile = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-        section1 = WallSection.objects.create(
-            profile=profile,
-            section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
-        )
-        section2 = WallSection.objects.create(
-            profile=profile,
-            section_name="Tower 2-3",
-            start_position=Decimal("500.00"),
-            target_length_feet=Decimal("500.00"),
-        )
-
-        target_date = date(2025, 10, 15)
-        DailyProgress.objects.create(
-            wall_section=section1,
-            date=target_date,
-            feet_built=Decimal("12.50"),
-            ice_cubic_yards=Decimal("2437.50"),
-            cost_gold_dragons=Decimal("4631250.00"),
-        )
-        DailyProgress.objects.create(
-            wall_section=section2,
-            date=target_date,
-            feet_built=Decimal("16.25"),
-            ice_cubic_yards=Decimal("3168.75"),
-            cost_gold_dragons=Decimal("6020625.00"),
-        )
-
-        results = repo.get_by_date(profile.id, target_date)
-
-        assert results.count() == 2
-        assert all(r.date == target_date for r in results)
-        assert all(r.wall_section.profile_id == profile.id for r in results)
-
-    def test_get_by_date_returns_empty_when_no_data(self) -> None:
-        """Test get_by_date returns empty queryset when no progress exists."""
-        repo = DailyProgressRepository()
-        profile = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-        target_date = date(2025, 10, 15)
-
-        results = repo.get_by_date(profile.id, target_date)
-
-        assert results.count() == 0
-
-    def test_get_by_date_filters_by_profile(self) -> None:
-        """Test get_by_date only returns progress for specified profile."""
-        repo = DailyProgressRepository()
-        profile1 = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-        profile2 = Profile.objects.create(name="Eastern Defense", team_lead="Tormund")
-        section1 = WallSection.objects.create(
-            profile=profile1,
-            section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
-        )
-        section2 = WallSection.objects.create(
-            profile=profile2,
-            section_name="Tower 5-6",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
-        )
-
-        target_date = date(2025, 10, 15)
-        DailyProgress.objects.create(
-            wall_section=section1,
-            date=target_date,
-            feet_built=Decimal("12.50"),
-            ice_cubic_yards=Decimal("2437.50"),
-            cost_gold_dragons=Decimal("4631250.00"),
-        )
-        DailyProgress.objects.create(
-            wall_section=section2,
-            date=target_date,
-            feet_built=Decimal("20.00"),
-            ice_cubic_yards=Decimal("3900.00"),
-            cost_gold_dragons=Decimal("7410000.00"),
-        )
-
-        results = repo.get_by_date(profile1.id, target_date)
-
-        assert results.count() == 1
-        first_result = results.first()
-        assert first_result is not None
-        assert first_result.wall_section.profile_id == profile1.id
-
-    def test_get_aggregates_by_profile_returns_summary_stats(self) -> None:
-        """Test aggregated statistics for a profile within date range."""
-        repo = DailyProgressRepository()
-        profile = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-        section = WallSection.objects.create(
-            profile=profile,
-            section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
-        )
-
-        DailyProgress.objects.create(
-            wall_section=section,
-            date=date(2025, 10, 1),
-            feet_built=Decimal("10.00"),
-            ice_cubic_yards=Decimal("1950.00"),
-            cost_gold_dragons=Decimal("3705000.00"),
-        )
-        DailyProgress.objects.create(
-            wall_section=section,
-            date=date(2025, 10, 2),
-            feet_built=Decimal("15.00"),
-            ice_cubic_yards=Decimal("2925.00"),
-            cost_gold_dragons=Decimal("5557500.00"),
-        )
-        DailyProgress.objects.create(
-            wall_section=section,
-            date=date(2025, 10, 3),
-            feet_built=Decimal("20.00"),
-            ice_cubic_yards=Decimal("3900.00"),
-            cost_gold_dragons=Decimal("7410000.00"),
-        )
-
-        result = repo.get_aggregates_by_profile(profile.id, date(2025, 10, 1), date(2025, 10, 3))
-
-        assert result["total_feet"] == Decimal("45.00")
-        assert result["total_ice"] == Decimal("8775.00")
-        assert result["total_cost"] == Decimal("16672500.00")
-        assert result["avg_feet"] == Decimal("15.00")
-        assert result["record_count"] == 3
-
-    def test_get_aggregates_by_profile_filters_date_range(self) -> None:
-        """Test aggregates only include data within specified date range."""
-        repo = DailyProgressRepository()
-        profile = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-        section = WallSection.objects.create(
-            profile=profile,
-            section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
-        )
-
-        DailyProgress.objects.create(
-            wall_section=section,
-            date=date(2025, 9, 30),
-            feet_built=Decimal("10.00"),
-            ice_cubic_yards=Decimal("1950.00"),
-            cost_gold_dragons=Decimal("3705000.00"),
-        )
-        DailyProgress.objects.create(
-            wall_section=section,
-            date=date(2025, 10, 1),
-            feet_built=Decimal("15.00"),
-            ice_cubic_yards=Decimal("2925.00"),
-            cost_gold_dragons=Decimal("5557500.00"),
-        )
-        DailyProgress.objects.create(
-            wall_section=section,
-            date=date(2025, 10, 4),
-            feet_built=Decimal("20.00"),
-            ice_cubic_yards=Decimal("3900.00"),
-            cost_gold_dragons=Decimal("7410000.00"),
-        )
-
-        result = repo.get_aggregates_by_profile(profile.id, date(2025, 10, 1), date(2025, 10, 3))
-
-        assert result["total_feet"] == Decimal("15.00")
-        assert result["record_count"] == 1
-
-    def test_get_aggregates_by_profile_returns_zeros_when_no_data(self) -> None:
-        """Test aggregates return explicit zeros when no data exists."""
-        repo = DailyProgressRepository()
-        profile = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-
-        result = repo.get_aggregates_by_profile(profile.id, date(2025, 10, 1), date(2025, 10, 15))
-
-        assert result["total_feet"] == Decimal("0")
-        assert result["total_ice"] == Decimal("0")
-        assert result["total_cost"] == Decimal("0")
-        assert result["avg_feet"] == Decimal("0")
-        assert result["record_count"] == 0
-
-    def test_get_aggregates_by_profile_filters_by_profile(self) -> None:
-        """Test aggregates only include data for specified profile."""
-        repo = DailyProgressRepository()
-        profile1 = Profile.objects.create(name="Northern Watch", team_lead="Jon Snow")
-        profile2 = Profile.objects.create(name="Eastern Defense", team_lead="Tormund")
-        section1 = WallSection.objects.create(
-            profile=profile1,
-            section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
-        )
-        section2 = WallSection.objects.create(
-            profile=profile2,
-            section_name="Tower 5-6",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
-        )
-
-        target_date = date(2025, 10, 1)
-        DailyProgress.objects.create(
-            wall_section=section1,
-            date=target_date,
-            feet_built=Decimal("10.00"),
-            ice_cubic_yards=Decimal("1950.00"),
-            cost_gold_dragons=Decimal("3705000.00"),
-        )
-        DailyProgress.objects.create(
-            wall_section=section2,
-            date=target_date,
-            feet_built=Decimal("50.00"),
-            ice_cubic_yards=Decimal("9750.00"),
-            cost_gold_dragons=Decimal("18525000.00"),
-        )
-
-        result = repo.get_aggregates_by_profile(profile1.id, target_date, target_date)
-
-        assert result["total_feet"] == Decimal("10.00")
-        assert result["record_count"] == 1

tests/unit/test_serializers.py

@@ -22,8 +22,6 @@ class TestDailyProgressSerializer:
         wall_section = WallSection.objects.create(
             profile=profile,
             section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
         )
 
         serializer = DailyProgressSerializer(
@@ -51,8 +49,6 @@ class TestDailyProgressSerializer:
         wall_section = WallSection.objects.create(
             profile=profile,
             section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
         )
 
         serializer = DailyProgressSerializer(
@@ -82,8 +78,6 @@ class TestDailyProgressSerializer:
         wall_section = WallSection.objects.create(
             profile=profile,
             section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
         )
 
         serializer = DailyProgressSerializer(
@@ -107,8 +101,6 @@ class TestDailyProgressSerializer:
         wall_section = WallSection.objects.create(
             profile=profile,
             section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
         )
 
         serializer = DailyProgressSerializer(
@@ -131,8 +123,6 @@ class TestDailyProgressSerializer:
         wall_section = WallSection.objects.create(
             profile=profile,
             section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
         )
 
         # Try to override calculated fields
@@ -159,8 +149,6 @@ class TestDailyProgressSerializer:
         wall_section = WallSection.objects.create(
             profile=profile,
             section_name="Tower 1-2",
-            start_position=Decimal("0.00"),
-            target_length_feet=Decimal("500.00"),
         )
 
         # Create first progress entry