MVP UI simplification: single room, 4 tabs

- Remove Project Info tab and ProjectFormData
- Change from multi-room to single room (session.room)
- Move facility_classification and construction_era to RoomFormData
- Simplify from 5 tabs to 4: Room, Images, Observations, Results
- Delete all test files (testing on HuggingFace due to GPU/ChromaDB)
- Update pipeline files to use session.room
- Update samples and documentation

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

CLAUDE.md

@@ -33,20 +33,22 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## UI Components (Gradio 6.x)
 
+**MVP Simplification:** 4 tabs (Room Assessment, Images, Observations, Generate Results).
+Single-room workflow - no project-level or multi-room support.
+
 The frontend uses optimized input components:
 
 | Field | Component | Notes |
 |-------|-----------|-------|
-| State | `gr.Dropdown` | 50 US states + DC + territories |
-| Dates | `gr.DateTime` | Calendar picker, no time selection |
-| ZIP Code | `gr.Textbox` + blur validation | Real-time format validation |
-| Credentials | `gr.Dropdown(multiselect=True)` | CIH, CSP, PE, etc. |
-| Floor | `gr.Dropdown` | Basement through Roof |
+| Room Name | `gr.Textbox` | Required field |
+| Dimensions | `gr.Number` | Length, Width in feet |
 | Ceiling Height | `gr.Dropdown` + custom option | 8-20 ft presets |
-| Image Upload | `gr.Files(file_count="multiple")` | Batch upload support |
+| Facility Classification | `gr.Radio` | operational, non-operational, public-childcare |
+| Construction Era | `gr.Radio` | pre-1980, 1980-2000, post-2000 |
+| Image Upload | `gr.Files(file_count="multiple")` | Batch upload, auto-assigned to room |
 
 **Keyboard Shortcuts:**
-- `Ctrl+1` through `Ctrl+5`: Navigate between tabs
+- `Ctrl+1` through `Ctrl+4`: Navigate between tabs
 
 ## Development Commands
 
@@ -63,8 +65,8 @@ python app.py
 # Recommended tooling (install as dev dependencies)
 ruff check .              # Linting
 ruff format .             # Formatting
-pytest tests/ -v          # Testing
 mypy .                    # Type checking
+# Note: Tests removed - testing occurs on HuggingFace due to GPU/ChromaDB requirements
 ```
 
 ## Architecture
@@ -85,10 +87,10 @@ mypy .                    # Type checking
 ├── rag/                   # Chunking, vectorstore, retrieval
 ├── schemas/               # Pydantic input/output models
 ├── pipeline/              # Main processing logic
-├── ui/                    # Gradio UI components
+├── ui/                    # Gradio UI components (4 tabs: room, images, observations, results)
 ├── RAG-KB/                # Knowledge base source files
 ├── chroma_db/             # ChromaDB persistence (generated)
-└── tests/
+└── sample_images/         # Sample fire damage images for testing
 ```
 
 ## Domain Knowledge

app.py

@@ -1,6 +1,7 @@
 """FDAM AI Pipeline - Fire Damage Assessment Methodology v4.0.1
 
 Main Gradio application entry point with session state and tab validation.
+MVP Simplification: Single room, 4 tabs (Room, Images, Observations, Results).
 """
 
 import gradio as gr
@@ -17,18 +18,18 @@ logger = logging.getLogger(__name__)
 from models.loader import get_models
 from ui.state import SessionState, create_new_session, session_to_json, session_from_json
 from ui.storage import get_head_html
-from ui.tabs import project, rooms, images, observations, results
+from ui.tabs import room, images, observations, results
 from ui import samples
 
 
-# Keyboard shortcuts JavaScript (Ctrl+1-5 for tab navigation)
+# Keyboard shortcuts JavaScript (Ctrl+1-4 for tab navigation)
 KEYBOARD_JS = """
 <script>
 document.addEventListener('keydown', (e) => {
-    if (e.ctrlKey && e.key >= '1' && e.key <= '5') {
+    if (e.ctrlKey && e.key >= '1' && e.key <= '4') {
         e.preventDefault();
         const tabIds = [
-            'tab-project-button', 'tab-rooms-button', 'tab-images-button',
+            'tab-room-button', 'tab-images-button',
             'tab-observations-button', 'tab-results-button'
         ];
         const tabIndex = parseInt(e.key) - 1;
@@ -73,7 +74,7 @@ def create_app() -> gr.Blocks:
             # FDAM AI Pipeline
             ## Fire Damage Assessment Methodology v4.0.1
 
-            Upload images and project information to generate a professional
+            Upload images and room information to generate a professional
             Cleaning Specification / Scope of Work.
             """
         )
@@ -105,30 +106,25 @@ def create_app() -> gr.Blocks:
         # Tab navigation (elem_id for stable JS selectors - Gradio appends "-button" for tab buttons)
         # Store Tab references for individual select event handlers
         with gr.Tabs() as tabs:
-            # Tab 1: Project Information
-            tab_project = gr.Tab("1. Project Info", id=0, elem_id="tab-project")
-            with tab_project:
-                tab1 = project.create_tab()
-
-            # Tab 2: Building/Rooms
-            tab_rooms = gr.Tab("2. Building/Rooms", id=1, elem_id="tab-rooms")
-            with tab_rooms:
-                tab2 = rooms.create_tab()
-
-            # Tab 3: Images
-            tab_images = gr.Tab("3. Images", id=2, elem_id="tab-images")
+            # Tab 1: Room Assessment
+            tab_room = gr.Tab("1. Room Assessment", id=0, elem_id="tab-room")
+            with tab_room:
+                tab1 = room.create_tab()
+
+            # Tab 2: Images
+            tab_images = gr.Tab("2. Images", id=1, elem_id="tab-images")
             with tab_images:
-                tab3 = images.create_tab()
+                tab2 = images.create_tab()
 
-            # Tab 4: Observations
-            tab_observations = gr.Tab("4. Observations", id=3, elem_id="tab-observations")
+            # Tab 3: Observations
+            tab_observations = gr.Tab("3. Observations", id=2, elem_id="tab-observations")
             with tab_observations:
-                tab4 = observations.create_tab()
+                tab3 = observations.create_tab()
 
-            # Tab 5: Generate Results
-            tab_results = gr.Tab("5. Generate Results", id=4, elem_id="tab-results")
+            # Tab 4: Generate Results
+            tab_results = gr.Tab("4. Generate Results", id=3, elem_id="tab-results")
             with tab_results:
-                tab5 = results.create_tab()
+                tab4 = results.create_tab()
 
         # --- Event Handlers ---
 
@@ -139,7 +135,7 @@ def create_app() -> gr.Blocks:
                 # Empty selection, do nothing
                 return (
                     current_session,  # session_state unchanged
-                    *project.load_form_from_session(current_session),  # 12 form values
+                    *room.load_from_session(current_session),  # room form values
                     gr.update(),  # tabs unchanged
                     "",  # clear status
                     "",  # reset dropdown
@@ -150,7 +146,7 @@ def create_app() -> gr.Blocks:
             if not new_session:
                 return (
                     current_session,
-                    *project.load_form_from_session(current_session),
+                    *room.load_from_session(current_session),
                     gr.update(),
                     '<span style="color: #c62828;">Error: Sample not found</span>',
                     "",
@@ -161,11 +157,11 @@ def create_app() -> gr.Blocks:
             name = scenario.name if scenario else scenario_id
 
             # Load form values from new session
-            form_values = project.load_form_from_session(new_session)
+            form_values = room.load_from_session(new_session)
 
             return (
                 new_session,  # updated session_state
-                *form_values,  # 12 form values for Tab 1
+                *form_values,  # room form values for Tab 1
                 gr.update(selected=0),  # switch to Tab 1 (Gradio 6.x syntax)
                 f'<span style="color: #2e7d32;">Loaded sample: {name}</span>',
                 "",  # reset dropdown to empty
@@ -176,42 +172,82 @@ def create_app() -> gr.Blocks:
             inputs=[sample_dropdown, session_state],
             outputs=[
                 session_state,
-                tab1["project_name"],
-                tab1["address"],
-                tab1["city"],
-                tab1["state"],
-                tab1["zip_code"],
-                tab1["client_name"],
-                tab1["fire_date"],
-                tab1["assessment_date"],
+                tab1["room_name"],
+                tab1["room_length"],
+                tab1["room_width"],
+                tab1["room_height_preset"],
+                tab1["room_height_custom"],
+                tab1["floor_area"],
+                tab1["room_volume"],
                 tab1["facility_classification"],
                 tab1["construction_era"],
-                tab1["assessor_name"],
-                tab1["assessor_credentials"],
                 tabs,
                 sample_status,
                 sample_dropdown,
             ],
         )
 
-        # Tab 1: Project Info
+        # Tab 1: Room Assessment
+
+        # Save room data on field changes
+        def on_room_field_change(
+            session: SessionState,
+            name: str,
+            length: float | None,
+            width: float | None,
+            height_preset: int | None,
+            height_custom: float | None,
+            facility_classification: str,
+            construction_era: str,
+        ):
+            """Save room data and update calculated values."""
+            updated_session = room.save_room_to_session(
+                session, name, length, width, height_preset, height_custom,
+                facility_classification, construction_era
+            )
+            floor_area, volume = room.update_calculated_values(
+                length, width, height_preset, height_custom
+            )
+            return updated_session, floor_area, volume
+
+        # Wire up all room input fields to save on change
+        room_inputs = [
+            session_state,
+            tab1["room_name"],
+            tab1["room_length"],
+            tab1["room_width"],
+            tab1["room_height_preset"],
+            tab1["room_height_custom"],
+            tab1["facility_classification"],
+            tab1["construction_era"],
+        ]
+        room_outputs = [session_state, tab1["floor_area"], tab1["room_volume"]]
+
+        for input_component in [
+            tab1["room_name"],
+            tab1["room_length"],
+            tab1["room_width"],
+            tab1["room_height_preset"],
+            tab1["room_height_custom"],
+            tab1["facility_classification"],
+            tab1["construction_era"],
+        ]:
+            input_component.change(
+                fn=on_room_field_change,
+                inputs=room_inputs,
+                outputs=room_outputs,
+            )
+
+        # Show/hide custom height input based on preset selection
+        tab1["room_height_preset"].change(
+            fn=room.on_height_preset_change,
+            inputs=[tab1["room_height_preset"]],
+            outputs=[tab1["room_height_custom"]],
+        )
+
         tab1["validate_btn"].click(
-            fn=project.validate_and_continue,
-            inputs=[
-                session_state,
-                tab1["project_name"],
-                tab1["address"],
-                tab1["city"],
-                tab1["state"],
-                tab1["zip_code"],
-                tab1["client_name"],
-                tab1["fire_date"],
-                tab1["assessment_date"],
-                tab1["facility_classification"],
-                tab1["construction_era"],
-                tab1["assessor_name"],
-                tab1["assessor_credentials"],
-            ],
+            fn=room.validate_and_continue,
+            inputs=[session_state],
             outputs=[
                 session_state,
                 tab1["validation_status"],
@@ -219,88 +255,56 @@ def create_app() -> gr.Blocks:
             ],
         )
 
-        # ZIP code validation on blur
-        tab1["zip_code"].blur(
-            fn=project.validate_zip_format,
-            inputs=[tab1["zip_code"]],
-            outputs=[tab1["zip_validation"]],
-        )
-
-        # Tab 2: Building/Rooms
-        tab2["add_room_btn"].click(
-            fn=rooms.add_room,
+        # Tab 2: Images
+        tab2["add_image_btn"].click(
+            fn=images.add_image,
             inputs=[
                 session_state,
-                tab2["room_name"],
-                tab2["room_floor"],
-                tab2["room_length"],
-                tab2["room_width"],
-                tab2["room_height_preset"],
-                tab2["room_height_custom"],
+                tab2["image_upload"],
+                tab2["image_description"],
             ],
             outputs=[
                 session_state,
-                tab2["rooms_table"],
+                tab2["images_gallery"],
                 tab2["validation_status"],
-                tab2["room_count"],
-                tab2["total_area"],
-                tab2["total_volume"],
-                tab2["room_name"],
-                tab2["room_floor"],
-                tab2["room_length"],
-                tab2["room_width"],
-                tab2["room_height_preset"],
-                tab2["room_height_custom"],
+                tab2["image_count"],
+                tab2["image_upload"],
+                tab2["image_description"],
             ],
         )
 
-        # Show/hide custom height input based on preset selection
-        tab2["room_height_preset"].change(
-            fn=rooms.on_height_preset_change,
-            inputs=[tab2["room_height_preset"]],
-            outputs=[tab2["room_height_custom"]],
-        )
-
-        tab2["clear_form_btn"].click(
-            fn=lambda: ("", None, None, None, None, None),
+        tab2["clear_upload_btn"].click(
+            fn=lambda: (None, ""),
             outputs=[
-                tab2["room_name"],
-                tab2["room_floor"],
-                tab2["room_length"],
-                tab2["room_width"],
-                tab2["room_height_preset"],
-                tab2["room_height_custom"],
+                tab2["image_upload"],
+                tab2["image_description"],
             ],
         )
 
         tab2["remove_last_btn"].click(
-            fn=rooms.remove_last_room,
+            fn=images.remove_last_image,
             inputs=[session_state],
             outputs=[
                 session_state,
-                tab2["rooms_table"],
+                tab2["images_gallery"],
                 tab2["validation_status"],
-                tab2["room_count"],
-                tab2["total_area"],
-                tab2["total_volume"],
+                tab2["image_count"],
             ],
         )
 
         tab2["clear_all_btn"].click(
-            fn=rooms.clear_all_rooms,
+            fn=images.clear_all_images,
             inputs=[session_state],
             outputs=[
                 session_state,
-                tab2["rooms_table"],
+                tab2["images_gallery"],
                 tab2["validation_status"],
-                tab2["room_count"],
-                tab2["total_area"],
-                tab2["total_volume"],
+                tab2["image_count"],
             ],
         )
 
         tab2["validate_btn"].click(
-            fn=rooms.validate_and_continue,
+            fn=images.validate_and_continue,
             inputs=[session_state],
             outputs=[
                 session_state,
@@ -314,59 +318,27 @@ def create_app() -> gr.Blocks:
             outputs=[tabs],
         )
 
-        # Tab 3: Images
-        tab3["add_image_btn"].click(
-            fn=images.add_image,
+        # Tab 3: Observations
+        tab3["validate_btn"].click(
+            fn=observations.validate_and_continue,
             inputs=[
                 session_state,
-                tab3["image_upload"],
-                tab3["room_select"],
-                tab3["image_description"],
-            ],
-            outputs=[
-                session_state,
-                tab3["images_gallery"],
-                tab3["validation_status"],
-                tab3["image_count"],
-                tab3["image_upload"],
-                tab3["image_description"],
-                tab3["room_select"],
-            ],
-        )
-
-        tab3["clear_upload_btn"].click(
-            fn=lambda: (None, ""),
-            outputs=[
-                tab3["image_upload"],
-                tab3["image_description"],
+                tab3["smoke_odor"],
+                tab3["odor_intensity"],
+                tab3["visible_soot"],
+                tab3["soot_description"],
+                tab3["large_char"],
+                tab3["char_density"],
+                tab3["ash_residue"],
+                tab3["ash_description"],
+                tab3["surface_discoloration"],
+                tab3["discoloration_description"],
+                tab3["dust_interference"],
+                tab3["dust_notes"],
+                tab3["wildfire_indicators"],
+                tab3["wildfire_notes"],
+                tab3["additional_notes"],
             ],
-        )
-
-        tab3["remove_last_btn"].click(
-            fn=images.remove_last_image,
-            inputs=[session_state],
-            outputs=[
-                session_state,
-                tab3["images_gallery"],
-                tab3["validation_status"],
-                tab3["image_count"],
-            ],
-        )
-
-        tab3["clear_all_btn"].click(
-            fn=images.clear_all_images,
-            inputs=[session_state],
-            outputs=[
-                session_state,
-                tab3["images_gallery"],
-                tab3["validation_status"],
-                tab3["image_count"],
-            ],
-        )
-
-        tab3["validate_btn"].click(
-            fn=images.validate_and_continue,
-            inputs=[session_state],
             outputs=[
                 session_state,
                 tab3["validation_status"],
@@ -379,72 +351,39 @@ def create_app() -> gr.Blocks:
             outputs=[tabs],
         )
 
-        # Tab 4: Observations
-        tab4["validate_btn"].click(
-            fn=observations.validate_and_continue,
-            inputs=[
-                session_state,
-                tab4["smoke_odor"],
-                tab4["odor_intensity"],
-                tab4["visible_soot"],
-                tab4["soot_description"],
-                tab4["large_char"],
-                tab4["char_density"],
-                tab4["ash_residue"],
-                tab4["ash_description"],
-                tab4["surface_discoloration"],
-                tab4["discoloration_description"],
-                tab4["dust_interference"],
-                tab4["dust_notes"],
-                tab4["wildfire_indicators"],
-                tab4["wildfire_notes"],
-                tab4["additional_notes"],
-            ],
-            outputs=[
-                session_state,
-                tab4["validation_status"],
-                tabs,
-            ],
-        )
-
-        tab4["back_btn"].click(
-            fn=lambda: gr.update(selected=2),
-            outputs=[tabs],
-        )
-
-        # Tab 5: Generate Results
-        tab5["generate_btn"].click(
+        # Tab 4: Generate Results
+        tab4["generate_btn"].click(
             fn=results.generate_assessment,
             inputs=[session_state],
             outputs=[
                 session_state,
-                tab5["processing_status"],
-                tab5["progress_html"],
-                tab5["annotated_gallery"],
-                tab5["stats_output"],
-                tab5["sow_output"],
-                tab5["download_md"],
-                tab5["download_pdf"],
+                tab4["processing_status"],
+                tab4["progress_html"],
+                tab4["annotated_gallery"],
+                tab4["stats_output"],
+                tab4["sow_output"],
+                tab4["download_md"],
+                tab4["download_pdf"],
             ],
         )
 
-        tab5["regenerate_btn"].click(
+        tab4["regenerate_btn"].click(
             fn=results.generate_assessment,
             inputs=[session_state],
             outputs=[
                 session_state,
-                tab5["processing_status"],
-                tab5["progress_html"],
-                tab5["annotated_gallery"],
-                tab5["stats_output"],
-                tab5["sow_output"],
-                tab5["download_md"],
-                tab5["download_pdf"],
+                tab4["processing_status"],
+                tab4["progress_html"],
+                tab4["annotated_gallery"],
+                tab4["stats_output"],
+                tab4["sow_output"],
+                tab4["download_md"],
+                tab4["download_pdf"],
             ],
         )
 
-        tab5["back_btn"].click(
-            fn=lambda: gr.update(selected=3),
+        tab4["back_btn"].click(
+            fn=lambda: gr.update(selected=2),
             outputs=[tabs],
         )
 
@@ -452,84 +391,67 @@ def create_app() -> gr.Blocks:
         # Using Tab.select instead of Tabs.select because Tabs.select doesn't fire in Gradio 6.x
         # See: https://github.com/gradio-app/gradio/issues/7189
 
-        # Tab 1 (Project): Load project form fields when selected
-        tab_project.select(
-            fn=project.load_form_from_session,
+        # Tab 1 (Room): Load room form fields when selected
+        tab_room.select(
+            fn=room.load_from_session,
             inputs=[session_state],
             outputs=[
-                tab1["project_name"],
-                tab1["address"],
-                tab1["city"],
-                tab1["state"],
-                tab1["zip_code"],
-                tab1["client_name"],
-                tab1["fire_date"],
-                tab1["assessment_date"],
+                tab1["room_name"],
+                tab1["room_length"],
+                tab1["room_width"],
+                tab1["room_height_preset"],
+                tab1["room_height_custom"],
+                tab1["floor_area"],
+                tab1["room_volume"],
                 tab1["facility_classification"],
                 tab1["construction_era"],
-                tab1["assessor_name"],
-                tab1["assessor_credentials"],
-            ],
-        )
-
-        # Tab 2 (Rooms): Load room table and stats when selected
-        tab_rooms.select(
-            fn=rooms.load_from_session,
-            inputs=[session_state],
-            outputs=[
-                tab2["rooms_table"],
-                tab2["room_count"],
-                tab2["total_area"],
-                tab2["total_volume"],
             ],
         )
 
-        # Tab 3 (Images): Load gallery, count, and room dropdown when selected
+        # Tab 2 (Images): Load gallery and count when selected
         def load_images_tab(session: SessionState):
             """Load all images tab data."""
-            room_choices = images.update_room_choices(session)
             gallery, count, warning = images.load_from_session(session)
-            return room_choices, gallery, count, warning
+            return gallery, count, warning
 
         tab_images.select(
             fn=load_images_tab,
             inputs=[session_state],
             outputs=[
-                tab3["room_select"],
-                tab3["images_gallery"],
-                tab3["image_count"],
-                tab3["resume_warning"],
+                tab2["images_gallery"],
+                tab2["image_count"],
+                tab2["resume_warning"],
             ],
         )
 
-        # Tab 4 (Observations): Load observation form fields when selected
+        # Tab 3 (Observations): Load observation form fields when selected
         tab_observations.select(
             fn=observations.load_form_from_session,
             inputs=[session_state],
             outputs=[
-                tab4["smoke_odor"],
-                tab4["odor_intensity"],
-                tab4["visible_soot"],
-                tab4["soot_description"],
-                tab4["large_char"],
-                tab4["char_density"],
-                tab4["ash_residue"],
-                tab4["ash_description"],
-                tab4["surface_discoloration"],
-                tab4["discoloration_description"],
-                tab4["dust_interference"],
-                tab4["dust_notes"],
-                tab4["wildfire_indicators"],
-                tab4["wildfire_notes"],
-                tab4["additional_notes"],
+                tab3["smoke_odor"],
+                tab3["odor_intensity"],
+                tab3["visible_soot"],
+                tab3["soot_description"],
+                tab3["large_char"],
+                tab3["char_density"],
+                tab3["ash_residue"],
+                tab3["ash_description"],
+                tab3["surface_discoloration"],
+                tab3["discoloration_description"],
+                tab3["dust_interference"],
+                tab3["dust_notes"],
+                tab3["wildfire_indicators"],
+                tab3["wildfire_notes"],
+                tab3["additional_notes"],
             ],
         )
 
-        # Tab 5 (Results): Check preflight status when selected
+        # Tab 4 (Results): Check preflight status when selected
         tab_results.select(
             fn=results.check_preflight,
             inputs=[session_state],
-            outputs=[tab5["preflight_status"]],
+            outputs=[tab4["preflight_status"]],
         )
 
     return app

pipeline/calculations.py

@@ -277,23 +277,19 @@ class FDAMCalculator:
         """Run all calculations from a session state.
 
         Args:
-            session: Current session state with rooms and project info
+            session: Current session state with room info
 
         Returns:
             Dictionary with all calculation results
         """
-        logger.debug(f"Running calculations for {len(session.rooms)} rooms")
+        r = session.room
+        logger.debug(f"Running calculations for room: {r.name}")
 
-        # Calculate totals from rooms
-        total_area = sum(r.length_ft * r.width_ft for r in session.rooms)
-        total_volume = sum(
-            r.length_ft * r.width_ft * r.ceiling_height_ft
-            for r in session.rooms
-        )
-        avg_ceiling = (
-            total_volume / total_area if total_area > 0 else 10.0
-        )
-        logger.debug(f"Totals: {total_area:.0f} SF, {total_volume:.0f} CF, avg ceiling {avg_ceiling:.1f} ft")
+        # Calculate totals from single room
+        total_area = r.length_ft * r.width_ft
+        total_volume = total_area * r.ceiling_height_ft
+        avg_ceiling = r.ceiling_height_ft if r.ceiling_height_ft > 0 else 10.0
+        logger.debug(f"Totals: {total_area:.0f} SF, {total_volume:.0f} CF, ceiling {avg_ceiling:.1f} ft")
 
         # Air filtration
         air_filtration = self.calculate_air_filtration(
@@ -313,8 +309,8 @@ class FDAMCalculator:
 
         # Regulatory flags
         regulatory = self.get_regulatory_flags(
-            construction_era=session.project.construction_era or "post-2000",
-            facility_classification=session.project.facility_classification or "non-operational",
+            construction_era=r.construction_era or "post-2000",
+            facility_classification=r.facility_classification or "non-operational",
         )
         if regulatory.notes:
             for note in regulatory.notes:
@@ -322,7 +318,7 @@ class FDAMCalculator:
 
         # Metals thresholds
         thresholds = self.get_metals_thresholds(
-            facility_classification=session.project.facility_classification or "non-operational",
+            facility_classification=r.facility_classification or "non-operational",
         )
         logger.debug(f"Metals thresholds ({thresholds.facility_type}): Pb={thresholds.lead_ug_100cm2} µg/100cm²")
 

pipeline/generator.py

@@ -141,11 +141,11 @@ class DocumentGenerator:
 
         return GeneratedDocument(
             markdown=markdown,
-            title=f"SOW - {session.project.project_name}",
+            title=f"SOW - {session.room.name}",
             generated_at=datetime.now().isoformat(),
             word_count=word_count,
             sections=[
-                "Header", "Project Info", "Scope Summary", "Room Inventory",
+                "Header", "Room Info", "Scope Summary", "Room Details",
                 "Vision Analysis", "Observations", "Dispositions",
                 "Cleaning Specs", "Air Filtration", "Sampling Plan",
                 "Regulatory", "Thresholds", "Footer"
@@ -156,26 +156,20 @@ class DocumentGenerator:
         """Generate document header."""
         return f"""# Cleaning Specification / Scope of Work
 
-**Project:** {session.project.project_name}
-**Prepared For:** {session.project.client_name}
+**Room:** {session.room.name}
 **Date:** {datetime.now().strftime('%B %d, %Y')}
 **Document Version:** FDAM v4.0.1"""
 
     def _generate_project_info(self, session: SessionState) -> str:
-        """Generate project information section."""
-        p = session.project
-        return f"""## Project Information
+        """Generate room information section."""
+        r = session.room
+        return f"""## Room Information
 
 | Field | Value |
 |-------|-------|
-| **Project Name** | {p.project_name} |
-| **Address** | {p.address}, {p.city}, {p.state} {p.zip_code} |
-| **Client** | {p.client_name} |
-| **Fire Date** | {p.fire_date} |
-| **Assessment Date** | {p.assessment_date} |
-| **Facility Classification** | {p.facility_classification or 'Not specified'} |
-| **Construction Era** | {p.construction_era or 'Not specified'} |
-| **Assessor** | {p.assessor_name} {p.assessor_credentials or ''} |"""
+| **Room Name** | {r.name} |
+| **Facility Classification** | {r.facility_classification or 'Not specified'} |
+| **Construction Era** | {r.construction_era or 'Not specified'} |"""
 
     def _generate_scope_summary(self, session: SessionState, calculations: dict) -> str:
         """Generate scope summary section."""
@@ -186,7 +180,7 @@ class DocumentGenerator:
 
 | Metric | Value |
 |--------|-------|
-| **Total Rooms/Areas** | {len(session.rooms)} |
+| **Room** | {session.room.name} |
 | **Total Floor Area** | {calculations['total_area_sf']:,.0f} SF |
 | **Total Volume** | {calculations['total_volume_cf']:,.0f} CF |
 | **Images Analyzed** | {len(session.images)} |
@@ -195,20 +189,21 @@ class DocumentGenerator:
 | **Est. Surface Wipes** | {sample.surface_wipes_min}-{sample.surface_wipes_max if sample else 'N/A'} |"""
 
     def _generate_room_inventory(self, session: SessionState) -> str:
-        """Generate room inventory table."""
-        lines = ["## Room Inventory", ""]
-        lines.append("| Room/Area | Dimensions | Area (SF) | Volume (CF) |")
-        lines.append("|-----------|------------|-----------|-------------|")
-
-        for room in session.rooms:
-            area = room.length_ft * room.width_ft
-            volume = area * room.ceiling_height_ft
-            lines.append(
-                f"| {room.name} | {room.length_ft:.0f}' × {room.width_ft:.0f}' × "
-                f"{room.ceiling_height_ft:.0f}' | {area:,.0f} | {volume:,.0f} |"
-            )
-
-        return "\n".join(lines)
+        """Generate room details section."""
+        r = session.room
+        area = r.length_ft * r.width_ft
+        volume = area * r.ceiling_height_ft
+
+        return f"""## Room Details
+
+| Property | Value |
+|----------|-------|
+| **Room Name** | {r.name} |
+| **Dimensions** | {r.length_ft:.0f}' × {r.width_ft:.0f}' × {r.ceiling_height_ft:.0f}' |
+| **Floor Area** | {area:,.0f} SF |
+| **Volume** | {volume:,.0f} CF |
+| **Facility Type** | {r.facility_classification or 'Not specified'} |
+| **Construction Era** | {r.construction_era or 'Not specified'} |"""
 
     def _generate_vision_summary(self, session: SessionState, vision_results: dict) -> str:
         """Generate AI vision analysis summary."""

pipeline/main.py

@@ -145,9 +145,9 @@ class FDAMPipeline:
         logger.info("=" * 60)
         logger.info("FDAM PIPELINE EXECUTION STARTED")
         logger.info("=" * 60)
-        logger.info(f"Project: {session.project.project_name}")
-        logger.info(f"Facility: {session.project.facility_classification}")
-        logger.info(f"Rooms: {len(session.rooms)}, Images: {len(session.images)}")
+        logger.info(f"Room: {session.room.name}")
+        logger.info(f"Facility: {session.room.facility_classification}")
+        logger.info(f"Images: {len(session.images)}")
 
         def report_progress(stage: int, message: str = ""):
             if progress_callback:
@@ -236,14 +236,10 @@ class FDAMPipeline:
                 )
                 vision_results[img_meta.id] = vision_result
 
-                # Build room mapping
-                room_info = next(
-                    (r for r in session.rooms if r.id == img_meta.room_id),
-                    None,
-                )
+                # Build room mapping (single room)
                 room_mapping[img_meta.id] = {
-                    "name": room_info.name if room_info else "Unknown",
-                    "id": img_meta.room_id,
+                    "name": session.room.name,
+                    "id": session.room.id,
                 }
 
                 # Create annotated image caption
@@ -389,10 +385,9 @@ class FDAMPipeline:
             disp_counts[d.disposition] = disp_counts.get(d.disposition, 0) + 1
 
         return {
-            "project_name": result.session.project.project_name,
-            "facility_classification": result.session.project.facility_classification,
-            "construction_era": result.session.project.construction_era,
-            "total_rooms": len(result.session.rooms),
+            "room_name": result.session.room.name,
+            "facility_classification": result.session.room.facility_classification,
+            "construction_era": result.session.room.construction_era,
             "total_images": len(result.session.images),
             "images_analyzed": len(result.vision_results),
             "total_floor_area_sf": f"{calc.get('total_area_sf', 0):,.0f}",

tests/conftest.py

@@ -1,68 +0,0 @@
-"""Pytest fixtures for Playwright E2E tests."""
-
-import pytest
-import subprocess
-import time
-import os
-import urllib.request
-import urllib.error
-from playwright.sync_api import sync_playwright, Browser, Page
-
-GRADIO_PORT = 7860
-GRADIO_URL = f"http://localhost:{GRADIO_PORT}"
-
-
-@pytest.fixture(scope="session")
-def gradio_server():
-    """Start Gradio server for E2E tests."""
-    env = os.environ.copy()
-    env["MOCK_MODELS"] = "true"
-
-    # Use venv python for consistent environment
-    python_cmd = ".venv/bin/python" if os.path.exists(".venv/bin/python") else "python3"
-
-    # Don't capture output - let it go to console for debugging
-    process = subprocess.Popen(
-        [python_cmd, "app.py"],
-        env=env,
-    )
-
-    # Wait for server to start with health check
-    max_retries = 30
-    for i in range(max_retries):
-        try:
-            urllib.request.urlopen(GRADIO_URL, timeout=1)
-            break
-        except (urllib.error.URLError, ConnectionRefusedError):
-            time.sleep(1)
-    else:
-        process.terminate()
-        raise RuntimeError("Gradio server failed to start")
-
-    yield GRADIO_URL
-
-    process.terminate()
-    process.wait()
-
-
-@pytest.fixture(scope="session")
-def browser_instance():
-    """Create browser instance for the session."""
-    # Use headless mode for WSL/CI environments, headed for local debugging
-    headless = os.environ.get("PLAYWRIGHT_HEADLESS", "true").lower() == "true"
-
-    with sync_playwright() as p:
-        browser = p.chromium.launch(headless=headless)
-        yield browser
-        browser.close()
-
-
-@pytest.fixture
-def page(browser_instance, gradio_server):
-    """Create new page for each test."""
-    context = browser_instance.new_context()
-    page = context.new_page()
-    page.goto(gradio_server)
-    page.wait_for_selector("#sample_dropdown", timeout=10000)
-    yield page
-    context.close()

tests/test_e2e_forms.py

@@ -1,307 +0,0 @@
-"""E2E tests for form interactions."""
-
-import pytest
-from playwright.sync_api import Page, expect
-
-
-def select_sample(page: Page, sample_text: str):
-    """Helper to select a sample from the dropdown."""
-    page.locator("#sample_dropdown input[role='listbox']").click()
-    page.wait_for_timeout(300)
-    page.locator(f"[role='option']:has-text('{sample_text}')").click()
-    # Wait for form to be populated - check that project_name has a value
-    # (status gets cleared when dropdown resets, so we can't rely on it)
-    page.wait_for_function(
-        """() => {
-            const textarea = document.querySelector('#project_name textarea');
-            return textarea && textarea.value && textarea.value.includes('Sample:');
-        }""",
-        timeout=30000
-    )
-
-
-class TestProjectForm:
-    """Test Tab 1 project form."""
-
-    def test_zip_validation_invalid(self, page: Page):
-        """Test ZIP code format validation with invalid input."""
-        # zip_code uses input (max_lines=1), not textarea
-        zip_input = page.locator("#zip_code input")
-
-        # Invalid ZIP (too short)
-        zip_input.fill("123")
-        zip_input.blur()
-        page.wait_for_timeout(300)
-
-        # Should show invalid message (✗ indicates error)
-        expect(page.locator("#zip_validation")).to_contain_text("✗")
-
-    def test_zip_validation_valid(self, page: Page):
-        """Test ZIP code format validation with valid input."""
-        # zip_code uses input (max_lines=1), not textarea
-        zip_input = page.locator("#zip_code input")
-
-        # Valid 5-digit ZIP
-        zip_input.fill("12345")
-        zip_input.blur()
-        page.wait_for_timeout(300)
-
-        # Should show valid checkmark
-        expect(page.locator("#zip_validation")).to_contain_text("Valid")
-
-    def test_zip_validation_valid_plus4(self, page: Page):
-        """Test ZIP+4 format validation."""
-        # zip_code uses input (max_lines=1), not textarea
-        zip_input = page.locator("#zip_code input")
-
-        # Valid ZIP+4
-        zip_input.fill("12345-6789")
-        zip_input.blur()
-        page.wait_for_timeout(300)
-
-        expect(page.locator("#zip_validation")).to_contain_text("Valid")
-
-    def test_facility_classification_radio(self, page: Page):
-        """Test facility classification radio buttons."""
-        # Use specific selector by value attribute to avoid substring matching
-        facility_group = page.locator("#facility_classification")
-
-        # Click Operational radio (use value attribute for exact match)
-        facility_group.locator("input[value='Operational']").click()
-        page.wait_for_timeout(200)
-
-        # Verify it's selected
-        expect(facility_group.locator("input[value='Operational']")).to_be_checked()
-
-        # Click Non-Operational
-        facility_group.locator("input[value='Non-Operational']").click()
-        page.wait_for_timeout(200)
-
-        expect(facility_group.locator("input[value='Non-Operational']")).to_be_checked()
-        expect(facility_group.locator("input[value='Operational']")).not_to_be_checked()
-
-    def test_construction_era_radio(self, page: Page):
-        """Test construction era radio buttons."""
-        page.get_by_label("Pre-1980").click()
-        expect(page.get_by_label("Pre-1980")).to_be_checked()
-
-        page.get_by_label("Post-2000").click()
-        expect(page.get_by_label("Post-2000")).to_be_checked()
-
-
-class TestRoomsForm:
-    """Test Tab 2 rooms form."""
-
-    def test_room_exists_after_sample_load(self, page: Page):
-        """Test room is created when sample is loaded."""
-        select_sample(page, "Bar & Dining Area")
-
-        # Go to Rooms tab
-        page.locator("#tab-rooms-button").click()
-        page.wait_for_timeout(500)
-
-        # Room should exist in table
-        expect(page.locator("#rooms_table")).to_contain_text("Bar & Dining Area")
-
-    def test_custom_height_visibility_toggle(self, page: Page):
-        """Test custom height field appears when 'Custom' selected."""
-        page.locator("#tab-rooms-button").click()
-        page.wait_for_timeout(300)
-
-        # Select a standard height first - click dropdown input to open
-        dropdown_input = page.locator("#room_height_preset input[role='listbox']")
-        dropdown_input.click()
-        page.wait_for_timeout(300)
-        page.locator("[role='option']:has-text('10 ft')").click()
-        page.wait_for_timeout(300)
-
-        # Custom height should be hidden
-        expect(page.locator("#room_height_custom")).not_to_be_visible()
-
-        # Select Custom - click dropdown input to open
-        dropdown_input.click()
-        page.wait_for_timeout(300)
-        page.locator("[role='option']:has-text('Custom')").click()
-        page.wait_for_timeout(300)
-
-        # Custom height should appear
-        expect(page.locator("#room_height_custom")).to_be_visible()
-
-    def test_room_validation_requires_name(self, page: Page):
-        """Test that room name is required."""
-        page.locator("#tab-rooms-button").click()
-        page.wait_for_timeout(300)
-
-        # Try to add room with empty name
-        page.locator("#room_length input").fill("20")
-        page.locator("#room_width input").fill("15")
-
-        # Select height from dropdown - click the input to open
-        page.locator("#room_height_preset input[role='listbox']").click()
-        page.wait_for_timeout(300)
-        page.locator("[role='option']:has-text('10 ft')").click()
-        page.wait_for_timeout(300)
-
-        page.get_by_role("button", name="Add Room").click()
-        page.wait_for_timeout(300)
-
-        # Should show validation error about room name
-        expect(page.locator("#tab2_validation")).to_contain_text("Room name")
-
-
-class TestImagesForm:
-    """Test Tab 3 images form."""
-
-    def test_images_gallery_shows_sample_images(self, page: Page):
-        """Test gallery displays images after sample load."""
-        select_sample(page, "Bar & Dining Area")
-
-        # Go to Images tab
-        page.locator("#tab-images-button").click()
-        page.wait_for_timeout(500)
-
-        # Gallery should have images
-        gallery = page.locator("#images_gallery")
-        expect(gallery).to_be_visible()
-
-        # Should have 3 images
-        images = gallery.locator("img")
-        expect(images).to_have_count(3)
-
-    def test_room_dropdown_populated(self, page: Page):
-        """Test room dropdown is populated after sample load."""
-        select_sample(page, "Bar & Dining Area")
-
-        # Go to Images tab
-        page.locator("#tab-images-button").click()
-        page.wait_for_timeout(500)
-
-        # Click dropdown input to open it and verify room is in options
-        page.locator("#room_select input[role='listbox']").click()
-        page.wait_for_timeout(300)
-
-        # Room should appear in dropdown options
-        expect(page.locator("[role='option']:has-text('Bar & Dining Area')")).to_be_visible()
-
-
-class TestObservationsForm:
-    """Test Tab 4 observations form."""
-
-    def test_checkbox_interactions(self, page: Page):
-        """Test observation checkboxes can be toggled."""
-        page.locator("#tab-observations-button").click()
-        page.wait_for_timeout(300)
-
-        # Check smoke odor
-        smoke_checkbox = page.locator("#smoke_odor input[type='checkbox']")
-        smoke_checkbox.check()
-        expect(smoke_checkbox).to_be_checked()
-
-        # Uncheck
-        smoke_checkbox.uncheck()
-        expect(smoke_checkbox).not_to_be_checked()
-
-    def test_odor_intensity_radio(self, page: Page):
-        """Test odor intensity radio buttons."""
-        page.locator("#tab-observations-button").click()
-        page.wait_for_timeout(300)
-
-        # Use specific selector within odor_intensity group to avoid matching char_density
-        odor_group = page.locator("#odor_intensity")
-
-        odor_group.get_by_label("Strong").click()
-        expect(odor_group.get_by_label("Strong")).to_be_checked()
-
-        odor_group.get_by_label("Moderate").click()
-        expect(odor_group.get_by_label("Moderate")).to_be_checked()
-        expect(odor_group.get_by_label("Strong")).not_to_be_checked()
-
-    def test_observations_persist_after_sample_load(self, page: Page):
-        """Test observations are populated from sample."""
-        select_sample(page, "Factory Area")
-
-        # Go to Observations tab
-        page.locator("#tab-observations-button").click()
-        page.wait_for_timeout(500)
-
-        # Factory sample has smoke odor = True
-        smoke_checkbox = page.locator("#smoke_odor input[type='checkbox']")
-        expect(smoke_checkbox).to_be_checked()
-
-
-class TestDebugSelectors:
-    """Debug tests to verify Gradio HTML structure."""
-
-    def test_capture_dropdown_and_sample_load(self, page: Page):
-        """Capture dropdown HTML and test full sample load.
-
-        Run with: pytest tests/test_e2e_forms.py::TestDebugSelectors::test_capture_dropdown_and_sample_load -v -s
-        """
-        page.wait_for_timeout(2000)
-
-        # Click dropdown to open
-        print("\n--- Opening dropdown ---")
-        dropdown_input = page.locator("#sample_dropdown input[role='listbox']")
-        dropdown_input.click()
-        page.wait_for_timeout(500)
-
-        # Click the Bar & Dining option
-        print("Clicking Bar & Dining option...")
-        page.locator("[role='option']:has-text('Bar & Dining Area')").click()
-        page.wait_for_timeout(2000)  # Wait for sample to load
-
-        # Check sample_status HTML
-        print("\n--- DEBUG: Status HTML ---")
-        try:
-            status_html = page.locator("#sample_status").evaluate("el => el.outerHTML")
-            print("Sample status HTML:", status_html[:500])
-        except Exception as e:
-            print(f"Error getting status: {e}")
-
-        # Check if project name was populated
-        print("\n--- DEBUG: Project Name ---")
-        try:
-            # Get the full HTML of project_name element
-            pn_html = page.locator("#project_name").evaluate("el => el.outerHTML")
-            print(f"Project name HTML:\n{pn_html[:800]}")
-
-            # Try different selectors
-            print("\nTrying different selectors:")
-            print(f"  #project_name input count: {page.locator('#project_name input').count()}")
-            print(f"  #project_name textarea count: {page.locator('#project_name textarea').count()}")
-            print(f"  #project_name [data-testid] count: {page.locator('#project_name [data-testid]').count()}")
-
-            # Check if there's any input/textarea in the document
-            all_inputs = page.locator("input[type='text']").count()
-            print(f"  Total text inputs on page: {all_inputs}")
-
-        except Exception as e:
-            print(f"Error: {e}")
-
-        print("--- END DEBUG ---\n")
-
-    def test_capture_full_page_structure(self, page: Page):
-        """Capture key element structures.
-
-        Run with: pytest tests/test_e2e_forms.py::TestDebugSelectors::test_capture_full_page_structure -v -s
-        """
-        page.wait_for_timeout(2000)
-
-        print("\n--- DEBUG: Page Structure ---")
-
-        # Capture project name structure
-        project_name = page.locator("#project_name")
-        print("Project name HTML:", project_name.evaluate("el => el.outerHTML")[:500])
-
-        # Capture tab button structure
-        try:
-            tab_btn = page.locator("#tab-project-button")
-            print("Tab button exists:", tab_btn.count() > 0)
-        except Exception as e:
-            print(f"Tab button error: {e}")
-
-        # Try to find tab by different selectors
-        tabs = page.locator('[role="tab"]').all()
-        print(f"Found {len(tabs)} tabs with role=tab")
-
-        print("--- END DEBUG ---\n")

tests/test_e2e_samples.py

@@ -1,148 +0,0 @@
-"""E2E tests for sample scenario loading."""
-
-import pytest
-from playwright.sync_api import Page, expect
-
-
-def select_sample(page: Page, sample_text: str):
-    """Helper to select a sample from the dropdown.
-
-    Args:
-        page: Playwright page
-        sample_text: Text of the sample option to select (e.g., "Bar & Dining Area")
-    """
-    # Gradio dropdowns use input[role='listbox'] - click to open
-    page.locator("#sample_dropdown input[role='listbox']").click()
-    page.wait_for_timeout(300)  # Wait for dropdown to open
-
-    # Click the option with matching text
-    page.locator(f"[role='option']:has-text('{sample_text}')").click()
-
-    # Wait for form to be populated - check that project_name has a value
-    # Gradio 6.x uses textarea for textboxes
-    page.wait_for_function(
-        """() => {
-            const textarea = document.querySelector('#project_name textarea');
-            return textarea && textarea.value && textarea.value.includes('Sample:');
-        }""",
-        timeout=30000
-    )
-
-
-class TestSampleLoading:
-    """Test loading sample scenarios via dropdown."""
-
-    def test_bar_dining_loads_correctly(self, page: Page):
-        """Verify Bar & Dining sample loads all data."""
-        select_sample(page, "Bar & Dining Area")
-
-        # Verify Tab 1 populated
-        expect(page.locator("#project_name textarea")).to_have_value(
-            "Sample: Bar & Dining Fire Assessment"
-        )
-        expect(page.locator("#city textarea")).to_have_value("Springfield")
-
-    def test_bar_area_loads_correctly(self, page: Page):
-        """Verify Bar Area sample loads all data."""
-        select_sample(page, "Bar Area")
-
-        expect(page.locator("#project_name textarea")).to_have_value(
-            "Sample: Bar Area Fire Assessment"
-        )
-
-    def test_kitchen_loads_6_images(self, page: Page):
-        """Verify Kitchen sample loads 6 images."""
-        select_sample(page, "Kitchen")
-
-        # Navigate to Images tab
-        page.locator("#tab-images-button").click()
-
-        # Wait for gallery to populate - may take time for images to render
-        page.wait_for_function(
-            """() => {
-                const gallery = document.querySelector('#images_gallery');
-                const images = gallery ? gallery.querySelectorAll('img') : [];
-                return images.length > 0;
-            }""",
-            timeout=10000
-        )
-
-        # Verify image count in gallery
-        gallery = page.locator("#images_gallery")
-        images = gallery.locator("img")
-        expect(images).to_have_count(6)
-
-    def test_factory_loads_1_image(self, page: Page):
-        """Verify Factory sample loads 1 image."""
-        select_sample(page, "Factory Area")
-
-        # Navigate to Images tab
-        page.locator("#tab-images-button").click()
-        page.wait_for_timeout(500)
-
-        # Verify image count
-        gallery = page.locator("#images_gallery")
-        images = gallery.locator("img")
-        expect(images).to_have_count(1)
-
-    def test_factory_operational_facility(self, page: Page):
-        """Verify Factory sample has operational classification."""
-        select_sample(page, "Factory Area")
-
-        # Check facility classification shows Operational
-        expect(page.locator("#facility_classification")).to_contain_text("Operational")
-
-    def test_sample_dropdown_resets_after_selection(self, page: Page):
-        """Verify dropdown resets to placeholder after loading sample."""
-        select_sample(page, "Bar & Dining Area")
-
-        # Dropdown should reset to placeholder text
-        dropdown_input = page.locator("#sample_dropdown input[role='listbox']")
-        expect(dropdown_input).to_have_value("Select a sample scenario...")
-
-
-class TestSampleRoomData:
-    """Test that sample rooms load correct data."""
-
-    def test_bar_dining_room_dimensions(self, page: Page):
-        """Verify Bar & Dining room has correct dimensions."""
-        select_sample(page, "Bar & Dining Area")
-
-        # Navigate to Rooms tab
-        page.locator("#tab-rooms-button").click()
-        page.wait_for_timeout(500)
-
-        # Verify room table shows the room
-        expect(page.locator("#rooms_table")).to_contain_text("Bar & Dining Area")
-        expect(page.locator("#rooms_table")).to_contain_text("40")  # Length
-        expect(page.locator("#rooms_table")).to_contain_text("30")  # Width
-
-    def test_kitchen_room_dimensions(self, page: Page):
-        """Verify Kitchen room has correct dimensions."""
-        select_sample(page, "Kitchen")
-
-        # Navigate to Rooms tab
-        page.locator("#tab-rooms-button").click()
-        page.wait_for_timeout(500)
-
-        # Verify room name
-        expect(page.locator("#rooms_table")).to_contain_text("Commercial Kitchen")
-
-
-class TestSampleObservations:
-    """Test that sample observations load correctly."""
-
-    def test_bar_dining_observations(self, page: Page):
-        """Verify Bar & Dining sample loads observations."""
-        select_sample(page, "Bar & Dining Area")
-
-        # Navigate to Observations tab
-        page.locator("#tab-observations-button").click()
-        page.wait_for_timeout(500)
-
-        # Verify smoke odor checkbox is checked
-        smoke_checkbox = page.locator("#smoke_odor input[type='checkbox']")
-        expect(smoke_checkbox).to_be_checked()
-
-        # Verify odor intensity shows Strong
-        expect(page.locator("#odor_intensity")).to_contain_text("Strong")

tests/test_e2e_workflow.py

@@ -1,150 +0,0 @@
-"""E2E tests for complete assessment workflow."""
-
-import pytest
-from playwright.sync_api import Page, expect
-
-
-def select_sample(page: Page, sample_text: str):
-    """Helper to select a sample from the dropdown."""
-    page.locator("#sample_dropdown input[role='listbox']").click()
-    page.wait_for_timeout(300)
-    page.locator(f"[role='option']:has-text('{sample_text}')").click()
-    # Wait for form to be populated - check that project_name has a value
-    # (status gets cleared when dropdown resets, so we can't rely on it)
-    page.wait_for_function(
-        """() => {
-            const textarea = document.querySelector('#project_name textarea');
-            return textarea && textarea.value && textarea.value.includes('Sample:');
-        }""",
-        timeout=30000
-    )
-
-
-class TestFullWorkflow:
-    """Test complete assessment generation workflow."""
-
-    def test_generate_with_sample(self, page: Page):
-        """Test full generation workflow with sample data."""
-        select_sample(page, "Bar & Dining Area")
-
-        # Navigate to Results tab
-        page.locator("#tab-results-button").click()
-        page.wait_for_timeout(500)
-
-        # Check preflight shows ready
-        expect(page.locator("#preflight_status")).to_contain_text("Ready to Generate")
-
-        # Click generate
-        page.locator("#generate_btn").click()
-
-        # Wait for generation - check for "Complete" in the status textbox input
-        # The processing_status is a Textbox, so we need to check the input value
-        page.wait_for_function(
-            """() => {
-                const input = document.querySelector('#processing_status input, #processing_status textarea');
-                return input && input.value && input.value.includes('Complete');
-            }""",
-            timeout=120000
-        )
-
-        # Verify outputs are visible
-        expect(page.locator("#sow_output")).to_be_visible()
-        expect(page.locator("#download_md")).to_be_visible()
-
-    def test_preflight_check_incomplete_session(self, page: Page):
-        """Test preflight shows errors for incomplete session."""
-        # Don't load sample - go directly to Results
-        page.locator("#tab-results-button").click()
-        page.wait_for_timeout(500)
-
-        # Should show cannot generate message
-        expect(page.locator("#preflight_status")).to_contain_text("Cannot Generate")
-
-
-class TestTabNavigation:
-    """Test tab navigation and validation."""
-
-    def test_click_tab_navigation(self, page: Page):
-        """Test clicking tab buttons navigates correctly."""
-        # Start on Tab 1 (Project)
-        expect(page.locator("#project_name")).to_be_visible()
-
-        # Click Tab 2 (Rooms)
-        page.locator("#tab-rooms-button").click()
-        page.wait_for_timeout(300)
-        expect(page.locator("#room_name")).to_be_visible()
-
-        # Click Tab 3 (Images)
-        page.locator("#tab-images-button").click()
-        page.wait_for_timeout(300)
-        expect(page.locator("#image_upload")).to_be_visible()
-
-        # Click Tab 4 (Observations)
-        page.locator("#tab-observations-button").click()
-        page.wait_for_timeout(300)
-        expect(page.locator("#smoke_odor")).to_be_visible()
-
-        # Click Tab 5 (Results)
-        page.locator("#tab-results-button").click()
-        page.wait_for_timeout(300)
-        expect(page.locator("#generate_btn")).to_be_visible()
-
-    def test_keyboard_shortcuts(self, page: Page):
-        """Test Ctrl+1-5 keyboard shortcuts."""
-        # Start on Tab 1
-        expect(page.locator("#project_name")).to_be_visible()
-
-        # Ctrl+3 -> Images tab
-        page.keyboard.press("Control+3")
-        page.wait_for_timeout(300)
-        expect(page.locator("#image_upload")).to_be_visible()
-
-        # Ctrl+5 -> Results tab
-        page.keyboard.press("Control+5")
-        page.wait_for_timeout(300)
-        expect(page.locator("#generate_btn")).to_be_visible()
-
-        # Ctrl+1 -> Back to Project
-        page.keyboard.press("Control+1")
-        page.wait_for_timeout(300)
-        expect(page.locator("#project_name")).to_be_visible()
-
-    def test_tab1_validation_prevents_navigation(self, page: Page):
-        """Test that incomplete Tab 1 shows validation errors."""
-        # Try to validate empty Tab 1
-        page.get_by_role("button", name="Validate & Continue to Rooms").click()
-        page.wait_for_timeout(500)
-
-        # Should show validation error message with required field errors
-        validation = page.locator("#tab1_validation")
-        expect(validation).to_contain_text("Please fix the following")
-
-
-class TestBackNavigation:
-    """Test back button navigation."""
-
-    def test_back_from_rooms_to_project(self, page: Page):
-        """Test back button from Rooms tab."""
-        # Go to Rooms tab
-        page.locator("#tab-rooms-button").click()
-        page.wait_for_timeout(300)
-
-        # Click back
-        page.get_by_role("button", name="Back to Project").click()
-        page.wait_for_timeout(300)
-
-        # Should be on Project tab
-        expect(page.locator("#project_name")).to_be_visible()
-
-    def test_back_from_images_to_rooms(self, page: Page):
-        """Test back button from Images tab."""
-        # Go to Images tab
-        page.locator("#tab-images-button").click()
-        page.wait_for_timeout(300)
-
-        # Click back
-        page.get_by_role("button", name="Back to Rooms").click()
-        page.wait_for_timeout(300)
-
-        # Should be on Rooms tab
-        expect(page.locator("#room_name")).to_be_visible()

tests/test_pdf_generator.py

@@ -1,246 +0,0 @@
-"""Tests for PDF generation module."""
-
-import pytest
-import tempfile
-from pathlib import Path
-
-from pipeline.pdf_generator import PDFGenerator, PDFResult, generate_sow_pdf, SOW_CSS
-
-
-class TestPDFGenerator:
-    """Test PDF generator functionality."""
-
-    @pytest.fixture
-    def generator(self):
-        """Create PDF generator instance."""
-        return PDFGenerator()
-
-    @pytest.fixture
-    def sample_markdown(self):
-        """Sample markdown for testing."""
-        return """# Test Document
-
-## Section One
-
-This is a test paragraph with **bold** and *italic* text.
-
-| Column A | Column B |
-|----------|----------|
-| Value 1  | Value 2  |
-| Value 3  | Value 4  |
-
-## Section Two
-
-- Bullet point one
-- Bullet point two
-- Bullet point three
-
----
-
-*Generated by test*
-"""
-
-    def test_weasyprint_available(self, generator):
-        """Test that WeasyPrint is detected as available."""
-        assert generator.weasyprint_available is True
-
-    def test_markdown_to_html(self, generator, sample_markdown):
-        """Test markdown to HTML conversion."""
-        html = generator.markdown_to_html(sample_markdown)
-
-        assert "<!DOCTYPE html>" in html
-        assert "<html>" in html
-        assert "<style>" in html
-        # Note: markdown library adds id attribute to headers (from TOC extension)
-        assert "<h1" in html and "Test Document</h1>" in html
-        assert "<table>" in html
-        assert "<strong>bold</strong>" in html
-
-    def test_markdown_to_html_includes_css(self, generator, sample_markdown):
-        """Test that HTML includes CSS styling."""
-        html = generator.markdown_to_html(sample_markdown)
-
-        # Check key CSS rules are included
-        assert "font-family" in html
-        assert "border-collapse" in html
-        assert "@page" in html
-
-    def test_generate_pdf_success(self, generator, sample_markdown):
-        """Test successful PDF generation."""
-        result = generator.generate_pdf(sample_markdown)
-
-        assert isinstance(result, PDFResult)
-        assert result.success is True
-        assert result.pdf_path is not None
-        assert result.error_message is None
-        assert result.file_size_bytes > 0
-
-        # Verify file exists
-        pdf_path = Path(result.pdf_path)
-        assert pdf_path.exists()
-        assert pdf_path.suffix == ".pdf"
-
-        # Clean up
-        pdf_path.unlink()
-
-    def test_generate_pdf_with_custom_path(self, generator, sample_markdown):
-        """Test PDF generation with custom output path."""
-        with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as f:
-            output_path = f.name
-
-        result = generator.generate_pdf(sample_markdown, output_path=output_path)
-
-        assert result.success is True
-        assert result.pdf_path == output_path
-
-        # Clean up
-        Path(output_path).unlink()
-
-    def test_generate_pdf_empty_content(self, generator):
-        """Test PDF generation with empty content."""
-        result = generator.generate_pdf("")
-
-        # Should still succeed with empty content
-        assert result.success is True
-        assert result.pdf_path is not None
-
-        # Clean up
-        Path(result.pdf_path).unlink()
-
-    def test_generate_pdf_complex_tables(self, generator):
-        """Test PDF with complex table content."""
-        markdown = """# Thresholds
-
-| Metal | Non-Operational | Operational | Unit |
-|-------|-----------------|-------------|------|
-| Lead | 22 | 500 | µg/100cm² |
-| Cadmium | 3.3 | 50 | µg/100cm² |
-| Arsenic | 6.7 | 100 | µg/100cm² |
-
-## Notes
-
-Special characters: µ, °, ², ™
-"""
-        result = generator.generate_pdf(markdown)
-
-        assert result.success is True
-        assert result.file_size_bytes > 0
-
-        # Clean up
-        Path(result.pdf_path).unlink()
-
-    def test_generate_html_fallback(self, generator, sample_markdown):
-        """Test HTML generation as fallback."""
-        success, html_path, error = generator.generate_html(sample_markdown)
-
-        assert success is True
-        assert html_path is not None
-        assert error is None
-
-        # Verify file exists and contains HTML
-        html_path = Path(html_path)
-        assert html_path.exists()
-        content = html_path.read_text()
-        assert "<html>" in content
-
-        # Clean up
-        html_path.unlink()
-
-    def test_custom_css(self):
-        """Test PDF generator with custom CSS."""
-        custom_css = """
-        body { font-family: monospace; }
-        h1 { color: red; }
-        """
-        generator = PDFGenerator(custom_css=custom_css)
-
-        html = generator.markdown_to_html("# Test")
-        assert "font-family: monospace" in html
-        assert "color: red" in html
-
-
-class TestGenerateSowPdf:
-    """Test the convenience function."""
-
-    def test_generate_sow_pdf(self):
-        """Test generate_sow_pdf convenience function."""
-        markdown = """# Scope of Work
-
-## Project: Test Fire
-
-| Field | Value |
-|-------|-------|
-| Client | ACME Corp |
-| Date | 2024-01-15 |
-
-## Recommendations
-
-- Clean all surfaces
-- HEPA vacuum required
-"""
-        result = generate_sow_pdf(
-            markdown_content=markdown,
-            project_name="Test Fire",
-        )
-
-        assert result.success is True
-        assert result.pdf_path is not None
-
-        # Clean up
-        Path(result.pdf_path).unlink()
-
-
-class TestSOWCSS:
-    """Test CSS styling constants."""
-
-    def test_sow_css_exists(self):
-        """Test that SOW_CSS is defined."""
-        assert SOW_CSS is not None
-        assert len(SOW_CSS) > 0
-
-    def test_sow_css_has_page_settings(self):
-        """Test that CSS includes page settings."""
-        assert "@page" in SOW_CSS
-        assert "margin" in SOW_CSS
-
-    def test_sow_css_has_table_styling(self):
-        """Test that CSS includes table styling."""
-        assert "table" in SOW_CSS
-        assert "border-collapse" in SOW_CSS
-        assert "th" in SOW_CSS
-        assert "td" in SOW_CSS
-
-    def test_sow_css_has_header_styling(self):
-        """Test that CSS includes header styling."""
-        assert "h1" in SOW_CSS
-        assert "h2" in SOW_CSS
-
-
-class TestPDFResultDataclass:
-    """Test PDFResult dataclass."""
-
-    def test_pdf_result_success(self):
-        """Test PDFResult with success."""
-        result = PDFResult(
-            success=True,
-            pdf_path="/tmp/test.pdf",
-            file_size_bytes=1000,
-        )
-
-        assert result.success is True
-        assert result.pdf_path == "/tmp/test.pdf"
-        assert result.error_message is None
-        assert result.file_size_bytes == 1000
-
-    def test_pdf_result_failure(self):
-        """Test PDFResult with failure."""
-        result = PDFResult(
-            success=False,
-            pdf_path=None,
-            error_message="Something went wrong",
-        )
-
-        assert result.success is False
-        assert result.pdf_path is None
-        assert result.error_message == "Something went wrong"
-        assert result.file_size_bytes == 0

tests/test_pipeline.py

@@ -1,525 +0,0 @@
-"""Tests for FDAM Pipeline components."""
-
-import pytest
-from PIL import Image
-import io
-
-from pipeline.calculations import (
-    FDAMCalculator,
-    AirFiltrationResult,
-    SampleDensityResult,
-    RegulatoryFlags,
-    MetalsThresholds,
-    METALS_THRESHOLDS,
-    PARTICULATE_THRESHOLDS,
-)
-from pipeline.dispositions import (
-    DispositionEngine,
-    DispositionResult,
-    SurfaceDisposition,
-    DISPOSITION_MATRIX,
-    CLEANING_PROTOCOLS,
-)
-from pipeline.generator import DocumentGenerator, GeneratedDocument
-from pipeline.main import FDAMPipeline, PipelineResult, PipelineProgress
-
-from ui.state import SessionState, RoomFormData, ImageFormData
-from ui.components import image_store
-
-
-class TestFDAMCalculator:
-    """Test FDAM calculations."""
-
-    @pytest.fixture
-    def calculator(self):
-        return FDAMCalculator()
-
-    def test_air_filtration_basic(self, calculator):
-        """Test basic air filtration calculation."""
-        result = calculator.calculate_air_filtration(
-            total_area_sf=10000,
-            avg_ceiling_height_ft=10,
-        )
-
-        assert isinstance(result, AirFiltrationResult)
-        assert result.total_volume_cf == 100000
-        assert result.required_ach == 4
-        assert result.unit_cfm == 2000
-        # (100000 * 4) / (2000 * 60) = 3.33 -> 4 units
-        assert result.units_required == 4
-
-    def test_air_filtration_large_space(self, calculator):
-        """Test air filtration for large space."""
-        result = calculator.calculate_air_filtration(
-            total_area_sf=50000,
-            avg_ceiling_height_ft=30,
-        )
-
-        # 1,500,000 CF * 4 ACH / (2000 * 60) = 50 units
-        assert result.units_required == 50
-        assert result.total_volume_cf == 1500000
-
-    def test_air_filtration_minimum_one_unit(self, calculator):
-        """Test minimum 1 unit is required."""
-        result = calculator.calculate_air_filtration(
-            total_area_sf=100,
-            avg_ceiling_height_ft=8,
-        )
-
-        assert result.units_required >= 1
-
-    def test_sample_density_small_area(self, calculator):
-        """Test sample density for small area."""
-        result = calculator.calculate_sample_density(
-            total_area_sf=3000,
-            surface_types_count=3,
-        )
-
-        assert isinstance(result, SampleDensityResult)
-        assert result.tape_lifts_min == 9  # 3 * 3
-        assert result.tape_lifts_max == 15  # 5 * 3
-
-    def test_sample_density_medium_area(self, calculator):
-        """Test sample density for medium area."""
-        result = calculator.calculate_sample_density(
-            total_area_sf=15000,
-            surface_types_count=3,
-        )
-
-        assert result.tape_lifts_min == 15  # 5 * 3
-        assert result.tape_lifts_max == 30  # 10 * 3
-
-    def test_sample_density_ceiling_deck(self, calculator):
-        """Test ceiling deck enhanced sampling."""
-        result = calculator.calculate_sample_density(
-            total_area_sf=10000,
-            has_ceiling_deck=True,
-        )
-
-        # 1 per 2,500 SF = 4 samples
-        assert result.ceiling_deck_samples == 4
-
-    def test_regulatory_flags_pre_1980(self, calculator):
-        """Test regulatory flags for pre-1980 construction."""
-        flags = calculator.get_regulatory_flags(
-            construction_era="pre-1980",
-            facility_classification="non-operational",
-        )
-
-        assert isinstance(flags, RegulatoryFlags)
-        assert flags.lbp_survey_required is True
-        assert flags.acm_survey_required is True
-        assert flags.acm_survey_recommended is False
-
-    def test_regulatory_flags_1980_2000(self, calculator):
-        """Test regulatory flags for 1980-2000 construction."""
-        flags = calculator.get_regulatory_flags(
-            construction_era="1980-2000",
-            facility_classification="operational",
-        )
-
-        assert flags.lbp_survey_required is False
-        assert flags.acm_survey_required is False
-        assert flags.acm_survey_recommended is True
-
-    def test_regulatory_flags_childcare(self, calculator):
-        """Test regulatory flags for public/childcare."""
-        flags = calculator.get_regulatory_flags(
-            construction_era="post-2000",
-            facility_classification="public-childcare",
-        )
-
-        assert flags.enhanced_childcare_thresholds is True
-
-    def test_metals_thresholds_non_operational(self, calculator):
-        """Test metals thresholds for non-operational facility."""
-        thresholds = calculator.get_metals_thresholds("non-operational")
-
-        assert isinstance(thresholds, MetalsThresholds)
-        assert thresholds.lead_ug_100cm2 == 22.0
-        assert thresholds.cadmium_ug_100cm2 == 3.3
-        assert thresholds.arsenic_ug_100cm2 == 6.7
-
-    def test_metals_thresholds_operational(self, calculator):
-        """Test metals thresholds for operational facility."""
-        thresholds = calculator.get_metals_thresholds("operational")
-
-        assert thresholds.lead_ug_100cm2 == 500.0
-        assert thresholds.cadmium_ug_100cm2 == 50.0
-
-    def test_metals_thresholds_childcare(self, calculator):
-        """Test metals thresholds for childcare facility."""
-        thresholds = calculator.get_metals_thresholds("public-childcare")
-
-        # EPA/HUD October 2024 for floors
-        assert thresholds.lead_ug_100cm2 == 4.3
-
-    def test_particulate_thresholds_exist(self):
-        """Test particulate thresholds are defined."""
-        assert "ash_char" in PARTICULATE_THRESHOLDS
-        assert "aciniform_soot" in PARTICULATE_THRESHOLDS
-        assert PARTICULATE_THRESHOLDS["ash_char"]["clearance"] == 150
-        assert PARTICULATE_THRESHOLDS["aciniform_soot"]["clearance"] == 500
-
-
-class TestDispositionEngine:
-    """Test disposition determination."""
-
-    @pytest.fixture
-    def engine(self):
-        return DispositionEngine()
-
-    def test_disposition_background(self, engine):
-        """Test disposition for background condition."""
-        result = engine.determine_disposition(
-            zone="far-field",
-            condition="background",
-            use_rag=False,
-        )
-
-        assert isinstance(result, DispositionResult)
-        assert result.disposition == "no-action"
-        assert result.confidence == 1.0
-
-    def test_disposition_structural_damage(self, engine):
-        """Test disposition for structural damage."""
-        result = engine.determine_disposition(
-            zone="burn-zone",
-            condition="structural-damage",
-            use_rag=False,
-        )
-
-        assert result.disposition == "remove-repair"
-        assert result.confidence == 1.0
-
-    def test_disposition_far_field_light(self, engine):
-        """Test disposition for far-field light condition."""
-        result = engine.determine_disposition(
-            zone="far-field",
-            condition="light",
-            use_rag=False,
-        )
-
-        assert result.disposition == "clean"
-        assert "standard" in result.protocol.lower()
-
-    def test_disposition_near_field_heavy(self, engine):
-        """Test disposition for near-field heavy condition."""
-        result = engine.determine_disposition(
-            zone="near-field",
-            condition="heavy",
-            use_rag=False,
-        )
-
-        assert result.disposition == "clean"
-        assert "aggressive" in result.protocol.lower()
-
-    def test_cleaning_method_drywall(self, engine):
-        """Test cleaning method for drywall."""
-        method = engine.get_cleaning_method(
-            surface_type="drywall",
-            condition="moderate",
-            use_rag=False,
-        )
-
-        assert "HEPA" in method["method"]
-        assert method["surface_type"] == "drywall"
-
-    def test_cleaning_method_concrete(self, engine):
-        """Test cleaning method for concrete."""
-        method = engine.get_cleaning_method(
-            surface_type="concrete-floor",
-            condition="heavy",
-            use_rag=False,
-        )
-
-        assert "scrubber" in method["method"].lower()
-        assert "multiple passes" in method["method"].lower()
-
-    def test_disposition_matrix_completeness(self):
-        """Test disposition matrix covers expected combinations."""
-        # Key combinations should be in matrix
-        assert ("far-field", "light") in DISPOSITION_MATRIX
-        assert ("near-field", "moderate") in DISPOSITION_MATRIX
-        assert ("burn-zone", "heavy") in DISPOSITION_MATRIX
-        assert ("any", "background") in DISPOSITION_MATRIX
-        assert ("any", "structural-damage") in DISPOSITION_MATRIX
-
-    def test_cleaning_protocols_exist(self):
-        """Test cleaning protocols are defined."""
-        assert "standard" in CLEANING_PROTOCOLS
-        assert "full" in CLEANING_PROTOCOLS
-        assert "aggressive" in CLEANING_PROTOCOLS
-
-        for protocol in CLEANING_PROTOCOLS.values():
-            assert "name" in protocol
-            assert "steps" in protocol
-            assert len(protocol["steps"]) > 0
-
-
-class TestDocumentGenerator:
-    """Test document generation."""
-
-    @pytest.fixture
-    def generator(self):
-        return DocumentGenerator()
-
-    @pytest.fixture
-    def sample_session(self):
-        session = SessionState()
-        session.project.project_name = "Test Fire Project"
-        session.project.address = "123 Main St"
-        session.project.city = "Springfield"
-        session.project.state = "IL"
-        session.project.zip_code = "62701"
-        session.project.client_name = "Test Client"
-        session.project.fire_date = "2024-01-01"
-        session.project.assessment_date = "2024-01-15"
-        session.project.facility_classification = "non-operational"
-        session.project.construction_era = "pre-1980"
-        session.project.assessor_name = "John Doe"
-        session.project.assessor_credentials = "CIH"
-
-        session.rooms.append(
-            RoomFormData(
-                id="room-001",
-                name="Main Hall",
-                length_ft=50,
-                width_ft=30,
-                ceiling_height_ft=12,
-            )
-        )
-        return session
-
-    @pytest.fixture
-    def sample_calculations(self):
-        calc = FDAMCalculator()
-        return {
-            "total_area_sf": 1500,
-            "total_volume_cf": 18000,
-            "avg_ceiling_height_ft": 12,
-            "air_filtration": calc.calculate_air_filtration(1500, 12),
-            "sample_density": calc.calculate_sample_density(1500),
-            "regulatory_flags": calc.get_regulatory_flags("pre-1980", "non-operational"),
-            "metals_thresholds": calc.get_metals_thresholds("non-operational"),
-            "particulate_thresholds": PARTICULATE_THRESHOLDS,
-        }
-
-    def test_generate_sow_basic(self, generator, sample_session, sample_calculations):
-        """Test basic SOW generation."""
-        doc = generator.generate_sow(
-            session=sample_session,
-            vision_results={},
-            surface_dispositions=[],
-            calculations=sample_calculations,
-        )
-
-        assert isinstance(doc, GeneratedDocument)
-        assert "Test Fire Project" in doc.markdown
-        assert "Cleaning Specification" in doc.markdown
-        assert doc.word_count > 0
-
-    def test_generate_sow_sections(self, generator, sample_session, sample_calculations):
-        """Test SOW contains required sections."""
-        doc = generator.generate_sow(
-            session=sample_session,
-            vision_results={},
-            surface_dispositions=[],
-            calculations=sample_calculations,
-        )
-
-        # Check for key sections
-        assert "## Project Information" in doc.markdown
-        assert "## Scope Summary" in doc.markdown
-        assert "## Room Inventory" in doc.markdown
-        assert "## Air Filtration Requirements" in doc.markdown
-        assert "## Regulatory Requirements" in doc.markdown
-        assert "## Clearance Thresholds" in doc.markdown
-
-    def test_generate_sow_with_dispositions(self, generator, sample_session, sample_calculations):
-        """Test SOW generation with dispositions."""
-        dispositions = [
-            SurfaceDisposition(
-                surface_type="drywall",
-                room_name="Main Hall",
-                zone="near-field",
-                condition="moderate",
-                disposition="clean",
-                cleaning_method="HEPA vacuum → Wet wipe",
-            )
-        ]
-
-        doc = generator.generate_sow(
-            session=sample_session,
-            vision_results={},
-            surface_dispositions=dispositions,
-            calculations=sample_calculations,
-        )
-
-        assert "drywall" in doc.markdown.lower()
-        assert "CLEAN" in doc.markdown
-
-
-class TestFDAMPipeline:
-    """Test full pipeline execution."""
-
-    @pytest.fixture
-    def pipeline(self):
-        return FDAMPipeline()
-
-    @pytest.fixture
-    def valid_session(self):
-        """Create a valid session for pipeline testing."""
-        session = SessionState()
-        session.project.project_name = "Pipeline Test"
-        session.project.address = "456 Oak Ave"
-        session.project.city = "Chicago"
-        session.project.state = "IL"
-        session.project.zip_code = "60601"
-        session.project.client_name = "Test Corp"
-        session.project.fire_date = "2024-06-01"
-        session.project.assessment_date = "2024-06-15"
-        session.project.facility_classification = "operational"
-        session.project.construction_era = "post-2000"
-        session.project.assessor_name = "Jane Smith"
-
-        session.rooms.append(
-            RoomFormData(
-                id="room-001",
-                name="Office A",
-                length_ft=20,
-                width_ft=15,
-                ceiling_height_ft=10,
-            )
-        )
-
-        # Add image metadata
-        img_id = "test-img-001"
-        session.images.append(
-            ImageFormData(
-                id=img_id,
-                filename="test.jpg",
-                room_id="room-001",
-            )
-        )
-
-        # Store actual image bytes
-        test_image = Image.new("RGB", (100, 100), color="red")
-        img_bytes = io.BytesIO()
-        test_image.save(img_bytes, format="PNG")
-        image_store.store(img_id, img_bytes.getvalue())
-
-        yield session
-
-        # Cleanup
-        image_store.clear()
-
-    def test_pipeline_execute_success(self, pipeline, valid_session):
-        """Test successful pipeline execution."""
-        progress_updates = []
-
-        def progress_callback(prog):
-            progress_updates.append(prog)
-
-        result = pipeline.execute(
-            session=valid_session,
-            progress_callback=progress_callback,
-        )
-
-        assert isinstance(result, PipelineResult)
-        assert result.success is True
-        assert result.document is not None
-        assert len(result.annotated_images) > 0
-        assert result.execution_time_seconds > 0
-        assert len(progress_updates) > 0
-
-    def test_pipeline_execute_missing_project_name(self, pipeline):
-        """Test pipeline fails with missing project name."""
-        session = SessionState()
-        # No project name set
-
-        result = pipeline.execute(session=session)
-
-        assert result.success is False
-        assert len(result.errors) > 0
-        assert any("project" in e.lower() for e in result.errors)
-
-    def test_pipeline_execute_missing_images(self, pipeline):
-        """Test pipeline fails with missing image bytes."""
-        session = SessionState()
-        session.project.project_name = "Test"
-        session.project.address = "123 Main"
-        session.project.city = "City"
-        session.project.state = "ST"
-        session.project.zip_code = "12345"
-        session.project.client_name = "Client"
-        session.project.fire_date = "2024-01-01"
-        session.project.assessment_date = "2024-01-02"
-        session.project.assessor_name = "Assessor"
-
-        session.rooms.append(
-            RoomFormData(id="r1", name="Room", length_ft=10, width_ft=10, ceiling_height_ft=10)
-        )
-        session.images.append(
-            ImageFormData(id="missing-img", filename="missing.jpg", room_id="r1")
-        )
-        # Don't store image bytes
-
-        result = pipeline.execute(session=session)
-
-        assert result.success is False
-        assert any("image" in e.lower() or "upload" in e.lower() for e in result.errors)
-
-    def test_pipeline_generates_stats(self, pipeline, valid_session):
-        """Test pipeline generates stats dictionary."""
-        result = pipeline.execute(session=valid_session)
-
-        stats = pipeline.generate_stats_dict(result)
-
-        assert "project_name" in stats
-        assert "total_rooms" in stats
-        assert "air_scrubbers_required" in stats
-        assert "execution_time" in stats
-
-    def test_pipeline_progress_stages(self, pipeline, valid_session):
-        """Test pipeline reports all 6 stages."""
-        stages_seen = set()
-
-        def progress_callback(prog):
-            stages_seen.add(prog.stage)
-
-        pipeline.execute(
-            session=valid_session,
-            progress_callback=progress_callback,
-        )
-
-        # Should see stages 1-6
-        assert len(stages_seen) >= 5  # At least most stages
-
-
-class TestIntegration:
-    """Integration tests for pipeline with RAG."""
-
-    def test_calculator_with_session(self):
-        """Test calculator with real session data."""
-        session = SessionState()
-        session.project.facility_classification = "non-operational"
-        session.project.construction_era = "pre-1980"
-        session.rooms.append(
-            RoomFormData(
-                id="r1",
-                name="Room 1",
-                length_ft=100,
-                width_ft=50,
-                ceiling_height_ft=15,
-            )
-        )
-
-        calc = FDAMCalculator()
-        results = calc.calculate_from_session(session)
-
-        assert results["total_area_sf"] == 5000
-        assert results["total_volume_cf"] == 75000
-        assert results["air_filtration"].units_required > 0
-        assert results["regulatory_flags"].lbp_survey_required is True
-        assert results["metals_thresholds"].lead_ug_100cm2 == 22.0

tests/test_rag.py

@@ -1,536 +0,0 @@
-"""Tests for RAG (Retrieval Augmented Generation) components."""
-
-import pytest
-from pathlib import Path
-import tempfile
-import shutil
-
-from rag.chunker import SemanticChunker, Chunk, chunk_file
-from rag.vectorstore import ChromaVectorStore, MockEmbeddingFunction
-from rag.retriever import FDAMRetriever, MockReranker, RetrievalResult
-
-
-class TestSemanticChunker:
-    """Test semantic chunker with table preservation."""
-
-    def test_chunk_simple_document(self):
-        """Test chunking a simple markdown document."""
-        text = """## Introduction
-
-This is the introduction paragraph with some content.
-
-## Section One
-
-This section contains important information about the topic.
-It has multiple sentences to form a proper paragraph.
-
-## Section Two
-
-Another section with different content here.
-"""
-        chunker = SemanticChunker()
-        chunks = chunker.chunk_document(
-            text=text,
-            source="test.md",
-            category="methodology",
-            priority="primary",
-        )
-
-        assert len(chunks) >= 1
-        assert all(isinstance(c, Chunk) for c in chunks)
-        assert all(c.source == "test.md" for c in chunks)
-        assert all(c.category == "methodology" for c in chunks)
-        assert all(c.priority == "primary" for c in chunks)
-
-    def test_preserve_tables(self):
-        """Test that tables are kept intact and not split."""
-        text = """## Thresholds
-
-| Material | Threshold | Unit |
-|----------|-----------|------|
-| Lead | 22 | µg/100cm² |
-| Cadmium | 3.3 | µg/100cm² |
-| Arsenic | 6.7 | µg/100cm² |
-
-## Next Section
-
-Some content after the table.
-"""
-        chunker = SemanticChunker()
-        chunks = chunker.chunk_document(
-            text=text,
-            source="thresholds.md",
-            category="thresholds",
-            priority="reference-threshold",
-        )
-
-        # Find the table chunk
-        table_chunks = [c for c in chunks if c.content_type == "table"]
-        assert len(table_chunks) >= 1
-
-        # Table should be complete
-        table_chunk = table_chunks[0]
-        assert "Lead" in table_chunk.text
-        assert "Cadmium" in table_chunk.text
-        assert "Arsenic" in table_chunk.text
-        assert "|" in table_chunk.text
-
-    def test_extract_keywords(self):
-        """Test keyword extraction from text."""
-        text = """## Zone Classification
-
-The burn zone shows heavy soot deposits and structural damage.
-Lead contamination requires HEPA vacuum cleaning per OSHA standards.
-"""
-        chunker = SemanticChunker()
-        chunks = chunker.chunk_document(
-            text=text,
-            source="zones.md",
-            category="methodology",
-            priority="primary",
-        )
-
-        # Should extract relevant keywords
-        all_keywords = []
-        for chunk in chunks:
-            all_keywords.extend(chunk.keywords)
-
-        # Check for expected domain keywords
-        keyword_set = set(all_keywords)
-        assert "burn zone" in keyword_set or "heavy" in keyword_set
-        assert "soot" in keyword_set or "structural damage" in keyword_set
-
-    def test_chunk_metadata(self):
-        """Test chunk metadata conversion."""
-        chunk = Chunk(
-            id="test_001",
-            text="Test content",
-            source="test.md",
-            category="methodology",
-            section="## Section 1",
-            priority="primary",
-            content_type="narrative",
-            keywords=["lead", "soot"],
-        )
-
-        metadata = chunk.to_metadata()
-
-        assert metadata["source"] == "test.md"
-        assert metadata["category"] == "methodology"
-        assert metadata["priority"] == "primary"
-        assert metadata["content_type"] == "narrative"
-        assert "lead" in metadata["keywords"]
-        assert "soot" in metadata["keywords"]
-
-    def test_split_by_headers(self):
-        """Test section splitting by markdown headers."""
-        text = """## Section One
-
-Content one.
-
-### Subsection A
-
-Content A.
-
-## Section Two
-
-Content two.
-"""
-        chunker = SemanticChunker()
-        sections = chunker._split_by_headers(text)
-
-        # Should have at least 3 sections (Introduction + 2 main + 1 sub)
-        assert len(sections) >= 2
-        headers = [s[0] for s in sections]
-        assert any("Section One" in h for h in headers)
-        assert any("Section Two" in h for h in headers)
-
-
-class TestMockEmbeddingFunction:
-    """Test mock embedding function."""
-
-    def test_embedding_dimension(self):
-        """Test that embeddings have correct dimension."""
-        mock = MockEmbeddingFunction()
-        embeddings = mock(["test text"])
-
-        assert len(embeddings) == 1
-        assert len(embeddings[0]) == mock.EMBEDDING_DIM
-
-    def test_deterministic_embeddings(self):
-        """Test that same text produces same embedding."""
-        mock = MockEmbeddingFunction()
-        text = "This is a test sentence."
-
-        emb1 = mock([text])[0]
-        emb2 = mock([text])[0]
-
-        assert emb1 == emb2
-
-    def test_different_texts_different_embeddings(self):
-        """Test that different texts produce different embeddings."""
-        mock = MockEmbeddingFunction()
-
-        emb1 = mock(["First text"])[0]
-        emb2 = mock(["Second text"])[0]
-
-        assert emb1 != emb2
-
-    def test_batch_embeddings(self):
-        """Test embedding multiple texts at once."""
-        mock = MockEmbeddingFunction()
-        texts = ["Text one", "Text two", "Text three"]
-
-        embeddings = mock(texts)
-
-        assert len(embeddings) == 3
-        assert all(len(e) == mock.EMBEDDING_DIM for e in embeddings)
-
-
-class TestChromaVectorStore:
-    """Test ChromaDB vector store."""
-
-    @pytest.fixture
-    def temp_dir(self):
-        """Create a temporary directory for ChromaDB."""
-        temp = tempfile.mkdtemp()
-        yield temp
-        shutil.rmtree(temp)
-
-    @pytest.fixture
-    def vectorstore(self, temp_dir):
-        """Create a test vector store."""
-        return ChromaVectorStore(
-            persist_directory=temp_dir,
-            embedding_function=MockEmbeddingFunction(),
-        )
-
-    @pytest.fixture
-    def sample_chunks(self):
-        """Create sample chunks for testing."""
-        return [
-            Chunk(
-                id="chunk_001",
-                text="Lead threshold for non-operational facilities is 22 µg/100cm².",
-                source="fdam.md",
-                category="thresholds",
-                section="## 1.4 Thresholds",
-                priority="primary",
-                content_type="narrative",
-                keywords=["lead", "non-operational"],
-            ),
-            Chunk(
-                id="chunk_002",
-                text="Burn zone requires structural assessment before cleaning.",
-                source="fdam.md",
-                category="methodology",
-                section="## 4.1 Zone Classification",
-                priority="primary",
-                content_type="narrative",
-                keywords=["burn zone", "structural damage"],
-            ),
-            Chunk(
-                id="chunk_003",
-                text="HEPA vacuum is required for soot removal.",
-                source="cleaning.md",
-                category="cleaning-procedures",
-                section="## 3.2 Methods",
-                priority="reference-narrative",
-                content_type="narrative",
-                keywords=["hepa", "vacuum", "soot"],
-            ),
-        ]
-
-    def test_add_chunks(self, vectorstore, sample_chunks):
-        """Test adding chunks to vector store."""
-        count = vectorstore.add_chunks(sample_chunks)
-        assert count == 3
-
-        stats = vectorstore.get_stats()
-        assert stats["total_chunks"] == 3
-
-    def test_query_returns_results(self, vectorstore, sample_chunks):
-        """Test querying the vector store."""
-        vectorstore.add_chunks(sample_chunks)
-
-        results = vectorstore.query("lead threshold", n_results=2)
-
-        assert len(results) <= 2
-        assert all("id" in r for r in results)
-        assert all("document" in r for r in results)
-        assert all("metadata" in r for r in results)
-        assert all("distance" in r for r in results)
-
-    def test_query_with_metadata_filter(self, vectorstore, sample_chunks):
-        """Test querying with metadata filter."""
-        vectorstore.add_chunks(sample_chunks)
-
-        results = vectorstore.query(
-            "cleaning method",
-            n_results=5,
-            where={"priority": "primary"},
-        )
-
-        # All results should have primary priority
-        for r in results:
-            assert r["metadata"]["priority"] == "primary"
-
-    def test_clear_collection(self, vectorstore, sample_chunks):
-        """Test clearing the collection."""
-        vectorstore.add_chunks(sample_chunks)
-        assert vectorstore.get_stats()["total_chunks"] == 3
-
-        vectorstore.clear()
-        assert vectorstore.get_stats()["total_chunks"] == 0
-
-    def test_delete_by_source(self, vectorstore, sample_chunks):
-        """Test deleting chunks by source."""
-        vectorstore.add_chunks(sample_chunks)
-
-        deleted = vectorstore.delete_by_source("fdam.md")
-        assert deleted == 2  # Two chunks from fdam.md
-
-        stats = vectorstore.get_stats()
-        assert stats["total_chunks"] == 1
-
-    def test_get_stats(self, vectorstore, sample_chunks):
-        """Test getting collection statistics."""
-        vectorstore.add_chunks(sample_chunks)
-
-        stats = vectorstore.get_stats()
-
-        assert stats["total_chunks"] == 3
-        assert "thresholds" in stats["categories"]
-        assert "methodology" in stats["categories"]
-        assert "primary" in stats["priorities"]
-        assert "reference-narrative" in stats["priorities"]
-
-
-class TestMockReranker:
-    """Test mock reranker."""
-
-    def test_rerank_returns_scores(self):
-        """Test that reranker returns scores."""
-        reranker = MockReranker()
-        query = "lead threshold contamination"
-        documents = [
-            "Lead threshold for facilities is 22 µg/100cm².",
-            "The weather is nice today.",
-            "Contamination levels require assessment.",
-        ]
-
-        scores = reranker.rerank(query, documents)
-
-        assert len(scores) == 3
-        assert all(0 <= s <= 1 for s in scores)
-
-    def test_relevant_doc_higher_score(self):
-        """Test that more relevant docs get higher scores."""
-        reranker = MockReranker()
-        query = "lead threshold"
-        documents = [
-            "Lead threshold is 22 µg.",  # Very relevant
-            "Weather forecast for tomorrow.",  # Not relevant
-        ]
-
-        scores = reranker.rerank(query, documents)
-
-        # First doc should have higher score (shares more words)
-        assert scores[0] > scores[1]
-
-
-class TestFDAMRetriever:
-    """Test FDAM retriever with priority weighting."""
-
-    @pytest.fixture
-    def temp_dir(self):
-        """Create a temporary directory."""
-        temp = tempfile.mkdtemp()
-        yield temp
-        shutil.rmtree(temp)
-
-    @pytest.fixture
-    def retriever(self, temp_dir):
-        """Create a test retriever with sample data."""
-        vectorstore = ChromaVectorStore(
-            persist_directory=temp_dir,
-            embedding_function=MockEmbeddingFunction(),
-        )
-
-        # Add sample chunks
-        chunks = [
-            Chunk(
-                id="primary_001",
-                text="Lead threshold for non-operational is 22 µg/100cm² per FDAM.",
-                source="fdam.md",
-                category="thresholds",
-                section="## Thresholds",
-                priority="primary",
-                content_type="narrative",
-                keywords=["lead", "threshold", "non-operational"],
-            ),
-            Chunk(
-                id="ref_001",
-                text="Lead clearance levels from BNL SOP.",
-                source="bnl.md",
-                category="thresholds",
-                section="## Attachment 9.3",
-                priority="reference-threshold",
-                content_type="table",
-                keywords=["lead", "clearance"],
-            ),
-            Chunk(
-                id="ref_002",
-                text="General cleaning procedures for soot removal.",
-                source="cleaning.md",
-                category="cleaning-procedures",
-                section="## Methods",
-                priority="reference-narrative",
-                content_type="narrative",
-                keywords=["cleaning", "soot"],
-            ),
-        ]
-        vectorstore.add_chunks(chunks)
-
-        return FDAMRetriever(
-            vectorstore=vectorstore,
-            reranker=MockReranker(),
-            use_reranking=True,
-        )
-
-    def test_retrieve_returns_results(self, retriever):
-        """Test basic retrieval."""
-        results = retriever.retrieve("lead threshold", top_k=3)
-
-        assert len(results) <= 3
-        assert all(isinstance(r, RetrievalResult) for r in results)
-
-    def test_priority_weighting(self, retriever):
-        """Test that primary sources get higher weight."""
-        results = retriever.retrieve("lead threshold", top_k=3)
-
-        # Find primary and reference results
-        primary_results = [r for r in results if r.priority == "primary"]
-        ref_results = [r for r in results if r.priority != "primary"]
-
-        if primary_results and ref_results:
-            # Primary should have higher weighted score (before reranking)
-            # Note: final_score includes reranking which may change order
-            primary = primary_results[0]
-            ref = ref_results[0]
-
-            # With similar similarity, primary weight (1.0) > ref weight (0.8-0.9)
-            # This test validates the weighting is applied
-            assert primary.weighted_score > 0
-
-    def test_category_filter(self, retriever):
-        """Test filtering by category."""
-        results = retriever.retrieve(
-            "cleaning method",
-            top_k=5,
-            category_filter="cleaning-procedures",
-        )
-
-        for r in results:
-            assert r.category == "cleaning-procedures"
-
-    def test_priority_filter(self, retriever):
-        """Test filtering by priority."""
-        results = retriever.retrieve(
-            "threshold",
-            top_k=5,
-            priority_filter="primary",
-        )
-
-        for r in results:
-            assert r.priority == "primary"
-
-    def test_retrieve_for_context(self, retriever):
-        """Test context string generation."""
-        context = retriever.retrieve_for_context("lead threshold", top_k=2)
-
-        assert isinstance(context, str)
-        assert "Source:" in context or "No relevant context" in context
-
-    def test_retrieve_thresholds(self, retriever):
-        """Test threshold-specific retrieval."""
-        results = retriever.retrieve_thresholds(
-            material_type="lead",
-            facility_type="non-operational",
-        )
-
-        assert len(results) <= 3
-        # Should filter to thresholds category
-        for r in results:
-            assert r.category == "thresholds"
-
-    def test_retrieve_disposition(self, retriever):
-        """Test disposition-specific retrieval."""
-        results = retriever.retrieve_disposition(
-            zone="burn-zone",
-            condition="heavy",
-        )
-
-        # Should prefer primary sources
-        if results:
-            assert results[0].priority == "primary"
-
-    def test_result_to_dict(self, retriever):
-        """Test RetrievalResult to_dict method."""
-        results = retriever.retrieve("test", top_k=1)
-
-        if results:
-            result_dict = results[0].to_dict()
-            assert "chunk_id" in result_dict
-            assert "text" in result_dict
-            assert "source" in result_dict
-            assert "similarity_score" in result_dict
-            assert "final_score" in result_dict
-
-    def test_empty_query_handling(self, retriever):
-        """Test handling of query with no good matches."""
-        results = retriever.retrieve(
-            "completely unrelated xyz123",
-            top_k=5,
-            category_filter="thresholds",
-        )
-
-        # Should still return results (just lower scores)
-        assert isinstance(results, list)
-
-
-class TestChunkFile:
-    """Test the chunk_file convenience function."""
-
-    @pytest.fixture
-    def temp_md_file(self):
-        """Create a temporary markdown file."""
-        temp = tempfile.NamedTemporaryFile(
-            mode="w",
-            suffix=".md",
-            delete=False,
-            encoding="utf-8",
-        )
-        temp.write("""## Test Document
-
-This is test content for chunking.
-
-| Column A | Column B |
-|----------|----------|
-| Value 1 | Value 2 |
-""")
-        temp.close()
-        yield Path(temp.name)
-        Path(temp.name).unlink()
-
-    def test_chunk_file(self, temp_md_file):
-        """Test chunking a file directly."""
-        chunks = chunk_file(
-            filepath=temp_md_file,
-            category="methodology",
-            priority="primary",
-        )
-
-        assert len(chunks) >= 1
-        assert all(c.source == temp_md_file.name for c in chunks)
-        assert all(c.category == "methodology" for c in chunks)

tests/test_samples.py

@@ -1,296 +0,0 @@
-"""Tests for sample room data module."""
-
-import pytest
-from pathlib import Path
-
-from ui.samples import (
-    SAMPLE_SCENARIOS,
-    SAMPLE_SCENARIOS_BY_ID,
-    SAMPLE_IMAGES_DIR,
-    get_sample_choices,
-    load_sample,
-    load_sample_images,
-    get_scenario_by_id,
-)
-from ui.state import SessionState
-from ui.components import image_store
-
-
-class TestSampleScenarios:
-    """Test sample scenario definitions."""
-
-    def test_four_scenarios_defined(self):
-        """Verify exactly 4 sample scenarios are defined."""
-        assert len(SAMPLE_SCENARIOS) == 4
-
-    def test_scenario_ids_unique(self):
-        """Verify all scenario IDs are unique."""
-        ids = [s.id for s in SAMPLE_SCENARIOS]
-        assert len(ids) == len(set(ids))
-
-    def test_scenario_ids_expected(self):
-        """Verify expected scenario IDs exist."""
-        expected_ids = {"bar_dining", "bar_area", "kitchen", "factory"}
-        actual_ids = set(SAMPLE_SCENARIOS_BY_ID.keys())
-        assert actual_ids == expected_ids
-
-    def test_all_scenarios_have_required_fields(self):
-        """Verify all scenarios have required data fields."""
-        for scenario in SAMPLE_SCENARIOS:
-            # Basic fields
-            assert scenario.id
-            assert scenario.name
-            assert scenario.description
-            assert scenario.image_files
-
-            # Project data required fields
-            assert "project_name" in scenario.project_data
-            assert "address" in scenario.project_data
-            assert "city" in scenario.project_data
-            assert "state" in scenario.project_data
-            assert "zip_code" in scenario.project_data
-            assert "client_name" in scenario.project_data
-            assert "fire_date" in scenario.project_data
-            assert "assessment_date" in scenario.project_data
-            assert "facility_classification" in scenario.project_data
-            assert "construction_era" in scenario.project_data
-            assert "assessor_name" in scenario.project_data
-
-            # Room data required fields
-            assert "name" in scenario.room_data
-            assert "length_ft" in scenario.room_data
-            assert "width_ft" in scenario.room_data
-            assert "ceiling_height_ft" in scenario.room_data
-
-            # Observations should have smoke/fire odor at minimum
-            assert "smoke_fire_odor" in scenario.observations_data
-
-
-class TestSampleImages:
-    """Test sample image file existence."""
-
-    def test_sample_images_dir_exists(self):
-        """Verify sample images directory exists."""
-        assert SAMPLE_IMAGES_DIR.exists()
-        assert SAMPLE_IMAGES_DIR.is_dir()
-
-    def test_all_referenced_images_exist(self):
-        """Verify all images referenced in scenarios exist on disk."""
-        missing_files = []
-        for scenario in SAMPLE_SCENARIOS:
-            for filename in scenario.image_files:
-                filepath = SAMPLE_IMAGES_DIR / filename
-                if not filepath.exists():
-                    missing_files.append(f"{scenario.id}: {filename}")
-
-        assert not missing_files, f"Missing image files: {missing_files}"
-
-    def test_bar_dining_has_3_images(self):
-        """Verify Bar & Dining scenario has 3 images."""
-        scenario = SAMPLE_SCENARIOS_BY_ID["bar_dining"]
-        assert len(scenario.image_files) == 3
-
-    def test_bar_area_has_3_images(self):
-        """Verify Bar Area scenario has 3 images."""
-        scenario = SAMPLE_SCENARIOS_BY_ID["bar_area"]
-        assert len(scenario.image_files) == 3
-
-    def test_kitchen_has_6_images(self):
-        """Verify Kitchen scenario has 6 images."""
-        scenario = SAMPLE_SCENARIOS_BY_ID["kitchen"]
-        assert len(scenario.image_files) == 6
-
-    def test_factory_has_1_image(self):
-        """Verify Factory scenario has 1 image."""
-        scenario = SAMPLE_SCENARIOS_BY_ID["factory"]
-        assert len(scenario.image_files) == 1
-
-
-class TestGetSampleChoices:
-    """Test get_sample_choices function."""
-
-    def test_returns_list_of_tuples(self):
-        """Verify function returns list of (label, value) tuples."""
-        choices = get_sample_choices()
-        assert isinstance(choices, list)
-        for choice in choices:
-            assert isinstance(choice, tuple)
-            assert len(choice) == 2
-
-    def test_first_choice_is_placeholder(self):
-        """Verify first choice is the placeholder."""
-        choices = get_sample_choices()
-        label, value = choices[0]
-        assert "Select" in label
-        assert value == ""
-
-    def test_returns_5_choices(self):
-        """Verify returns 5 choices (1 placeholder + 4 scenarios)."""
-        choices = get_sample_choices()
-        assert len(choices) == 5
-
-    def test_all_scenario_ids_in_choices(self):
-        """Verify all scenario IDs appear in choices."""
-        choices = get_sample_choices()
-        values = [v for _, v in choices]
-        assert "bar_dining" in values
-        assert "bar_area" in values
-        assert "kitchen" in values
-        assert "factory" in values
-
-
-class TestLoadSample:
-    """Test load_sample function."""
-
-    def test_load_valid_scenario_returns_session(self):
-        """Verify loading valid scenario returns SessionState."""
-        session = load_sample("bar_dining")
-        assert session is not None
-        assert isinstance(session, SessionState)
-
-        # Cleanup
-        image_store.clear()
-
-    def test_load_invalid_scenario_returns_none(self):
-        """Verify loading invalid scenario returns None."""
-        session = load_sample("nonexistent_scenario")
-        assert session is None
-
-    def test_loaded_session_has_project_data(self):
-        """Verify loaded session has correct project data."""
-        session = load_sample("bar_dining")
-        assert session.project.project_name == "Sample: Bar & Dining Fire Assessment"
-        assert session.project.city == "Springfield"
-        assert session.project.state == "IL"
-
-        # Cleanup
-        image_store.clear()
-
-    def test_loaded_session_has_room(self):
-        """Verify loaded session has room data."""
-        session = load_sample("kitchen")
-        assert len(session.rooms) == 1
-        assert session.rooms[0].name == "Commercial Kitchen"
-        assert session.rooms[0].length_ft == 30.0
-        assert session.rooms[0].width_ft == 25.0
-
-        # Cleanup
-        image_store.clear()
-
-    def test_loaded_session_has_images(self):
-        """Verify loaded session has images loaded into store."""
-        session = load_sample("bar_area")
-        assert len(session.images) == 3
-
-        # Verify images are in store
-        for img in session.images:
-            assert image_store.get(img.id) is not None
-
-        # Cleanup
-        image_store.clear()
-
-    def test_loaded_session_has_observations(self):
-        """Verify loaded session has observations data."""
-        session = load_sample("factory")
-        assert session.observations.smoke_fire_odor is True
-        assert session.observations.odor_intensity == "strong"
-        assert session.observations.large_char_particles is True
-
-        # Cleanup
-        image_store.clear()
-
-    def test_loaded_session_tabs_marked_complete(self):
-        """Verify loaded session has tabs marked as complete."""
-        session = load_sample("bar_dining")
-        assert session.tab1_complete is True
-        assert session.tab2_complete is True
-        assert session.tab3_complete is True
-        assert session.tab4_complete is True
-
-        # Cleanup
-        image_store.clear()
-
-    def test_facility_classification_correct(self):
-        """Verify facility classifications are set correctly."""
-        # Restaurant scenarios should be non-operational
-        session = load_sample("bar_dining")
-        assert session.project.facility_classification == "non-operational"
-        image_store.clear()
-
-        # Factory should be operational
-        session = load_sample("factory")
-        assert session.project.facility_classification == "operational"
-        image_store.clear()
-
-    def test_construction_era_correct(self):
-        """Verify construction eras are set correctly."""
-        # Bar scenarios should be pre-1980
-        session = load_sample("bar_area")
-        assert session.project.construction_era == "pre-1980"
-        image_store.clear()
-
-        # Kitchen should be 1980-2000
-        session = load_sample("kitchen")
-        assert session.project.construction_era == "1980-2000"
-        image_store.clear()
-
-
-class TestGetScenarioById:
-    """Test get_scenario_by_id function."""
-
-    def test_returns_scenario_for_valid_id(self):
-        """Verify returns scenario for valid ID."""
-        scenario = get_scenario_by_id("kitchen")
-        assert scenario is not None
-        assert scenario.id == "kitchen"
-        assert scenario.name == "Kitchen"
-
-    def test_returns_none_for_invalid_id(self):
-        """Verify returns None for invalid ID."""
-        scenario = get_scenario_by_id("invalid_id")
-        assert scenario is None
-
-
-class TestLoadSampleImages:
-    """Test load_sample_images function."""
-
-    def test_loads_images_into_store(self):
-        """Verify images are loaded into image_store."""
-        scenario = SAMPLE_SCENARIOS_BY_ID["bar_dining"]
-        room_id = "test-room-123"
-
-        image_metas = load_sample_images(scenario, room_id)
-
-        assert len(image_metas) == 3
-        for meta in image_metas:
-            assert meta.room_id == room_id
-            assert image_store.get(meta.id) is not None
-
-        # Cleanup
-        image_store.clear()
-
-    def test_image_metadata_has_correct_room_id(self):
-        """Verify image metadata has correct room ID."""
-        scenario = SAMPLE_SCENARIOS_BY_ID["factory"]
-        room_id = "factory-room-456"
-
-        image_metas = load_sample_images(scenario, room_id)
-
-        assert len(image_metas) == 1
-        assert image_metas[0].room_id == room_id
-
-        # Cleanup
-        image_store.clear()
-
-    def test_image_ids_are_unique(self):
-        """Verify each loaded image gets a unique ID."""
-        scenario = SAMPLE_SCENARIOS_BY_ID["kitchen"]
-        room_id = "kitchen-room"
-
-        image_metas = load_sample_images(scenario, room_id)
-
-        ids = [meta.id for meta in image_metas]
-        assert len(ids) == len(set(ids))  # All unique
-
-        # Cleanup
-        image_store.clear()

tests/test_schemas.py

@@ -1,459 +0,0 @@
-"""Tests for FDAM AI Pipeline Pydantic schemas."""
-
-from datetime import date
-
-import pytest
-from pydantic import ValidationError
-
-from schemas import (
-    # Input models
-    AssessmentInput,
-    Dimensions,
-    ImageMetadata,
-    ProjectInfo,
-    QualitativeObservations,
-    Room,
-    Surface,
-    get_material_category,
-    # Output models
-    AirFiltration,
-    CalculationResults,
-    CombustionIndicators,
-    ConditionAnalysis,
-    ConfidenceReport,
-    DetectedMaterial,
-    EquipmentRequirements,
-    GeneratedDocuments,
-    LaborEstimate,
-    RegulatoryFlags,
-    SampleDensity,
-    SamplingRecommendation,
-    SurfaceAreas,
-    VisionAnalysisResult,
-    ZoneAnalysis,
-)
-
-
-# --- Input Schema Tests ---
-
-
-class TestMaterialCategory:
-    """Test material category helper function."""
-
-    def test_non_porous_materials(self):
-        assert get_material_category("steel") == "non-porous"
-        assert get_material_category("concrete") == "non-porous"
-        assert get_material_category("glass") == "non-porous"
-        assert get_material_category("metal") == "non-porous"
-        assert get_material_category("cmu") == "non-porous"
-
-    def test_semi_porous_materials(self):
-        assert get_material_category("drywall-painted") == "semi-porous"
-        assert get_material_category("drywall-unpainted") == "semi-porous"
-        assert get_material_category("wood-sealed") == "semi-porous"
-        assert get_material_category("wood-unsealed") == "semi-porous"
-
-    def test_porous_materials(self):
-        assert get_material_category("carpet") == "porous"
-        assert get_material_category("carpet-pad") == "porous"
-        assert get_material_category("insulation-fiberglass") == "porous"
-        assert get_material_category("acoustic-tile") == "porous"
-        assert get_material_category("upholstery") == "porous"
-
-    def test_hvac_materials(self):
-        assert get_material_category("ductwork-rigid") == "hvac"
-        assert get_material_category("ductwork-flexible") == "hvac"
-        assert get_material_category("hvac-interior-insulation") == "hvac"
-
-
-class TestDimensions:
-    """Test Dimensions model."""
-
-    def test_valid_dimensions(self):
-        dims = Dimensions(length_ft=100, width_ft=50, ceiling_height_ft=20)
-        assert dims.area_sf == 5000
-        assert dims.volume_cf == 100000
-
-    def test_invalid_zero_dimension(self):
-        with pytest.raises(ValidationError):
-            Dimensions(length_ft=0, width_ft=50, ceiling_height_ft=20)
-
-    def test_invalid_negative_dimension(self):
-        with pytest.raises(ValidationError):
-            Dimensions(length_ft=-10, width_ft=50, ceiling_height_ft=20)
-
-    def test_dimension_exceeds_max(self):
-        with pytest.raises(ValidationError):
-            Dimensions(length_ft=20000, width_ft=50, ceiling_height_ft=20)
-
-
-class TestSurface:
-    """Test Surface model."""
-
-    def test_valid_surface(self):
-        surface = Surface(
-            id="surf-001",
-            material="steel",
-            description="North wall steel panel",
-            area_sf=500,
-        )
-        assert surface.category == "non-porous"
-        assert surface.zone is None
-        assert surface.ai_detected is False
-
-    def test_surface_with_zone_and_condition(self):
-        surface = Surface(
-            id="surf-002",
-            material="carpet",
-            description="Main floor carpet",
-            area_sf=2000,
-            zone="near-field",
-            condition="moderate",
-            disposition="remove",
-        )
-        assert surface.category == "porous"
-        assert surface.zone == "near-field"
-        assert surface.condition == "moderate"
-        assert surface.disposition == "remove"
-
-    def test_invalid_material(self):
-        with pytest.raises(ValidationError):
-            Surface(
-                id="surf-003",
-                material="invalid-material",
-                description="Test surface",
-                area_sf=100,
-            )
-
-
-class TestRoom:
-    """Test Room model."""
-
-    def test_valid_room(self):
-        room = Room(
-            id="room-001",
-            name="Warehouse Bay A",
-            dimensions=Dimensions(length_ft=100, width_ft=50, ceiling_height_ft=20),
-        )
-        assert room.zone_classification is None
-        assert len(room.surfaces) == 0
-        assert len(room.image_ids) == 0
-
-    def test_room_with_surfaces(self):
-        room = Room(
-            id="room-002",
-            name="Office Space",
-            floor="Ground Floor",
-            dimensions=Dimensions(length_ft=30, width_ft=20, ceiling_height_ft=10),
-            zone_classification="far-field",
-            zone_confidence=0.85,
-            surfaces=[
-                Surface(
-                    id="surf-001",
-                    material="drywall-painted",
-                    description="North wall",
-                    area_sf=300,
-                ),
-                Surface(
-                    id="surf-002",
-                    material="carpet",
-                    description="Floor carpet",
-                    area_sf=600,
-                ),
-            ],
-        )
-        assert len(room.surfaces) == 2
-        assert room.zone_classification == "far-field"
-
-
-class TestProjectInfo:
-    """Test ProjectInfo model."""
-
-    def test_valid_project_info(self):
-        project = ProjectInfo(
-            project_name="ABC Warehouse Fire",
-            address="123 Main Street",
-            city="Springfield",
-            state="IL",
-            zip_code="62701",
-            client_name="ABC Industries",
-            fire_date=date(2024, 12, 15),
-            assessment_date=date(2024, 12, 20),
-            facility_classification="non-operational",
-            construction_era="post-2000",
-            assessor_name="John Smith",
-            assessor_credentials="CIH",
-        )
-        assert project.project_name == "ABC Warehouse Fire"
-        assert project.facility_classification == "non-operational"
-
-    def test_missing_required_field(self):
-        with pytest.raises(ValidationError):
-            ProjectInfo(
-                project_name="Test Project",
-                # Missing address and other required fields
-            )
-
-
-class TestQualitativeObservations:
-    """Test QualitativeObservations model."""
-
-    def test_minimal_observations(self):
-        obs = QualitativeObservations(
-            smoke_fire_odor=True,
-            visible_soot_deposits=True,
-            large_char_particles=False,
-            ash_like_residue=False,
-            surface_discoloration=True,
-            dust_loading_interference=False,
-            wildfire_indicators=False,
-        )
-        assert obs.smoke_fire_odor is True
-        assert obs.odor_intensity is None
-
-    def test_full_observations(self):
-        obs = QualitativeObservations(
-            smoke_fire_odor=True,
-            odor_intensity="strong",
-            visible_soot_deposits=True,
-            soot_pattern_description="Heavy deposits on ceiling",
-            large_char_particles=True,
-            char_density_estimate="moderate",
-            ash_like_residue=True,
-            ash_color_texture="Gray powdery residue",
-            surface_discoloration=True,
-            discoloration_description="Yellowing on walls",
-            dust_loading_interference=False,
-            wildfire_indicators=False,
-            additional_notes="Structural engineer review recommended",
-        )
-        assert obs.odor_intensity == "strong"
-        assert obs.char_density_estimate == "moderate"
-
-
-class TestAssessmentInput:
-    """Test complete AssessmentInput model."""
-
-    @pytest.fixture
-    def sample_project(self):
-        return ProjectInfo(
-            project_name="Test Project",
-            address="123 Test St",
-            city="TestCity",
-            state="TX",
-            zip_code="12345",
-            client_name="Test Client",
-            fire_date=date(2024, 12, 1),
-            assessment_date=date(2024, 12, 15),
-            facility_classification="operational",
-            construction_era="1980-2000",
-            assessor_name="Test Assessor",
-        )
-
-    @pytest.fixture
-    def sample_room(self):
-        return Room(
-            id="room-001",
-            name="Test Room",
-            dimensions=Dimensions(length_ft=50, width_ft=30, ceiling_height_ft=12),
-        )
-
-    @pytest.fixture
-    def sample_observations(self):
-        return QualitativeObservations(
-            smoke_fire_odor=True,
-            visible_soot_deposits=True,
-            large_char_particles=False,
-            ash_like_residue=False,
-            surface_discoloration=False,
-            dust_loading_interference=False,
-            wildfire_indicators=False,
-        )
-
-    def test_valid_assessment_input(self, sample_project, sample_room, sample_observations):
-        assessment = AssessmentInput(
-            project=sample_project,
-            rooms=[sample_room],
-            observations=sample_observations,
-        )
-        assert len(assessment.rooms) == 1
-        assert len(assessment.images) == 0
-
-    def test_duplicate_room_ids(self, sample_project, sample_room, sample_observations):
-        room2 = Room(
-            id="room-001",  # Same ID as sample_room
-            name="Duplicate Room",
-            dimensions=Dimensions(length_ft=20, width_ft=20, ceiling_height_ft=10),
-        )
-        with pytest.raises(ValidationError) as exc_info:
-            AssessmentInput(
-                project=sample_project,
-                rooms=[sample_room, room2],
-                observations=sample_observations,
-            )
-        assert "Room IDs must be unique" in str(exc_info.value)
-
-    def test_image_references_invalid_room(self, sample_project, sample_room, sample_observations):
-        image = ImageMetadata(
-            id="img-001",
-            filename="test.jpg",
-            room_id="nonexistent-room",
-        )
-        with pytest.raises(ValidationError) as exc_info:
-            AssessmentInput(
-                project=sample_project,
-                rooms=[sample_room],
-                images=[image],
-                observations=sample_observations,
-            )
-        assert "references unknown room" in str(exc_info.value)
-
-    def test_valid_image_reference(self, sample_project, sample_room, sample_observations):
-        image = ImageMetadata(
-            id="img-001",
-            filename="test.jpg",
-            room_id="room-001",
-        )
-        assessment = AssessmentInput(
-            project=sample_project,
-            rooms=[sample_room],
-            images=[image],
-            observations=sample_observations,
-        )
-        assert len(assessment.images) == 1
-
-
-# --- Output Schema Tests ---
-
-
-class TestVisionAnalysisResult:
-    """Test VisionAnalysisResult output model."""
-
-    def test_valid_vision_result(self):
-        result = VisionAnalysisResult(
-            zone=ZoneAnalysis(
-                classification="near-field",
-                confidence=0.85,
-                reasoning="Heavy soot deposits visible on surfaces",
-            ),
-            condition=ConditionAnalysis(
-                level="moderate",
-                confidence=0.80,
-                reasoning="Visible film on surfaces",
-            ),
-            materials=[
-                DetectedMaterial(
-                    type="steel",
-                    category="non-porous",
-                    confidence=0.90,
-                    location_description="Ceiling structure",
-                ),
-            ],
-            combustion_indicators=CombustionIndicators(
-                soot_visible=True,
-                soot_pattern="Heavy deposits on horizontal surfaces",
-                char_visible=False,
-                ash_visible=True,
-                ash_description="Gray powdery residue",
-            ),
-            structural_concerns=["Beam deflection observed"],
-            access_issues=["High ceiling requires lift access"],
-            recommended_sampling_locations=[
-                SamplingRecommendation(
-                    description="Center of contamination",
-                    sample_type="tape_lift",
-                    priority="high",
-                ),
-            ],
-            flags_for_review=["Zone boundary unclear"],
-        )
-        assert result.zone.classification == "near-field"
-        assert len(result.materials) == 1
-        assert result.combustion_indicators.soot_visible is True
-
-
-class TestCalculationResults:
-    """Test CalculationResults output model."""
-
-    def test_valid_calculation_results(self):
-        results = CalculationResults(
-            surface_areas=SurfaceAreas(
-                by_type={"steel": 5000, "carpet": 3000},
-                by_disposition={"clean": 5000, "remove": 3000},
-                total_floor_sf=8000,
-                total_surface_sf=8000,
-                total_volume_cf=160000,
-            ),
-            air_filtration=AirFiltration(
-                total_volume_cf=160000,
-                required_ach=4,
-                unit_cfm=2000,
-                units_required=6,
-                calculation="(160,000 CF x 4 ACH) / (2000 CFM x 60) = 6 units",
-            ),
-            sample_density=SampleDensity(
-                total_sf=8000,
-                size_category="5,000 - 25,000 SF",
-                surface_types_count=2,
-                surface_types=["steel", "carpet"],
-                tape_lifts_per_type="5-10",
-                surface_wipes_per_type="5-10",
-                recommended_tape_lifts=20,
-                recommended_surface_wipes=20,
-            ),
-            labor_estimate=LaborEstimate(
-                hepa_vacuum=10,
-                wet_wipe=25,
-                removal=15,
-                total_hours=50,
-            ),
-            equipment=EquipmentRequirements(
-                air_scrubbers=6,
-                hepa_vacuums=2,
-            ),
-            regulatory_flags=RegulatoryFlags(),
-        )
-        assert results.air_filtration.units_required == 6
-        assert results.labor_estimate.total_hours == 50
-
-
-class TestConfidenceReport:
-    """Test ConfidenceReport output model."""
-
-    def test_high_confidence_report(self):
-        report = ConfidenceReport(
-            flagged_items=[],
-            overall_confidence=0.92,
-            review_required=False,
-        )
-        assert report.review_required is False
-
-    def test_low_confidence_report(self):
-        from schemas import FlaggedItem
-
-        report = ConfidenceReport(
-            flagged_items=[
-                FlaggedItem(
-                    type="zone_classification",
-                    room="Warehouse Bay A",
-                    confidence=0.55,
-                    recommendation="Professional review recommended",
-                ),
-            ],
-            overall_confidence=0.55,
-            review_required=True,
-        )
-        assert report.review_required is True
-        assert len(report.flagged_items) == 1
-
-
-class TestGeneratedDocuments:
-    """Test GeneratedDocuments output model."""
-
-    def test_valid_documents(self):
-        docs = GeneratedDocuments(
-            cleaning_specification_md="# Cleaning Specification\n\n## Scope of Work...",
-            sampling_plan_md="# Sampling Plan\n\n## Recommendations...",
-            confidence_report_md="# Confidence Report\n\n## Summary...",
-        )
-        assert "Cleaning Specification" in docs.cleaning_specification_md

tests/test_tabs.py

@@ -1,401 +0,0 @@
-"""Tests for tab UI modules."""
-
-import pytest
-from PIL import Image
-import io
-
-from ui.state import SessionState, RoomFormData, ImageFormData
-from ui.tabs import project, rooms, images, observations, results
-from ui.components import image_store
-
-
-class TestProjectTab:
-    """Test Tab 1: Project Info."""
-
-    def test_update_session_from_form(self):
-        session = SessionState()
-        session = project.update_session_from_form(
-            session,
-            project_name="Test Project",
-            address="123 Main St",
-            city="Springfield",
-            state="IL",
-            zip_code="62701",
-            client_name="Test Client",
-            fire_date="2024-12-01",
-            assessment_date="2024-12-15",
-            facility_classification="Operational",
-            construction_era="Pre-1980",
-            assessor_name="John Smith",
-            assessor_credentials=["CIH"],
-        )
-
-        assert session.project.project_name == "Test Project"
-        assert session.project.facility_classification == "operational"
-        assert session.project.construction_era == "pre-1980"
-
-    def test_validate_and_continue_incomplete(self):
-        session = SessionState()
-        session, html, tab_index = project.validate_and_continue(
-            session,
-            project_name="",  # Missing
-            address="123 Main",
-            city="City",
-            state="IL",
-            zip_code="12345",
-            client_name="Client",
-            fire_date="2024-01-01",
-            assessment_date="2024-01-02",
-            facility_classification="Non-Operational",
-            construction_era="Post-2000",
-            assessor_name="Name",
-            assessor_credentials=[],
-        )
-
-        assert tab_index["selected"] == 0  # Stay on tab (Gradio update dict)
-        assert "Project name is required" in html
-        assert session.tab1_complete is False
-
-    def test_validate_and_continue_complete(self):
-        session = SessionState()
-        session, html, tab_index = project.validate_and_continue(
-            session,
-            project_name="Test",
-            address="123 Main",
-            city="City",
-            state="IL",
-            zip_code="12345",
-            client_name="Client",
-            fire_date="2024-01-01",
-            assessment_date="2024-01-02",
-            facility_classification="Non-Operational",
-            construction_era="Post-2000",
-            assessor_name="Name",
-            assessor_credentials=[],
-        )
-
-        assert tab_index["selected"] == 1  # Go to next tab (Gradio update dict)
-        assert "✓" in html
-        assert session.tab1_complete is True
-
-    def test_load_form_from_session(self):
-        session = SessionState()
-        session.project.project_name = "Loaded Project"
-        session.project.facility_classification = "public-childcare"
-        session.project.construction_era = "1980-2000"
-
-        values = project.load_form_from_session(session)
-
-        assert values[0] == "Loaded Project"  # project_name
-        assert values[8] == "Public/Childcare"  # facility_classification (UI value)
-        assert values[9] == "1980-2000"  # construction_era (UI value)
-
-
-class TestRoomsTab:
-    """Test Tab 2: Building/Rooms."""
-
-    def test_add_room_valid(self):
-        session = SessionState()
-
-        result = rooms.add_room(
-            session,
-            name="Room 1",
-            floor="Ground Floor",
-            length=100.0,
-            width=50.0,
-            height_preset=20,  # Using preset value
-            height_custom=None,
-        )
-
-        session = result[0]
-        table_data = result[1]
-        validation_html = result[2]
-
-        assert len(session.rooms) == 1
-        assert session.rooms[0].name == "Room 1"
-        assert "✓" in validation_html
-        assert len(table_data) == 1
-
-    def test_add_room_invalid(self):
-        session = SessionState()
-
-        result = rooms.add_room(
-            session,
-            name="",  # Missing
-            floor=None,
-            length=0,  # Invalid
-            width=50.0,
-            height_preset=None,  # No height selected
-            height_custom=None,
-        )
-
-        session = result[0]
-        validation_html = result[2]
-
-        assert len(session.rooms) == 0
-        assert "Room name is required" in validation_html
-        assert "Length must be greater than 0" in validation_html
-
-    def test_remove_last_room(self):
-        session = SessionState()
-        session.rooms.append(RoomFormData(name="Room 1", length_ft=100, width_ft=50, ceiling_height_ft=20))
-        session.rooms.append(RoomFormData(name="Room 2", length_ft=75, width_ft=40, ceiling_height_ft=15))
-
-        session, table_data, html, count, area, volume = rooms.remove_last_room(session)
-
-        assert len(session.rooms) == 1
-        assert session.rooms[0].name == "Room 1"
-        assert "Room 2" in html
-
-    def test_validate_and_continue(self):
-        session = SessionState()
-        session.rooms.append(RoomFormData(name="Room 1", length_ft=100, width_ft=50, ceiling_height_ft=20))
-
-        session, html, tab_index = rooms.validate_and_continue(session)
-
-        assert tab_index["selected"] == 2  # Go to Images tab (Gradio update dict)
-        assert session.tab2_complete is True
-
-
-class MockFile:
-    """Mock file object for testing gr.Files uploads."""
-
-    def __init__(self, path: str):
-        self.name = path
-
-
-class TestImagesTab:
-    """Test Tab 3: Images."""
-
-    def test_add_image_valid(self, tmp_path):
-        session = SessionState()
-        session.rooms.append(RoomFormData(id="room-001", name="Room 1", length_ft=100, width_ft=50, ceiling_height_ft=20))
-
-        # Create a test image file
-        test_image = Image.new("RGB", (100, 100), color="red")
-        img_path = tmp_path / "test_image.png"
-        test_image.save(img_path)
-
-        # Create mock file object
-        mock_file = MockFile(str(img_path))
-
-        result = images.add_image(
-            session,
-            files=[mock_file],
-            room_id="room-001",
-            description="Test image",
-        )
-
-        session = result[0]
-        gallery_data = result[1]
-        validation_html = result[2]
-
-        assert len(session.images) == 1
-        assert session.images[0].room_id == "room-001"
-        assert "✓" in validation_html
-        # Image should be in store
-        assert image_store.get(session.images[0].id) is not None
-
-        # Cleanup
-        image_store.clear()
-
-    def test_add_image_no_room(self, tmp_path):
-        session = SessionState()
-
-        # Create a test image file
-        test_image = Image.new("RGB", (100, 100), color="red")
-        img_path = tmp_path / "test_image.png"
-        test_image.save(img_path)
-
-        mock_file = MockFile(str(img_path))
-
-        result = images.add_image(
-            session,
-            files=[mock_file],
-            room_id="",  # No room selected
-            description="",
-        )
-
-        session = result[0]
-        validation_html = result[2]
-
-        assert len(session.images) == 0
-        assert "select a room" in validation_html
-
-    def test_validate_missing_images(self):
-        session = SessionState()
-        session.rooms.append(RoomFormData(id="room-001", name="Room 1"))
-        # Add image metadata but don't store the actual image
-        session.images.append(ImageFormData(id="img-missing", filename="test.jpg", room_id="room-001"))
-
-        session, html, tab_index = images.validate_and_continue(session)
-
-        assert tab_index["selected"] == 2  # Stay on Images tab (Gradio update dict)
-        assert "re-uploaded" in html
-
-    def test_update_room_choices(self):
-        session = SessionState()
-        session.rooms.append(RoomFormData(id="room-001", name="Room 1"))
-        session.rooms.append(RoomFormData(id="room-002", name="Room 2"))
-
-        update = images.update_room_choices(session)
-
-        assert "choices" in update
-        assert len(update["choices"]) == 2
-
-
-class TestObservationsTab:
-    """Test Tab 4: Observations."""
-
-    def test_update_session_from_form(self):
-        session = SessionState()
-        session = observations.update_session_from_form(
-            session,
-            smoke_odor=True,
-            odor_intensity="Strong",
-            visible_soot=True,
-            soot_description="Heavy on ceiling",
-            large_char=True,
-            char_density="Moderate",
-            ash_residue=False,
-            ash_description="",
-            surface_discoloration=True,
-            discoloration_description="Yellowing",
-            dust_interference=False,
-            dust_notes="",
-            wildfire_indicators=False,
-            wildfire_notes="",
-            additional_notes="Test notes",
-        )
-
-        assert session.observations.smoke_fire_odor is True
-        assert session.observations.odor_intensity == "strong"
-        assert session.observations.char_density_estimate == "moderate"
-        assert session.observations.additional_notes == "Test notes"
-
-    def test_validate_and_continue(self):
-        session = SessionState()
-
-        session, html, tab_index = observations.validate_and_continue(
-            session,
-            smoke_odor=True,
-            odor_intensity="Moderate",
-            visible_soot=True,
-            soot_description="",
-            large_char=False,
-            char_density="None",
-            ash_residue=False,
-            ash_description="",
-            surface_discoloration=False,
-            discoloration_description="",
-            dust_interference=False,
-            dust_notes="",
-            wildfire_indicators=False,
-            wildfire_notes="",
-            additional_notes="",
-        )
-
-        assert tab_index["selected"] == 4  # Go to Results tab (Gradio update dict)
-        assert session.tab4_complete is True
-
-    def test_load_form_from_session(self):
-        session = SessionState()
-        session.observations.smoke_fire_odor = True
-        session.observations.odor_intensity = "strong"
-        session.observations.char_density_estimate = "dense"
-
-        values = observations.load_form_from_session(session)
-
-        assert values[0] is True  # smoke_odor
-        assert values[1] == "Strong"  # odor_intensity (UI value)
-        assert values[5] == "Dense"  # char_density (UI value)
-
-
-class TestResultsTab:
-    """Test Tab 5: Generate Results."""
-
-    def test_check_preflight_incomplete(self):
-        session = SessionState()
-        # No data added
-
-        html = results.check_preflight(session)
-
-        assert "Cannot Generate" in html
-        assert "Project name is required" in html
-
-    def test_check_preflight_complete(self):
-        session = SessionState()
-        session.project.project_name = "Test"
-        session.project.address = "123 Main"
-        session.project.city = "City"
-        session.project.state = "IL"
-        session.project.zip_code = "12345"
-        session.project.client_name = "Client"
-        session.project.fire_date = "2024-01-01"
-        session.project.assessment_date = "2024-01-02"
-        session.project.assessor_name = "Assessor"
-
-        session.rooms.append(RoomFormData(
-            id="room-001",
-            name="Room 1",
-            length_ft=100,
-            width_ft=50,
-            ceiling_height_ft=20,
-        ))
-
-        # Add image with actual bytes in store
-        img_id = "img-001"
-        session.images.append(ImageFormData(id=img_id, filename="test.jpg", room_id="room-001"))
-        test_image = Image.new("RGB", (100, 100), color="red")
-        img_bytes = io.BytesIO()
-        test_image.save(img_bytes, format="PNG")
-        image_store.store(img_id, img_bytes.getvalue())
-
-        html = results.check_preflight(session)
-
-        assert "Ready to Generate" in html
-        assert "Test" in html  # Project name
-
-        # Cleanup
-        image_store.clear()
-
-    def test_generate_assessment_incomplete(self):
-        session = SessionState()
-        # Missing required data
-
-        result = results.generate_assessment(session)
-
-        session = result[0]
-        status = result[1]
-        sow = result[5]
-
-        assert "Error" in status
-        assert "Error" in sow
-
-
-class TestMapConversions:
-    """Test UI-to-schema value mappings."""
-
-    def test_facility_map(self):
-        assert project.FACILITY_MAP["Non-Operational"] == "non-operational"
-        assert project.FACILITY_MAP["Operational"] == "operational"
-        assert project.FACILITY_MAP["Public/Childcare"] == "public-childcare"
-
-    def test_facility_map_reverse(self):
-        assert project.FACILITY_MAP_REVERSE["non-operational"] == "Non-Operational"
-        assert project.FACILITY_MAP_REVERSE["operational"] == "Operational"
-        assert project.FACILITY_MAP_REVERSE["public-childcare"] == "Public/Childcare"
-
-    def test_era_map(self):
-        assert project.ERA_MAP["Pre-1980"] == "pre-1980"
-        assert project.ERA_MAP["1980-2000"] == "1980-2000"
-        assert project.ERA_MAP["Post-2000"] == "post-2000"
-
-    def test_odor_map(self):
-        assert observations.ODOR_MAP["None"] == "none"
-        assert observations.ODOR_MAP["Strong"] == "strong"
-
-    def test_char_density_map(self):
-        assert observations.CHAR_DENSITY_MAP["None"] is None
-        assert observations.CHAR_DENSITY_MAP["Sparse"] == "sparse"
-        assert observations.CHAR_DENSITY_MAP["Dense"] == "dense"

tests/test_ui_state.py

@@ -1,360 +0,0 @@
-"""Tests for UI state management."""
-
-import json
-import pytest
-
-from ui.state import (
-    SessionState,
-    AssessmentHistory,
-    ProjectFormData,
-    RoomFormData,
-    ImageFormData,
-    ObservationsFormData,
-    create_new_session,
-    session_to_json,
-    session_from_json,
-    history_to_json,
-    history_from_json,
-)
-from ui.components import (
-    create_validation_message,
-    create_room_table_data,
-    create_history_dropdown_choices,
-    create_stats_dict,
-    ImageStore,
-)
-
-
-class TestSessionState:
-    """Test SessionState model."""
-
-    def test_create_new_session(self):
-        session = create_new_session()
-        assert session.session_id is not None
-        assert len(session.session_id) == 32  # UUID hex
-        assert session.tab1_complete is False
-        assert len(session.rooms) == 0
-
-    def test_session_serialization(self):
-        session = SessionState()
-        session.project.project_name = "Test Project"
-        session.rooms.append(RoomFormData(
-            name="Room 1",
-            length_ft=100,
-            width_ft=50,
-            ceiling_height_ft=20,
-        ))
-
-        # Serialize
-        json_str = session_to_json(session)
-        assert "Test Project" in json_str
-        assert "Room 1" in json_str
-
-        # Deserialize
-        loaded = session_from_json(json_str)
-        assert loaded.project.project_name == "Test Project"
-        assert len(loaded.rooms) == 1
-        assert loaded.rooms[0].name == "Room 1"
-
-    def test_session_validation_tab1_incomplete(self):
-        session = SessionState()
-        is_valid, errors = session.validate_tab1()
-        assert is_valid is False
-        assert "Project name is required" in errors
-        assert "Address is required" in errors
-
-    def test_session_validation_tab1_complete(self):
-        session = SessionState()
-        session.project = ProjectFormData(
-            project_name="Test Project",
-            address="123 Main St",
-            city="Springfield",
-            state="IL",
-            zip_code="62701",
-            client_name="Test Client",
-            fire_date="2024-12-01",
-            assessment_date="2024-12-15",
-            assessor_name="John Smith",
-        )
-        is_valid, errors = session.validate_tab1()
-        assert is_valid is True
-        assert len(errors) == 0
-
-    def test_session_validation_tab2_no_rooms(self):
-        session = SessionState()
-        is_valid, errors = session.validate_tab2()
-        assert is_valid is False
-        assert "At least one room is required" in errors
-
-    def test_session_validation_tab2_invalid_dimensions(self):
-        session = SessionState()
-        session.rooms.append(RoomFormData(
-            name="Room 1",
-            length_ft=0,  # Invalid
-            width_ft=50,
-            ceiling_height_ft=20,
-        ))
-        is_valid, errors = session.validate_tab2()
-        assert is_valid is False
-        assert any("Length must be greater than 0" in e for e in errors)
-
-    def test_session_validation_tab2_complete(self):
-        session = SessionState()
-        session.rooms.append(RoomFormData(
-            name="Room 1",
-            length_ft=100,
-            width_ft=50,
-            ceiling_height_ft=20,
-        ))
-        is_valid, errors = session.validate_tab2()
-        assert is_valid is True
-
-    def test_session_validation_tab3_no_images(self):
-        session = SessionState()
-        is_valid, errors = session.validate_tab3()
-        assert is_valid is False
-        assert "At least one image is required" in errors
-
-    def test_session_validation_tab3_complete(self):
-        session = SessionState()
-        session.rooms.append(RoomFormData(id="room-001", name="Room 1"))
-        session.images.append(ImageFormData(
-            filename="test.jpg",
-            room_id="room-001",
-        ))
-        is_valid, errors = session.validate_tab3()
-        assert is_valid is True
-
-    def test_session_can_generate(self):
-        session = SessionState()
-        # Fill all required fields
-        session.project = ProjectFormData(
-            project_name="Test",
-            address="123 Main",
-            city="City",
-            state="IL",
-            zip_code="12345",
-            client_name="Client",
-            fire_date="2024-01-01",
-            assessment_date="2024-01-02",
-            assessor_name="Assessor",
-        )
-        session.rooms.append(RoomFormData(
-            id="room-001",
-            name="Room 1",
-            length_ft=100,
-            width_ft=50,
-            ceiling_height_ft=20,
-        ))
-        session.images.append(ImageFormData(
-            filename="test.jpg",
-            room_id="room-001",
-        ))
-
-        can_gen, errors = session.can_generate()
-        assert can_gen is True
-        assert len(errors) == 0
-
-    def test_session_display_name(self):
-        session = SessionState()
-        # Default name from session ID
-        assert session.session_id[:8] in session.get_display_name()
-
-        # Name from project
-        session.project.project_name = "My Project"
-        assert session.get_display_name() == "My Project"
-
-        # Explicit name takes priority
-        session.name = "Custom Name"
-        assert session.get_display_name() == "Custom Name"
-
-
-class TestAssessmentHistory:
-    """Test AssessmentHistory model."""
-
-    def test_empty_history(self):
-        history = AssessmentHistory()
-        assert len(history.assessments) == 0
-        assert history.current_session_id is None
-
-    def test_add_assessment(self):
-        history = AssessmentHistory()
-        session = SessionState()
-        session.project.project_name = "Test"
-
-        history.add_assessment(session)
-        assert len(history.assessments) == 1
-        assert history.assessments[0].session_id == session.session_id
-
-    def test_add_assessment_updates_existing(self):
-        history = AssessmentHistory()
-        session = SessionState()
-        session.project.project_name = "Original"
-
-        history.add_assessment(session)
-
-        # Update and re-add
-        session.project.project_name = "Updated"
-        history.add_assessment(session)
-
-        # Should still have only 1 entry
-        assert len(history.assessments) == 1
-        assert history.assessments[0].project.project_name == "Updated"
-
-    def test_history_limit(self):
-        history = AssessmentHistory()
-
-        # Add 25 assessments
-        for i in range(25):
-            session = SessionState()
-            session.project.project_name = f"Project {i}"
-            history.add_assessment(session)
-
-        # Should only keep 20
-        assert len(history.assessments) == 20
-        # Most recent should be first
-        assert history.assessments[0].project.project_name == "Project 24"
-
-    def test_get_assessment(self):
-        history = AssessmentHistory()
-        session = SessionState()
-        history.add_assessment(session)
-
-        retrieved = history.get_assessment(session.session_id)
-        assert retrieved is not None
-        assert retrieved.session_id == session.session_id
-
-        # Non-existent
-        assert history.get_assessment("nonexistent") is None
-
-    def test_remove_assessment(self):
-        history = AssessmentHistory()
-        session = SessionState()
-        history.add_assessment(session)
-
-        history.remove_assessment(session.session_id)
-        assert len(history.assessments) == 0
-
-    def test_history_serialization(self):
-        history = AssessmentHistory()
-        session = SessionState()
-        session.project.project_name = "Test Project"
-        history.add_assessment(session)
-
-        json_str = history_to_json(history)
-        loaded = history_from_json(json_str)
-
-        assert len(loaded.assessments) == 1
-        assert loaded.assessments[0].project.project_name == "Test Project"
-
-    def test_history_items(self):
-        history = AssessmentHistory()
-        session = SessionState()
-        session.project.project_name = "Test Project"
-        session.has_results = True
-        history.add_assessment(session)
-
-        items = history.get_history_items()
-        assert len(items) == 1
-        assert items[0]["name"] == "Test Project"
-        assert items[0]["has_results"] is True
-
-
-class TestUIComponents:
-    """Test UI component helpers."""
-
-    def test_validation_message_success(self):
-        msg = create_validation_message(True, [], "All good!")
-        assert "✓" in msg
-        assert "All good!" in msg
-
-    def test_validation_message_failure(self):
-        msg = create_validation_message(False, ["Error 1", "Error 2"])
-        assert "⚠" in msg
-        assert "Error 1" in msg
-        assert "Error 2" in msg
-
-    def test_room_table_data(self):
-        session = SessionState()
-        session.rooms.append(RoomFormData(
-            name="Room 1",
-            length_ft=100,
-            width_ft=50,
-            ceiling_height_ft=20,
-        ))
-
-        data = create_room_table_data(session)
-        assert len(data) == 1
-        assert data[0][0] == "Room 1"
-        assert "100 x 50 x 20" in data[0][1]
-        assert "5,000" in data[0][2]  # Area
-        assert "100,000" in data[0][3]  # Volume
-
-    def test_history_dropdown_choices(self):
-        history = AssessmentHistory()
-        session = SessionState()
-        session.project.project_name = "Test Project"
-        history.add_assessment(session)
-
-        choices = create_history_dropdown_choices(history)
-        assert len(choices) == 2  # "New Assessment" + 1 saved
-        assert choices[0][0] == "-- New Assessment --"
-        assert "Test Project" in choices[1][0]
-
-    def test_stats_dict(self):
-        session = SessionState()
-        session.rooms.append(RoomFormData(
-            name="Room 1",
-            length_ft=100,
-            width_ft=50,
-            ceiling_height_ft=20,
-        ))
-        session.images.append(ImageFormData(filename="test.jpg", room_id="room-001"))
-
-        stats = create_stats_dict(session)
-        assert stats["rooms"] == 1
-        assert stats["images"] == 1
-        assert stats["total_floor_area_sf"] == "5,000"
-        assert stats["total_volume_cf"] == "100,000"
-
-
-class TestImageStore:
-    """Test ImageStore for in-memory image storage."""
-
-    def test_store_and_get(self):
-        store = ImageStore()
-        store.store("img-001", b"test image bytes")
-
-        assert store.get("img-001") == b"test image bytes"
-        assert store.get("nonexistent") is None
-
-    def test_remove(self):
-        store = ImageStore()
-        store.store("img-001", b"test")
-        store.remove("img-001")
-
-        assert store.get("img-001") is None
-
-    def test_clear(self):
-        store = ImageStore()
-        store.store("img-001", b"test1")
-        store.store("img-002", b"test2")
-        store.clear()
-
-        assert store.get("img-001") is None
-        assert store.get("img-002") is None
-
-    def test_missing_ids(self):
-        store = ImageStore()
-        store.store("img-001", b"test")
-
-        missing = store.get_missing_ids(["img-001", "img-002", "img-003"])
-        assert missing == ["img-002", "img-003"]
-
-    def test_has_all(self):
-        store = ImageStore()
-        store.store("img-001", b"test1")
-        store.store("img-002", b"test2")
-
-        assert store.has_all(["img-001", "img-002"]) is True
-        assert store.has_all(["img-001", "img-003"]) is False

ui/__init__.py

@@ -2,7 +2,6 @@
 
 from .state import (
     # Form data models
-    ProjectFormData,
     RoomFormData,
     ImageFormData,
     ObservationsFormData,
@@ -34,7 +33,6 @@ from .components import (
     create_validation_message,
     create_progress_html,
     create_history_dropdown_choices,
-    create_room_table_data,
     create_tab_status_indicator,
     create_stats_dict,
     format_validation_errors_html,
@@ -47,7 +45,6 @@ from .components import (
 
 __all__ = [
     # Form data models
-    "ProjectFormData",
     "RoomFormData",
     "ImageFormData",
     "ObservationsFormData",
@@ -74,7 +71,6 @@ __all__ = [
     "create_validation_message",
     "create_progress_html",
     "create_history_dropdown_choices",
-    "create_room_table_data",
     "create_tab_status_indicator",
     "create_stats_dict",
     "format_validation_errors_html",

ui/components.py

@@ -90,28 +90,6 @@ def create_history_dropdown_choices(history: AssessmentHistory) -> list[tuple[st
     return choices
 
 
-def create_room_table_data(session: SessionState) -> list[list]:
-    """Create data for rooms table display.
-
-    Args:
-        session: Current session state
-
-    Returns:
-        List of rows for dataframe
-    """
-    rows = []
-    for room in session.rooms:
-        area = room.length_ft * room.width_ft
-        volume = area * room.ceiling_height_ft
-        rows.append([
-            room.name,
-            f"{room.length_ft:.0f} x {room.width_ft:.0f} x {room.ceiling_height_ft:.0f}",
-            f"{area:,.0f}",
-            f"{volume:,.0f}",
-        ])
-    return rows
-
-
 def create_tab_status_indicator(
     tab_number: int,
     is_complete: bool,
@@ -144,19 +122,17 @@ def create_stats_dict(session: SessionState) -> dict:
     Returns:
         Dictionary of statistics
     """
-    total_area = sum(r.length_ft * r.width_ft for r in session.rooms)
-    total_volume = sum(
-        r.length_ft * r.width_ft * r.ceiling_height_ft
-        for r in session.rooms
-    )
+    r = session.room
+    total_area = r.length_ft * r.width_ft
+    total_volume = total_area * r.ceiling_height_ft
 
     return {
-        "rooms": len(session.rooms),
+        "room_name": r.name or "Not set",
         "images": len(session.images),
         "total_floor_area_sf": f"{total_area:,.0f}",
         "total_volume_cf": f"{total_volume:,.0f}",
-        "facility_classification": session.project.facility_classification or "Not set",
-        "construction_era": session.project.construction_era or "Not set",
+        "facility_classification": r.facility_classification or "Not set",
+        "construction_era": r.construction_era or "Not set",
     }
 
 

ui/samples.py

@@ -1,7 +1,8 @@
 """Sample room data for testing the FDAM AI Pipeline.
 
-Provides 4 pre-configured sample scenarios with complete project data,
-room information, images, and qualitative observations.
+Provides 4 pre-configured sample scenarios with complete room data,
+images, and qualitative observations.
+MVP Simplification: Single room, no project-level data.
 """
 
 import uuid
@@ -13,7 +14,6 @@ from PIL import Image
 
 from ui.state import (
     SessionState,
-    ProjectFormData,
     RoomFormData,
     ImageFormData,
     ObservationsFormData,
@@ -32,7 +32,6 @@ class SampleScenario:
     id: str
     name: str
     description: str
-    project_data: dict
     room_data: dict
     observations_data: dict
     image_files: list[str] = field(default_factory=list)
@@ -46,26 +45,13 @@ SAMPLE_SCENARIOS = [
         id="bar_dining",
         name="Bar & Dining Area",
         description="3 images",
-        project_data={
-            "project_name": "Sample: Bar & Dining Fire Assessment",
-            "address": "1234 Main Street",
-            "city": "Springfield",
-            "state": "IL",
-            "zip_code": "62701",
-            "client_name": "Sample Test Client",
-            "fire_date": "2024-11-15",
-            "assessment_date": "2024-12-01",
-            "facility_classification": "non-operational",
-            "construction_era": "pre-1980",
-            "assessor_name": "Test Assessor",
-            "assessor_credentials": ["CIH"],
-        },
         room_data={
             "name": "Bar & Dining Area",
-            "floor": "Ground Floor",
             "length_ft": 40.0,
             "width_ft": 30.0,
             "ceiling_height_ft": 12.0,
+            "facility_classification": "non-operational",
+            "construction_era": "pre-1980",
         },
         observations_data={
             "smoke_fire_odor": True,
@@ -95,26 +81,13 @@ SAMPLE_SCENARIOS = [
         id="bar_area",
         name="Bar Area",
         description="3 images",
-        project_data={
-            "project_name": "Sample: Bar Area Fire Assessment",
-            "address": "1234 Main Street",
-            "city": "Springfield",
-            "state": "IL",
-            "zip_code": "62701",
-            "client_name": "Sample Test Client",
-            "fire_date": "2024-11-15",
-            "assessment_date": "2024-12-01",
-            "facility_classification": "non-operational",
-            "construction_era": "pre-1980",
-            "assessor_name": "Test Assessor",
-            "assessor_credentials": ["CIH"],
-        },
         room_data={
             "name": "Bar Area",
-            "floor": "Ground Floor",
             "length_ft": 25.0,
             "width_ft": 20.0,
             "ceiling_height_ft": 14.0,
+            "facility_classification": "non-operational",
+            "construction_era": "pre-1980",
         },
         observations_data={
             "smoke_fire_odor": True,
@@ -144,26 +117,13 @@ SAMPLE_SCENARIOS = [
         id="kitchen",
         name="Kitchen",
         description="6 images",
-        project_data={
-            "project_name": "Sample: Kitchen Fire Assessment",
-            "address": "5678 Industrial Blvd",
-            "city": "Chicago",
-            "state": "IL",
-            "zip_code": "60601",
-            "client_name": "Sample Test Client",
-            "fire_date": "2024-10-20",
-            "assessment_date": "2024-11-05",
-            "facility_classification": "non-operational",
-            "construction_era": "1980-2000",
-            "assessor_name": "Test Assessor",
-            "assessor_credentials": ["CIH", "CSP"],
-        },
         room_data={
             "name": "Commercial Kitchen",
-            "floor": "Ground Floor",
             "length_ft": 30.0,
             "width_ft": 25.0,
             "ceiling_height_ft": 10.0,
+            "facility_classification": "non-operational",
+            "construction_era": "1980-2000",
         },
         observations_data={
             "smoke_fire_odor": True,
@@ -196,26 +156,13 @@ SAMPLE_SCENARIOS = [
         id="factory",
         name="Factory Area",
         description="1 image",
-        project_data={
-            "project_name": "Sample: Factory Fire Assessment",
-            "address": "9999 Factory Way",
-            "city": "Detroit",
-            "state": "MI",
-            "zip_code": "48201",
-            "client_name": "Industrial Test Corp",
-            "fire_date": "2024-09-01",
-            "assessment_date": "2024-09-15",
-            "facility_classification": "operational",
-            "construction_era": "pre-1980",
-            "assessor_name": "Test Assessor",
-            "assessor_credentials": ["CIH", "PE"],
-        },
         room_data={
             "name": "Factory Production Area",
-            "floor": "Ground Floor",
             "length_ft": 80.0,
             "width_ft": 60.0,
             "ceiling_height_ft": 25.0,
+            "facility_classification": "operational",
+            "construction_era": "pre-1980",
         },
         observations_data={
             "smoke_fire_odor": True,
@@ -313,34 +260,33 @@ def load_sample(scenario_id: str) -> SessionState | None:
     if not scenario:
         return None
 
-    # Create room with unique ID
+    # Create room with unique ID and all fields from room_data
     room_id = f"room-{uuid.uuid4().hex[:8]}"
     room = RoomFormData(
         id=room_id,
         name=scenario.room_data["name"],
-        floor=scenario.room_data.get("floor", ""),
         length_ft=scenario.room_data["length_ft"],
         width_ft=scenario.room_data["width_ft"],
         ceiling_height_ft=scenario.room_data["ceiling_height_ft"],
+        facility_classification=scenario.room_data.get("facility_classification", "non-operational"),
+        construction_era=scenario.room_data.get("construction_era", "post-2000"),
     )
 
     # Load images
     images = load_sample_images(scenario, room_id)
 
-    # Create session
+    # Create session with single room
     session = SessionState(
-        project=ProjectFormData(**scenario.project_data),
-        rooms=[room],
+        room=room,
         images=images,
         observations=ObservationsFormData(**scenario.observations_data),
-        name=scenario.project_data["project_name"],
+        name=scenario.room_data["name"],
     )
 
     # Mark tabs as complete since we have all data
     session.tab1_complete = True
-    session.tab2_complete = True
-    session.tab3_complete = len(images) > 0
-    session.tab4_complete = True
+    session.tab2_complete = len(images) > 0
+    session.tab3_complete = True
 
     return session
 

ui/state.py

@@ -2,6 +2,8 @@
 
 Provides Pydantic models for session state and localStorage persistence.
 Images are stored separately (not in localStorage due to size limits).
+
+MVP Simplification: Single room assessment (no project-level fields).
 """
 
 import json
@@ -22,32 +24,21 @@ from schemas.input import (
 # --- Form Data Models (for localStorage) ---
 
 
-class ProjectFormData(BaseModel):
-    """Form data for Tab 1: Project Info."""
-
-    project_name: str = ""
-    address: str = ""
-    city: str = ""
-    state: str = ""
-    zip_code: str = ""
-    client_name: str = ""
-    fire_date: str = ""  # ISO format string for form compatibility
-    assessment_date: str = ""
-    facility_classification: FacilityClassification = "non-operational"
-    construction_era: ConstructionEra = "post-2000"
-    assessor_name: str = ""
-    assessor_credentials: list[str] = Field(default_factory=list)  # Multiselect credentials
-
-
 class RoomFormData(BaseModel):
-    """Form data for a single room."""
+    """Form data for Tab 1: Room Assessment.
+
+    Includes facility_classification and construction_era moved from
+    the removed ProjectFormData (required for calculations).
+    """
 
     id: str = Field(default_factory=lambda: f"room-{uuid.uuid4().hex[:8]}")
     name: str = ""
-    floor: str = ""
     length_ft: float = 0
     width_ft: float = 0
     ceiling_height_ft: float = 0
+    # Moved from ProjectFormData (required for calculations)
+    facility_classification: FacilityClassification = "non-operational"
+    construction_era: ConstructionEra = "post-2000"
 
 
 class ImageFormData(BaseModel):
@@ -61,7 +52,7 @@ class ImageFormData(BaseModel):
 
 
 class ObservationsFormData(BaseModel):
-    """Form data for Tab 4: Observations."""
+    """Form data for Tab 3: Observations."""
 
     smoke_fire_odor: bool = False
     odor_intensity: OdorIntensity = "none"
@@ -85,6 +76,9 @@ class SessionState(BaseModel):
 
     This model is serialized to localStorage for persistence.
     Images are stored separately and referenced by ID.
+
+    MVP Simplification: Single room, no project-level fields.
+    Tabs: 1=Room, 2=Images, 3=Observations, 4=Generate
     """
 
     # Session metadata
@@ -93,15 +87,13 @@ class SessionState(BaseModel):
     updated_at: str = Field(default_factory=lambda: datetime.now().isoformat())
     name: str = ""  # Display name for history list
 
-    # Tab completion status
-    tab1_complete: bool = False
-    tab2_complete: bool = False
-    tab3_complete: bool = False
-    tab4_complete: bool = False
+    # Tab completion status (3 input tabs)
+    tab1_complete: bool = False  # Room Assessment
+    tab2_complete: bool = False  # Images
+    tab3_complete: bool = False  # Observations
 
-    # Form data by tab
-    project: ProjectFormData = Field(default_factory=ProjectFormData)
-    rooms: list[RoomFormData] = Field(default_factory=list)
+    # Form data - single room (not list)
+    room: RoomFormData = Field(default_factory=RoomFormData)
     images: list[ImageFormData] = Field(default_factory=list)
     observations: ObservationsFormData = Field(default_factory=ObservationsFormData)
 
@@ -117,63 +109,37 @@ class SessionState(BaseModel):
         """Get a display name for the history list."""
         if self.name:
             return self.name
-        if self.project.project_name:
-            return self.project.project_name
+        if self.room.name:
+            return self.room.name
         return f"Assessment {self.session_id[:8]}"
 
     def validate_tab1(self) -> tuple[bool, list[str]]:
-        """Validate Tab 1 (Project Info) is complete."""
+        """Validate Tab 1 (Room Assessment) is complete."""
         errors = []
-        p = self.project
-        if not p.project_name:
-            errors.append("Project name is required")
-        if not p.address:
-            errors.append("Address is required")
-        if not p.city:
-            errors.append("City is required")
-        if not p.state:
-            errors.append("State is required")
-        if not p.zip_code:
-            errors.append("ZIP code is required")
-        if not p.client_name:
-            errors.append("Client name is required")
-        if not p.fire_date:
-            errors.append("Fire date is required")
-        if not p.assessment_date:
-            errors.append("Assessment date is required")
-        if not p.assessor_name:
-            errors.append("Assessor name is required")
+        r = self.room
+        if not r.name:
+            errors.append("Room name is required")
+        if r.length_ft <= 0:
+            errors.append("Length must be greater than 0")
+        if r.width_ft <= 0:
+            errors.append("Width must be greater than 0")
+        if r.ceiling_height_ft <= 0:
+            errors.append("Ceiling height must be greater than 0")
         return len(errors) == 0, errors
 
     def validate_tab2(self) -> tuple[bool, list[str]]:
-        """Validate Tab 2 (Building/Rooms) is complete."""
-        errors = []
-        if not self.rooms:
-            errors.append("At least one room is required")
-        for room in self.rooms:
-            if not room.name:
-                errors.append(f"Room name is required")
-            if room.length_ft <= 0:
-                errors.append(f"Room '{room.name}': Length must be greater than 0")
-            if room.width_ft <= 0:
-                errors.append(f"Room '{room.name}': Width must be greater than 0")
-            if room.ceiling_height_ft <= 0:
-                errors.append(f"Room '{room.name}': Ceiling height must be greater than 0")
-        return len(errors) == 0, errors
-
-    def validate_tab3(self) -> tuple[bool, list[str]]:
-        """Validate Tab 3 (Images) is complete."""
+        """Validate Tab 2 (Images) is complete."""
         errors = []
         if not self.images:
             errors.append("At least one image is required")
         for img in self.images:
             if not img.room_id:
-                errors.append(f"Image '{img.filename}': Must be associated with a room")
+                errors.append(f"Image '{img.filename}': Must be associated with the room")
         return len(errors) == 0, errors
 
-    def validate_tab4(self) -> tuple[bool, list[str]]:
-        """Validate Tab 4 (Observations) is complete."""
-        # Tab 4 has no required fields - all checkboxes default to False
+    def validate_tab3(self) -> tuple[bool, list[str]]:
+        """Validate Tab 3 (Observations) is complete."""
+        # Tab 3 has no required fields - all checkboxes default to False
         return True, []
 
     def can_generate(self) -> tuple[bool, list[str]]:
@@ -192,10 +158,6 @@ class SessionState(BaseModel):
         if not valid3:
             all_errors.extend(errors3)
 
-        valid4, errors4 = self.validate_tab4()
-        if not valid4:
-            all_errors.extend(errors4)
-
         return len(all_errors) == 0, all_errors
 
 
@@ -255,20 +217,35 @@ def session_to_json(session: SessionState) -> str:
 def session_from_json(json_str: str) -> SessionState:
     """Deserialize session from JSON.
 
-    Includes migration for old sessions where assessor_credentials was a string.
+    Includes migration from old multi-room format to single room.
     """
     try:
-        # Parse JSON first to check for migrations needed
         data = json.loads(json_str)
 
-        # Migration: Convert old string credentials to list
-        if "project" in data and isinstance(data["project"].get("assessor_credentials"), str):
-            old_creds = data["project"]["assessor_credentials"]
-            # Convert comma-separated string to list, or empty list if empty
-            if old_creds:
-                data["project"]["assessor_credentials"] = [c.strip() for c in old_creds.split(",") if c.strip()]
+        # Migration: Convert old multi-room format to single room
+        if "rooms" in data and isinstance(data["rooms"], list):
+            # Use first room if available, otherwise create empty
+            if data["rooms"]:
+                data["room"] = data["rooms"][0]
             else:
-                data["project"]["assessor_credentials"] = []
+                data["room"] = {}
+            del data["rooms"]
+
+        # Migration: Move facility_classification and construction_era from project to room
+        if "project" in data:
+            project = data["project"]
+            if "room" not in data:
+                data["room"] = {}
+            # Move fields if they exist in project
+            if "facility_classification" in project:
+                data["room"]["facility_classification"] = project["facility_classification"]
+            if "construction_era" in project:
+                data["room"]["construction_era"] = project["construction_era"]
+            del data["project"]
+
+        # Migration: Remove old tab4_complete (now only 3 tabs)
+        if "tab4_complete" in data:
+            del data["tab4_complete"]
 
         return SessionState.model_validate(data)
     except Exception:

ui/tabs/__init__.py

@@ -1,14 +1,12 @@
 """Tab modules for FDAM AI Pipeline UI."""
 
-from . import project
-from . import rooms
+from . import room
 from . import images
 from . import observations
 from . import results
 
 __all__ = [
-    "project",
-    "rooms",
+    "room",
     "images",
     "observations",
     "results",

ui/tabs/images.py

@@ -1,11 +1,12 @@
-"""Tab 3: Images.
+"""Tab 2: Images.
 
 Upload and manage fire damage images for AI analysis.
+MVP Simplification: Single room - images auto-assigned to the room.
 """
 
 import uuid
 import gradio as gr
-from typing import Any, Optional
+from typing import Any
 from PIL import Image
 import io
 
@@ -15,15 +16,14 @@ from config.settings import settings
 
 
 def create_tab() -> dict[str, Any]:
-    """Create Tab 3 UI components.
+    """Create Tab 2 UI components.
 
     Returns:
         Dictionary of component references for event wiring.
     """
     gr.Markdown("### Fire Damage Images")
     gr.Markdown(
-        f"*Upload up to {settings.max_images_per_assessment} images for AI analysis. "
-        f"Each image must be associated with a room.*"
+        f"*Upload up to {settings.max_images_per_assessment} images for AI analysis.*"
     )
 
     with gr.Row():
@@ -34,13 +34,6 @@ def create_tab() -> dict[str, Any]:
                 file_types=["image"],
                 elem_id="image_upload",
             )
-            room_select = gr.Dropdown(
-                label="Associate with Room *",
-                choices=[],
-                value=None,
-                elem_id="room_select",
-                info="All uploaded images will be assigned to this room",
-            )
             image_description = gr.Textbox(
                 label="Description (optional)",
                 placeholder="e.g., View of ceiling deck from center aisle",
@@ -75,7 +68,7 @@ def create_tab() -> dict[str, Any]:
     with gr.Row():
         validation_status = gr.HTML(
             value="",
-            elem_id="tab3_validation",
+            elem_id="tab2_validation",
         )
 
     # Resume warning (shown when images need re-upload)
@@ -87,7 +80,7 @@ def create_tab() -> dict[str, Any]:
         )
 
     with gr.Row():
-        back_btn = gr.Button("← Back to Rooms")
+        back_btn = gr.Button("← Back to Room")
         validate_btn = gr.Button(
             "Validate & Continue to Observations →",
             variant="primary",
@@ -95,7 +88,6 @@ def create_tab() -> dict[str, Any]:
 
     return {
         "image_upload": image_upload,
-        "room_select": room_select,
         "image_description": image_description,
         "add_image_btn": add_image_btn,
         "clear_upload_btn": clear_upload_btn,
@@ -113,20 +105,20 @@ def create_tab() -> dict[str, Any]:
 def add_image(
     session: SessionState,
     files: list | None,
-    room_id: str,
     description: str,
-) -> tuple[SessionState, list[tuple], str, str, None, str, str]:
+) -> tuple[SessionState, list[tuple], str, str, None, str]:
     """Add one or more images to the session (batch upload).
 
+    Images are automatically associated with the single room.
+
     Args:
         session: Current session state.
         files: List of uploaded file objects from gr.Files, each with a `name` attribute.
-        room_id: Room ID to associate images with.
         description: Optional description applied to all images.
 
     Returns:
         Tuple of (session, gallery_data, validation_html, image_count,
-                  cleared_files, cleared_description, room_id).
+                  cleared_files, cleared_description).
     """
     validation_html = ""
 
@@ -134,8 +126,6 @@ def add_image(
     errors = []
     if not files or len(files) == 0:
         errors.append("Please upload at least one image")
-    if not room_id:
-        errors.append("Please select a room for these images")
 
     # Check capacity
     current_count = len(session.images)
@@ -158,14 +148,11 @@ def add_image(
         """
         gallery_data = _get_gallery_data(session)
         count_str = f"{len(session.images)} / {max_allowed}"
-        return session, gallery_data, validation_html, count_str, files, description, room_id
+        return session, gallery_data, validation_html, count_str, files, description
 
-    # Get room name for filenames
-    room_name = "unknown"
-    for room in session.rooms:
-        if room.id == room_id:
-            room_name = room.name.replace(" ", "_")[:20]
-            break
+    # Get room info from session (single room)
+    room_id = session.room.id
+    room_name = session.room.name.replace(" ", "_")[:20] if session.room.name else "room"
 
     # Process each uploaded file
     added_count = 0
@@ -205,7 +192,7 @@ def add_image(
     if added_count > 0:
         validation_html = f"""
         <div style="background: #e8f5e9; border: 1px solid #66bb6a; border-radius: 4px; padding: 10px;">
-            <span style="color: #2e7d32;">✓ {added_count} image(s) added for room: {room_name}</span>
+            <span style="color: #2e7d32;">✓ {added_count} image(s) added for {room_name}</span>
         </div>
         """
     else:
@@ -219,7 +206,7 @@ def add_image(
     count_str = f"{len(session.images)} / {max_allowed}"
 
     # Clear form
-    return session, gallery_data, validation_html, count_str, None, "", room_id
+    return session, gallery_data, validation_html, count_str, None, ""
 
 
 def remove_last_image(session: SessionState) -> tuple[SessionState, list[tuple], str, str]:
@@ -265,7 +252,7 @@ def clear_all_images(session: SessionState) -> tuple[SessionState, list[tuple],
 
 
 def validate_and_continue(session: SessionState) -> tuple[SessionState, str, int]:
-    """Validate Tab 3 and proceed to Tab 4.
+    """Validate Tab 2 and proceed to Tab 3.
 
     Returns:
         Tuple of (session, validation_html, next_tab_index).
@@ -285,21 +272,21 @@ def validate_and_continue(session: SessionState) -> tuple[SessionState, str, int
             </p>
         </div>
         """
-        return session, html, gr.update(selected=2)  # Stay on Images tab
+        return session, html, gr.update(selected=1)  # Stay on Images tab (index 1)
 
-    is_valid, errors = session.validate_tab3()
+    is_valid, errors = session.validate_tab2()
 
     if is_valid:
-        session.tab3_complete = True
+        session.tab2_complete = True
         session.update_timestamp()
         html = """
         <div style="background: #e8f5e9; border: 1px solid #66bb6a; border-radius: 4px; padding: 10px;">
             <span style="color: #2e7d32;">✓ Images complete. Proceeding to Observations tab...</span>
         </div>
         """
-        return session, html, gr.update(selected=3)  # Go to tab index 3 (Observations)
+        return session, html, gr.update(selected=2)  # Go to tab index 2 (Observations)
     else:
-        session.tab3_complete = False
+        session.tab2_complete = False
         error_items = "".join(f"<li>{e}</li>" for e in errors)
         html = f"""
         <div style="background: #ffebee; border: 1px solid #ef5350; border-radius: 4px; padding: 10px;">
@@ -309,18 +296,7 @@ def validate_and_continue(session: SessionState) -> tuple[SessionState, str, int
             </ul>
         </div>
         """
-        return session, html, gr.update(selected=2)  # Stay on current tab
-
-
-def update_room_choices(session: SessionState) -> dict:
-    """Update room dropdown choices.
-
-    Returns:
-        Gradio update dict for Dropdown component.
-    """
-    choices = [(r.name, r.id) for r in session.rooms]
-    # Don't reset value - let user keep their selection when adding multiple images
-    return gr.update(choices=choices)
+        return session, html, gr.update(selected=1)  # Stay on current tab
 
 
 def load_from_session(session: SessionState) -> tuple[list[tuple], str, str]:

ui/tabs/project.py

@@ -1,287 +0,0 @@
-"""Tab 1: Project Information.
-
-Collects project details, client information, and facility classification.
-"""
-
-import re
-import gradio as gr
-from typing import Any
-
-from ui.state import SessionState, ProjectFormData
-from ui.constants import US_STATES, ASSESSOR_CREDENTIALS
-
-
-# ZIP code validation regex (5 digits or 5+4 format)
-ZIP_PATTERN = re.compile(r"^\d{5}(-\d{4})?$")
-
-
-# Map UI values to schema values
-FACILITY_MAP = {
-    "Non-Operational": "non-operational",
-    "Operational": "operational",
-    "Public/Childcare": "public-childcare",
-}
-FACILITY_MAP_REVERSE = {v: k for k, v in FACILITY_MAP.items()}
-
-ERA_MAP = {
-    "Pre-1980": "pre-1980",
-    "1980-2000": "1980-2000",
-    "Post-2000": "post-2000",
-}
-ERA_MAP_REVERSE = {v: k for k, v in ERA_MAP.items()}
-
-
-def create_tab() -> dict[str, Any]:
-    """Create Tab 1 UI components.
-
-    Returns:
-        Dictionary of component references for event wiring.
-    """
-    gr.Markdown("### Project Information")
-    gr.Markdown("*Enter project details, client information, and facility classification.*")
-
-    with gr.Row():
-        with gr.Column():
-            project_name = gr.Textbox(
-                label="Project/Facility Name *",
-                placeholder="e.g., ABC Warehouse",
-                elem_id="project_name",
-            )
-            address = gr.Textbox(
-                label="Street Address *",
-                elem_id="address",
-            )
-            with gr.Row():
-                city = gr.Textbox(label="City *", elem_id="city")
-                state = gr.Dropdown(
-                    label="State *",
-                    choices=US_STATES,
-                    elem_id="state",
-                    allow_custom_value=True,  # Allow empty value for validation
-                )
-                with gr.Column(scale=1):
-                    zip_code = gr.Textbox(
-                        label="ZIP Code *",
-                        max_lines=1,
-                        elem_id="zip_code",
-                        info="Format: 12345 or 12345-6789",
-                    )
-                    zip_validation = gr.HTML(
-                        value="",
-                        elem_id="zip_validation",
-                    )
-
-        with gr.Column():
-            client_name = gr.Textbox(
-                label="Client Name *",
-                elem_id="client_name",
-            )
-            fire_date = gr.DateTime(
-                label="Fire Date *",
-                include_time=False,
-                type="string",
-                elem_id="fire_date",
-            )
-            assessment_date = gr.DateTime(
-                label="Assessment Date *",
-                include_time=False,
-                type="string",
-                elem_id="assessment_date",
-            )
-
-    with gr.Row():
-        facility_classification = gr.Radio(
-            choices=["Non-Operational", "Operational", "Public/Childcare"],
-            label="Facility Classification *",
-            value="Non-Operational",
-            info="Affects clearance thresholds (see FDAM §3.1)",
-            elem_id="facility_classification",
-        )
-        construction_era = gr.Radio(
-            choices=["Pre-1980", "1980-2000", "Post-2000"],
-            label="Construction Era *",
-            value="Post-2000",
-            info="Affects LBP/ACM regulatory flags",
-            elem_id="construction_era",
-        )
-
-    with gr.Row():
-        assessor_name = gr.Textbox(
-            label="Assessor Name *",
-            elem_id="assessor_name",
-        )
-        assessor_credentials = gr.Dropdown(
-            label="Credentials (optional)",
-            choices=ASSESSOR_CREDENTIALS,
-            multiselect=True,
-            elem_id="assessor_credentials",
-            info="Select all that apply",
-        )
-
-    # Validation status display
-    with gr.Row():
-        validation_status = gr.HTML(
-            value="",
-            elem_id="tab1_validation",
-        )
-
-    with gr.Row():
-        validate_btn = gr.Button(
-            "Validate & Continue to Rooms →",
-            variant="primary",
-        )
-
-    return {
-        "project_name": project_name,
-        "address": address,
-        "city": city,
-        "state": state,
-        "zip_code": zip_code,
-        "zip_validation": zip_validation,
-        "client_name": client_name,
-        "fire_date": fire_date,
-        "assessment_date": assessment_date,
-        "facility_classification": facility_classification,
-        "construction_era": construction_era,
-        "assessor_name": assessor_name,
-        "assessor_credentials": assessor_credentials,
-        "validation_status": validation_status,
-        "validate_btn": validate_btn,
-    }
-
-
-def update_session_from_form(
-    session: SessionState,
-    project_name: str,
-    address: str,
-    city: str,
-    state: str,
-    zip_code: str,
-    client_name: str,
-    fire_date: str,
-    assessment_date: str,
-    facility_classification: str,
-    construction_era: str,
-    assessor_name: str,
-    assessor_credentials: list[str] | None,
-) -> SessionState:
-    """Update session state from form values."""
-    session.project = ProjectFormData(
-        project_name=project_name or "",
-        address=address or "",
-        city=city or "",
-        state=state or "",
-        zip_code=zip_code or "",
-        client_name=client_name or "",
-        fire_date=fire_date or "",
-        assessment_date=assessment_date or "",
-        facility_classification=FACILITY_MAP.get(facility_classification, "non-operational"),
-        construction_era=ERA_MAP.get(construction_era, "post-2000"),
-        assessor_name=assessor_name or "",
-        assessor_credentials=assessor_credentials or [],
-    )
-    session.update_timestamp()
-    return session
-
-
-def validate_and_continue(
-    session: SessionState,
-    project_name: str,
-    address: str,
-    city: str,
-    state: str,
-    zip_code: str,
-    client_name: str,
-    fire_date: str,
-    assessment_date: str,
-    facility_classification: str,
-    construction_era: str,
-    assessor_name: str,
-    assessor_credentials: list[str] | None,
-) -> tuple[SessionState, str, int]:
-    """Validate Tab 1 and update session.
-
-    Returns:
-        Tuple of (updated session, validation HTML, next tab index).
-    """
-    # Update session first
-    session = update_session_from_form(
-        session,
-        project_name,
-        address,
-        city,
-        state,
-        zip_code,
-        client_name,
-        fire_date,
-        assessment_date,
-        facility_classification,
-        construction_era,
-        assessor_name,
-        assessor_credentials,
-    )
-
-    # Validate
-    is_valid, errors = session.validate_tab1()
-
-    if is_valid:
-        session.tab1_complete = True
-        html = """
-        <div style="background: #e8f5e9; border: 1px solid #66bb6a; border-radius: 4px; padding: 10px;">
-            <span style="color: #2e7d32;">✓ Project information complete. Proceeding to Rooms tab...</span>
-        </div>
-        """
-        return session, html, gr.update(selected=1)  # Go to tab index 1 (Rooms)
-    else:
-        session.tab1_complete = False
-        error_items = "".join(f"<li>{e}</li>" for e in errors)
-        html = f"""
-        <div style="background: #ffebee; border: 1px solid #ef5350; border-radius: 4px; padding: 10px;">
-            <strong style="color: #c62828;">Please fix the following:</strong>
-            <ul style="margin: 5px 0 0 0; padding-left: 20px; color: #c62828;">
-                {error_items}
-            </ul>
-        </div>
-        """
-        return session, html, gr.update(selected=0)  # Stay on current tab
-
-
-def load_form_from_session(session: SessionState) -> tuple:
-    """Load form values from session state.
-
-    Returns:
-        Tuple of form values in component order.
-    """
-    p = session.project
-    return (
-        p.project_name,
-        p.address,
-        p.city,
-        p.state,
-        p.zip_code,
-        p.client_name,
-        p.fire_date,
-        p.assessment_date,
-        FACILITY_MAP_REVERSE.get(p.facility_classification, "Non-Operational"),
-        ERA_MAP_REVERSE.get(p.construction_era, "Post-2000"),
-        p.assessor_name,
-        p.assessor_credentials,
-    )
-
-
-def validate_zip_format(zip_code: str) -> str:
-    """Validate ZIP code format and return validation HTML indicator.
-
-    Args:
-        zip_code: The ZIP code string to validate.
-
-    Returns:
-        HTML string with validation indicator (green check or red X).
-    """
-    if not zip_code:
-        return ""  # Empty - no indicator
-
-    if ZIP_PATTERN.match(zip_code.strip()):
-        return '<span style="color: #2e7d32; font-size: 12px;">✓ Valid format</span>'
-    else:
-        return '<span style="color: #c62828; font-size: 12px;">✗ Use format: 12345 or 12345-6789</span>'

ui/tabs/results.py

@@ -141,8 +141,7 @@ def check_preflight(session: SessionState) -> str:
         <div style="background: #e8f5e9; border: 1px solid #66bb6a; border-radius: 4px; padding: 15px;">
             <strong style="color: #2e7d32;">✓ Ready to Generate</strong>
             <div style="margin-top: 10px; color: #333;">
-                <strong>Project:</strong> {session.project.project_name}<br>
-                <strong>Rooms:</strong> {stats['rooms']}<br>
+                <strong>Room:</strong> {stats['room_name']}<br>
                 <strong>Images:</strong> {stats['images']}<br>
                 <strong>Total Area:</strong> {stats['total_floor_area_sf']} SF<br>
                 <strong>Facility:</strong> {stats['facility_classification']}<br>
@@ -214,11 +213,12 @@ def generate_assessment(
     try:
         if sow_markdown:
             # Save Markdown file
+            room_name_safe = session.room.name.replace(' ', '_') if session.room.name else "Room"
             with tempfile.NamedTemporaryFile(
                 mode='w',
                 suffix='.md',
                 delete=False,
-                prefix=f"SOW_{session.project.project_name.replace(' ', '_')}_",
+                prefix=f"SOW_{room_name_safe}_",
             ) as f:
                 f.write(sow_markdown)
                 md_path = f.name
@@ -258,18 +258,12 @@ def _generate_sow_markdown(
 ) -> str:
     """Generate Scope of Work markdown document.
 
-    This is a placeholder - real implementation would use LLM generation.
+    This is a placeholder - real implementation uses DocumentGenerator.
+    Kept for backwards compatibility but should not be called directly.
     """
-    # Build room summaries
-    room_lines = []
-    for room in session.rooms:
-        area = room.length_ft * room.width_ft
-        volume = area * room.ceiling_height_ft
-        room_lines.append(
-            f"| {room.name} | {room.length_ft:.0f}' x {room.width_ft:.0f}' x {room.ceiling_height_ft:.0f}' | "
-            f"{area:,.0f} | {volume:,.0f} |"
-        )
-    room_table = "\n".join(room_lines)
+    r = session.room
+    area = r.length_ft * r.width_ft
+    volume = area * r.ceiling_height_ft
 
     # Build vision summary
     vision_lines = []
@@ -302,18 +296,13 @@ def _generate_sow_markdown(
 
     markdown = f"""# Cleaning Specification / Scope of Work
 
-## Project Information
+## Room Information
 
 | Field | Value |
 |-------|-------|
-| **Project Name** | {session.project.project_name} |
-| **Address** | {session.project.address}, {session.project.city}, {session.project.state} {session.project.zip_code} |
-| **Client** | {session.project.client_name} |
-| **Fire Date** | {session.project.fire_date} |
-| **Assessment Date** | {session.project.assessment_date} |
-| **Facility Classification** | {session.project.facility_classification} |
-| **Construction Era** | {session.project.construction_era} |
-| **Assessor** | {session.project.assessor_name} {session.project.assessor_credentials or ''} |
+| **Room Name** | {r.name} |
+| **Facility Classification** | {r.facility_classification or 'Not specified'} |
+| **Construction Era** | {r.construction_era or 'Not specified'} |
 
 ---
 
@@ -321,18 +310,21 @@ def _generate_sow_markdown(
 
 | Metric | Value |
 |--------|-------|
-| Total Rooms/Areas | {stats['total_rooms']} |
+| Room | {r.name} |
 | Total Floor Area | {stats['total_floor_area_sf']} SF |
 | Total Volume | {stats['total_volume_cf']} CF |
 | Images Analyzed | {stats['total_images']} |
 
 ---
 
-## Room Inventory
+## Room Details
 
-| Room/Area | Dimensions | Area (SF) | Volume (CF) |
-|-----------|------------|-----------|-------------|
-{room_table}
+| Property | Value |
+|----------|-------|
+| **Room Name** | {r.name} |
+| **Dimensions** | {r.length_ft:.0f}' x {r.width_ft:.0f}' x {r.ceiling_height_ft:.0f}' |
+| **Floor Area** | {area:,.0f} SF |
+| **Volume** | {volume:,.0f} CF |
 
 ---
 

ui/tabs/room.py

@@ -0,0 +1,275 @@
+"""Tab 1: Room Assessment.
+
+Single room input with dimensions and assessment context.
+MVP Simplification: No multi-room support.
+"""
+
+import gradio as gr
+from typing import Any
+
+from ui.state import SessionState
+from ui.constants import CEILING_HEIGHT_PRESETS
+
+
+# Facility classification options
+FACILITY_OPTIONS = [
+    ("Operational", "operational"),
+    ("Non-Operational", "non-operational"),
+    ("Public/Childcare", "public-childcare"),
+]
+
+# Construction era options
+CONSTRUCTION_ERA_OPTIONS = [
+    ("Pre-1980 (potential LBP/ACM)", "pre-1980"),
+    ("1980-2000", "1980-2000"),
+    ("Post-2000", "post-2000"),
+]
+
+
+def create_tab() -> dict[str, Any]:
+    """Create Tab 1 UI components.
+
+    Returns:
+        Dictionary of component references for event wiring.
+    """
+    gr.Markdown("### Room Assessment")
+    gr.Markdown("*Enter room details and assessment context.*")
+
+    # Room identification
+    room_name = gr.Textbox(
+        label="Room/Area Name *",
+        placeholder="e.g., Warehouse Bay A, Office 101",
+        elem_id="room_name",
+    )
+
+    # Dimensions
+    gr.Markdown("#### Dimensions")
+    with gr.Row():
+        room_length = gr.Number(
+            label="Length (ft) *",
+            minimum=1,
+            value=None,
+            elem_id="room_length",
+        )
+        room_width = gr.Number(
+            label="Width (ft) *",
+            minimum=1,
+            value=None,
+            elem_id="room_width",
+        )
+
+    with gr.Row():
+        room_height_preset = gr.Dropdown(
+            label="Ceiling Height *",
+            choices=CEILING_HEIGHT_PRESETS,
+            elem_id="room_height_preset",
+            info="Select preset or choose Custom",
+        )
+        room_height_custom = gr.Number(
+            label="Custom Height (ft)",
+            minimum=1,
+            value=None,
+            visible=False,
+            elem_id="room_height_custom",
+        )
+
+    # Calculated displays
+    with gr.Row():
+        floor_area = gr.Textbox(
+            label="Floor Area (SF)",
+            value="0",
+            interactive=False,
+        )
+        room_volume = gr.Textbox(
+            label="Volume (CF)",
+            value="0",
+            interactive=False,
+        )
+
+    # Assessment context (moved from Project tab)
+    gr.Markdown("#### Assessment Context")
+
+    facility_classification = gr.Radio(
+        label="Facility Classification *",
+        choices=FACILITY_OPTIONS,
+        value="non-operational",
+        elem_id="facility_classification",
+        info="Affects clearance thresholds",
+    )
+
+    construction_era = gr.Radio(
+        label="Construction Era *",
+        choices=CONSTRUCTION_ERA_OPTIONS,
+        value="post-2000",
+        elem_id="construction_era",
+        info="Pre-1980 triggers LBP/ACM flags",
+    )
+
+    # Validation status
+    validation_status = gr.HTML(
+        value="",
+        elem_id="tab1_validation",
+    )
+
+    validate_btn = gr.Button(
+        "Continue to Images →",
+        variant="primary",
+    )
+
+    return {
+        "room_name": room_name,
+        "room_length": room_length,
+        "room_width": room_width,
+        "room_height_preset": room_height_preset,
+        "room_height_custom": room_height_custom,
+        "floor_area": floor_area,
+        "room_volume": room_volume,
+        "facility_classification": facility_classification,
+        "construction_era": construction_era,
+        "validation_status": validation_status,
+        "validate_btn": validate_btn,
+    }
+
+
+def on_height_preset_change(preset_value: int | None) -> dict:
+    """Show/hide custom height input based on preset selection.
+
+    Args:
+        preset_value: The selected preset value, or None for "Custom".
+
+    Returns:
+        Gradio update dict for custom height visibility.
+    """
+    return gr.update(visible=(preset_value is None))
+
+
+def update_calculated_values(
+    length: float | None,
+    width: float | None,
+    height_preset: int | None,
+    height_custom: float | None,
+) -> tuple[str, str]:
+    """Calculate and return floor area and volume.
+
+    Returns:
+        Tuple of (floor_area_str, volume_str).
+    """
+    # Get effective values
+    length_val = float(length) if length and length > 0 else 0
+    width_val = float(width) if width and width > 0 else 0
+
+    if height_preset is not None:
+        height_val = float(height_preset)
+    elif height_custom is not None and height_custom > 0:
+        height_val = float(height_custom)
+    else:
+        height_val = 0
+
+    # Calculate
+    area = length_val * width_val
+    volume = area * height_val
+
+    return f"{area:,.0f}", f"{volume:,.0f}"
+
+
+def save_room_to_session(
+    session: SessionState,
+    name: str,
+    length: float | None,
+    width: float | None,
+    height_preset: int | None,
+    height_custom: float | None,
+    facility_classification: str,
+    construction_era: str,
+) -> SessionState:
+    """Save room data to session (called on field changes).
+
+    Returns:
+        Updated session.
+    """
+    # Determine actual ceiling height
+    if height_preset is not None:
+        height = float(height_preset)
+    elif height_custom is not None and height_custom > 0:
+        height = float(height_custom)
+    else:
+        height = 0
+
+    # Update session room data
+    session.room.name = name.strip() if name else ""
+    session.room.length_ft = float(length) if length and length > 0 else 0
+    session.room.width_ft = float(width) if width and width > 0 else 0
+    session.room.ceiling_height_ft = height
+    session.room.facility_classification = facility_classification
+    session.room.construction_era = construction_era
+    session.update_timestamp()
+
+    return session
+
+
+def validate_and_continue(session: SessionState) -> tuple[SessionState, str, int]:
+    """Validate Tab 1 and proceed to Tab 2.
+
+    Returns:
+        Tuple of (session, validation_html, next_tab_index).
+    """
+    is_valid, errors = session.validate_tab1()
+
+    if is_valid:
+        session.tab1_complete = True
+        session.update_timestamp()
+        html = """
+        <div style="background: #e8f5e9; border: 1px solid #66bb6a; border-radius: 4px; padding: 10px;">
+            <span style="color: #2e7d32;">✓ Room details complete. Proceeding to Images tab...</span>
+        </div>
+        """
+        return session, html, gr.update(selected=1)  # Go to tab index 1 (Images)
+    else:
+        session.tab1_complete = False
+        error_items = "".join(f"<li>{e}</li>" for e in errors)
+        html = f"""
+        <div style="background: #ffebee; border: 1px solid #ef5350; border-radius: 4px; padding: 10px;">
+            <strong style="color: #c62828;">Please fix the following:</strong>
+            <ul style="margin: 5px 0 0 0; padding-left: 20px; color: #c62828;">
+                {error_items}
+            </ul>
+        </div>
+        """
+        return session, html, gr.update(selected=0)  # Stay on current tab
+
+
+def load_from_session(session: SessionState) -> tuple[str, float | None, float | None, int | None, float | None, str, str, str, str]:
+    """Load room data from session.
+
+    Returns:
+        Tuple of (name, length, width, height_preset, height_custom,
+                  floor_area, volume, facility_classification, construction_era).
+    """
+    r = session.room
+
+    # Determine if height matches a preset or is custom
+    height_preset = None
+    height_custom = None
+
+    # Check if ceiling height matches a preset value
+    preset_values = [p[1] for p in CEILING_HEIGHT_PRESETS if p[1] is not None]
+    if r.ceiling_height_ft in preset_values:
+        height_preset = int(r.ceiling_height_ft)
+    elif r.ceiling_height_ft > 0:
+        height_custom = r.ceiling_height_ft
+
+    # Calculate stats
+    area = r.length_ft * r.width_ft
+    volume = area * r.ceiling_height_ft
+
+    return (
+        r.name,
+        r.length_ft if r.length_ft > 0 else None,
+        r.width_ft if r.width_ft > 0 else None,
+        height_preset,
+        height_custom,
+        f"{area:,.0f}",
+        f"{volume:,.0f}",
+        r.facility_classification,
+        r.construction_era,
+    )

ui/tabs/rooms.py

@@ -1,344 +0,0 @@
-"""Tab 2: Building/Rooms.
-
-Manages rooms and areas for assessment with dimensions.
-"""
-
-import uuid
-import gradio as gr
-from typing import Any
-
-from ui.state import SessionState, RoomFormData
-from ui.components import create_room_table_data
-from ui.constants import FLOOR_OPTIONS, CEILING_HEIGHT_PRESETS
-
-
-def create_tab() -> dict[str, Any]:
-    """Create Tab 2 UI components.
-
-    Returns:
-        Dictionary of component references for event wiring.
-    """
-    gr.Markdown("### Building/Rooms")
-    gr.Markdown("*Add rooms and areas to assess. At least one room is required.*")
-
-    with gr.Row():
-        with gr.Column(scale=2):
-            room_name = gr.Textbox(
-                label="Room/Area Name *",
-                placeholder="e.g., Warehouse Bay A",
-                elem_id="room_name",
-            )
-            room_floor = gr.Dropdown(
-                label="Floor (optional)",
-                choices=FLOOR_OPTIONS,
-                elem_id="room_floor",
-            )
-            with gr.Row():
-                room_length = gr.Number(
-                    label="Length (ft) *",
-                    minimum=1,
-                    value=None,
-                    elem_id="room_length",
-                )
-                room_width = gr.Number(
-                    label="Width (ft) *",
-                    minimum=1,
-                    value=None,
-                    elem_id="room_width",
-                )
-            with gr.Row():
-                room_height_preset = gr.Dropdown(
-                    label="Ceiling Height *",
-                    choices=CEILING_HEIGHT_PRESETS,
-                    elem_id="room_height_preset",
-                    info="Select preset or choose Custom",
-                )
-                room_height_custom = gr.Number(
-                    label="Custom Height (ft)",
-                    minimum=1,
-                    value=None,
-                    visible=False,
-                    elem_id="room_height_custom",
-                )
-
-            with gr.Row():
-                add_room_btn = gr.Button("Add Room", variant="primary")
-                clear_form_btn = gr.Button("Clear Form", variant="secondary")
-
-        with gr.Column(scale=3):
-            rooms_table = gr.Dataframe(
-                headers=["Name", "L x W x H", "Area (SF)", "Volume (CF)"],
-                label="Rooms Added",
-                interactive=False,
-                elem_id="rooms_table",
-            )
-            with gr.Row():
-                remove_last_btn = gr.Button("Remove Last Room", variant="secondary")
-                clear_all_btn = gr.Button("Clear All Rooms", variant="stop")
-
-    # Summary stats
-    with gr.Row():
-        room_count = gr.Textbox(
-            label="Total Rooms",
-            value="0",
-            interactive=False,
-        )
-        total_area = gr.Textbox(
-            label="Total Floor Area (SF)",
-            value="0",
-            interactive=False,
-        )
-        total_volume = gr.Textbox(
-            label="Total Volume (CF)",
-            value="0",
-            interactive=False,
-        )
-
-    # Validation status
-    with gr.Row():
-        validation_status = gr.HTML(
-            value="",
-            elem_id="tab2_validation",
-        )
-
-    with gr.Row():
-        back_btn = gr.Button("← Back to Project Info")
-        validate_btn = gr.Button(
-            "Validate & Continue to Images →",
-            variant="primary",
-        )
-
-    return {
-        "room_name": room_name,
-        "room_floor": room_floor,
-        "room_length": room_length,
-        "room_width": room_width,
-        "room_height_preset": room_height_preset,
-        "room_height_custom": room_height_custom,
-        "add_room_btn": add_room_btn,
-        "clear_form_btn": clear_form_btn,
-        "rooms_table": rooms_table,
-        "remove_last_btn": remove_last_btn,
-        "clear_all_btn": clear_all_btn,
-        "room_count": room_count,
-        "total_area": total_area,
-        "total_volume": total_volume,
-        "validation_status": validation_status,
-        "back_btn": back_btn,
-        "validate_btn": validate_btn,
-    }
-
-
-def add_room(
-    session: SessionState,
-    name: str,
-    floor: str | None,
-    length: float,
-    width: float,
-    height_preset: int | None,
-    height_custom: float | None,
-) -> tuple[SessionState, list[list], str, str, str, str, str | None, float | None, float | None, None, None]:
-    """Add a room to the session.
-
-    Returns:
-        Tuple of (session, table_data, validation_html, room_count, total_area, total_volume,
-                  cleared_name, cleared_floor, cleared_length, cleared_width,
-                  cleared_height_preset, cleared_height_custom).
-    """
-    validation_html = ""
-
-    # Determine actual ceiling height from preset or custom
-    if height_preset is not None:
-        height = float(height_preset)
-    elif height_custom is not None and height_custom > 0:
-        height = float(height_custom)
-    else:
-        height = None
-
-    # Validate input
-    errors = []
-    if not name or not name.strip():
-        errors.append("Room name is required")
-    if not length or length <= 0:
-        errors.append("Length must be greater than 0")
-    if not width or width <= 0:
-        errors.append("Width must be greater than 0")
-    if not height or height <= 0:
-        errors.append("Ceiling height is required (select preset or enter custom)")
-
-    if errors:
-        error_items = "".join(f"<li>{e}</li>" for e in errors)
-        validation_html = f"""
-        <div style="background: #ffebee; border: 1px solid #ef5350; border-radius: 4px; padding: 10px;">
-            <ul style="margin: 0; padding-left: 20px; color: #c62828;">
-                {error_items}
-            </ul>
-        </div>
-        """
-        # Return current state without changes
-        table_data = create_room_table_data(session)
-        stats = _calculate_stats(session)
-        return (
-            session,
-            table_data,
-            validation_html,
-            stats["count"],
-            stats["area"],
-            stats["volume"],
-            name or "",
-            floor,
-            length,
-            width,
-            height_preset,
-            height_custom,
-        )
-
-    # Add the room
-    room = RoomFormData(
-        id=f"room-{uuid.uuid4().hex[:8]}",
-        name=name.strip(),
-        floor=floor.strip() if floor else "",
-        length_ft=float(length),
-        width_ft=float(width),
-        ceiling_height_ft=float(height),
-    )
-    session.rooms.append(room)
-    session.update_timestamp()
-
-    # Success message
-    validation_html = f"""
-    <div style="background: #e8f5e9; border: 1px solid #66bb6a; border-radius: 4px; padding: 10px;">
-        <span style="color: #2e7d32;">✓ Added room: {name}</span>
-    </div>
-    """
-
-    table_data = create_room_table_data(session)
-    stats = _calculate_stats(session)
-
-    # Clear form fields (return None for Number components, None for dropdowns)
-    return (
-        session,
-        table_data,
-        validation_html,
-        stats["count"],
-        stats["area"],
-        stats["volume"],
-        "",  # Clear name
-        None,  # Clear floor dropdown
-        None,  # Clear length
-        None,  # Clear width
-        None,  # Clear height preset
-        None,  # Clear height custom
-    )
-
-
-def on_height_preset_change(preset_value: int | None) -> dict:
-    """Show/hide custom height input based on preset selection.
-
-    Args:
-        preset_value: The selected preset value, or None for "Custom".
-
-    Returns:
-        Gradio update dict for custom height visibility.
-    """
-    # If None (Custom selected), show custom input; otherwise hide it
-    return gr.update(visible=(preset_value is None))
-
-
-def remove_last_room(session: SessionState) -> tuple[SessionState, list[list], str, str, str]:
-    """Remove the last room from the session."""
-    if session.rooms:
-        removed = session.rooms.pop()
-        session.update_timestamp()
-        validation_html = f"""
-        <div style="background: #fff3e0; border: 1px solid #ffb74d; border-radius: 4px; padding: 10px;">
-            <span style="color: #e65100;">Removed room: {removed.name}</span>
-        </div>
-        """
-    else:
-        validation_html = ""
-
-    table_data = create_room_table_data(session)
-    stats = _calculate_stats(session)
-    return session, table_data, validation_html, stats["count"], stats["area"], stats["volume"]
-
-
-def clear_all_rooms(session: SessionState) -> tuple[SessionState, list[list], str, str, str, str]:
-    """Clear all rooms from the session."""
-    count = len(session.rooms)
-    session.rooms = []
-    session.update_timestamp()
-
-    validation_html = ""
-    if count > 0:
-        validation_html = f"""
-        <div style="background: #fff3e0; border: 1px solid #ffb74d; border-radius: 4px; padding: 10px;">
-            <span style="color: #e65100;">Cleared {count} room(s)</span>
-        </div>
-        """
-
-    return session, [], validation_html, "0", "0", "0"
-
-
-def validate_and_continue(session: SessionState) -> tuple[SessionState, str, int]:
-    """Validate Tab 2 and proceed to Tab 3.
-
-    Returns:
-        Tuple of (session, validation_html, next_tab_index).
-    """
-    is_valid, errors = session.validate_tab2()
-
-    if is_valid:
-        session.tab2_complete = True
-        session.update_timestamp()
-        html = """
-        <div style="background: #e8f5e9; border: 1px solid #66bb6a; border-radius: 4px; padding: 10px;">
-            <span style="color: #2e7d32;">✓ Rooms complete. Proceeding to Images tab...</span>
-        </div>
-        """
-        return session, html, gr.update(selected=2)  # Go to tab index 2 (Images)
-    else:
-        session.tab2_complete = False
-        error_items = "".join(f"<li>{e}</li>" for e in errors)
-        html = f"""
-        <div style="background: #ffebee; border: 1px solid #ef5350; border-radius: 4px; padding: 10px;">
-            <strong style="color: #c62828;">Please fix the following:</strong>
-            <ul style="margin: 5px 0 0 0; padding-left: 20px; color: #c62828;">
-                {error_items}
-            </ul>
-        </div>
-        """
-        return session, html, gr.update(selected=1)  # Stay on current tab
-
-
-def load_from_session(session: SessionState) -> tuple[list[list], str, str, str]:
-    """Load table data and stats from session.
-
-    Returns:
-        Tuple of (table_data, room_count, total_area, total_volume).
-    """
-    table_data = create_room_table_data(session)
-    stats = _calculate_stats(session)
-    return table_data, stats["count"], stats["area"], stats["volume"]
-
-
-def _calculate_stats(session: SessionState) -> dict[str, str]:
-    """Calculate room statistics."""
-    count = len(session.rooms)
-    total_area = sum(r.length_ft * r.width_ft for r in session.rooms)
-    total_volume = sum(r.length_ft * r.width_ft * r.ceiling_height_ft for r in session.rooms)
-
-    return {
-        "count": str(count),
-        "area": f"{total_area:,.0f}",
-        "volume": f"{total_volume:,.0f}",
-    }
-
-
-def get_room_choices(session: SessionState) -> list[tuple[str, str]]:
-    """Get room choices for dropdown (used in Images tab).
-
-    Returns:
-        List of (display_name, room_id) tuples.
-    """
-    return [(r.name, r.id) for r in session.rooms]