Frontend simplification (4→2 tabs) + lazy imports for HF Spaces

Major changes:
- Consolidate 4 tabs into 2: Input (room+images+observations) and Results+Chat
- Add chat interface for Q&A and document modifications (pipeline/chat.py)
- Lazy imports throughout to defer chromadb until needed
- Auto-build RAG index on startup if empty
- Default mock_models=False for production

Files added:
- ui/tabs/input_tab.py: Combined input tab with accordions
- ui/tabs/results_tab.py: Results display with chat interface
- pipeline/chat.py: Chat handler using vision model in text-only mode

Import chain fixes (HF Spaces compatibility):
- pipeline/__init__.py: __getattr__ lazy imports
- rag/__init__.py: __getattr__ lazy imports
- pipeline/main.py, dispositions.py, generator.py: TYPE_CHECKING + deferred imports
- rag/retriever.py: Lazy vectorstore import in __init__

FDAM methodology fixes:
- Public/Childcare lead threshold: 4.3 → 0.54 µg/100cm² (FDAM §1.4)
- Sample density tiers for large areas (FDAM §2.3)

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

CLAUDE.md

@@ -34,8 +34,20 @@ 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.
+**Simplified 2-Tab UI:** Input + Results/Chat.
+Single-room workflow with integrated chat for Q&A and document modifications.
+
+### Tab 1: Input
+Uses `gr.Accordion` for collapsible sections:
+- **Room Details** (open by default): Name, dimensions, ceiling height, facility classification, construction era
+- **Images** (open by default): Multi-file upload, gallery preview, image count
+- **Field Observations** (collapsed by default): 15 qualitative observation fields
+
+### Tab 2: Results + Chat
+- **Results Display**: Annotated gallery, assessment stats (JSON), SOW document (markdown)
+- **Downloads**: Markdown and PDF export
+- **Chat Interface**: Q&A about results, document modifications via `gr.Chatbot(type="messages")`
+- **Quick Actions**: Pre-defined buttons for common queries
 
 The frontend uses optimized input components:
 
@@ -47,9 +59,11 @@ The frontend uses optimized input components:
 | 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 |
+| Chat | `gr.Chatbot(type="messages")` | Gradio 6 messages format |
 
 **Keyboard Shortcuts:**
-- `Ctrl+1` through `Ctrl+4`: Navigate between tabs
+- `Ctrl+1`: Navigate to Input tab
+- `Ctrl+2`: Navigate to Results tab
 
 ## Development Commands
 
@@ -87,8 +101,12 @@ mypy .                    # Type checking
 ├── models/                # Model loading (mock vs real)
 ├── rag/                   # Chunking, vectorstore, retrieval
 ├── schemas/               # Pydantic input/output models
-├── pipeline/              # Main processing logic
-├── ui/                    # Gradio UI components (4 tabs: room, images, observations, results)
+├── pipeline/              # Main processing logic + chat handler
+│   └── chat.py            # Chat handler for Q&A and document mods
+├── ui/                    # Gradio UI components
+│   └── tabs/              # Tab modules
+│       ├── input_tab.py   # Combined input (room + images + observations)
+│       └── results_tab.py # Results display + chat interface
 ├── RAG-KB/                # Knowledge base source files
 ├── chroma_db/             # ChromaDB persistence (generated)
 └── sample_images/         # Sample fire damage images for testing

app.py

@@ -1,7 +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).
+Main Gradio application entry point with session state and chat functionality.
+Simplified UI: 2 tabs (Input + Results/Chat).
 """
 
 import gradio as gr
@@ -18,20 +18,18 @@ logger = logging.getLogger(__name__)
 from models.loader import get_models
 from ui.state import SessionState, create_new_session
 from ui.storage import get_head_html
-from ui.tabs import room, images, observations, results
+from ui.tabs import input_tab, results_tab
 from ui import samples
+from pipeline.chat import ChatHandler, get_quick_action_message
 
 
-# Keyboard shortcuts JavaScript (Ctrl+1-4 for tab navigation)
+# Keyboard shortcuts JavaScript (Ctrl+1-2 for tab navigation)
 KEYBOARD_JS = """
 <script>
 document.addEventListener('keydown', (e) => {
-    if (e.ctrlKey && e.key >= '1' && e.key <= '4') {
+    if (e.ctrlKey && e.key >= '1' && e.key <= '2') {
         e.preventDefault();
-        const tabIds = [
-            'tab-room-button', 'tab-images-button',
-            'tab-observations-button', 'tab-results-button'
-        ];
+        const tabIds = ['tab-input-button', 'tab-results-button'];
         const tabIndex = parseInt(e.key) - 1;
         const tabButton = document.getElementById(tabIds[tabIndex]);
         if (tabButton) {
@@ -53,17 +51,39 @@ VALIDATION_CSS = """
 """
 
 
+def ensure_rag_index():
+    """Ensure RAG index is built. Builds on first run if empty."""
+    from pathlib import Path
+    try:
+        # Check if index exists and has content
+        chroma_path = Path(__file__).parent / "chroma_db"
+        if not chroma_path.exists() or not any(chroma_path.iterdir()):
+            logger.info("RAG index empty or missing - building from RAG-KB...")
+            from rag.index_builder import build_index
+            stats = build_index(rebuild=False)
+            logger.info(f"RAG index built: {stats['chunks_created']} chunks from {stats['documents_processed']} documents")
+        else:
+            logger.info("RAG index found")
+    except Exception as e:
+        logger.warning(f"RAG index build failed (will use fallback): {e}")
+
+
 def create_app() -> gr.Blocks:
     """Create the main Gradio application."""
 
     # Initialize models at startup
     model_stack = get_models()
 
-    # Note: head parameter moved to launch() in Gradio 6.0
-    # localStorage JS will be injected there
+    # Ensure RAG index is built (builds on first run)
+    ensure_rag_index()
+
+    # Initialize chat handler
+    chat_handler = ChatHandler(model_stack)
+
     with gr.Blocks(
         title="FDAM AI Pipeline - Fire Damage Assessment",
         css=VALIDATION_CSS,
+        head=get_head_html(KEYBOARD_JS),
     ) as app:
         # Session state (stored in Gradio State component)
         session_state = gr.State(value=create_new_session())
@@ -100,31 +120,19 @@ def create_app() -> gr.Blocks:
             sample_status = gr.HTML(
                 value="",
                 elem_id="sample_status",
-                scale=3,
             )
 
-        # Tab navigation (elem_id for stable JS selectors - Gradio appends "-button" for tab buttons)
-        # Store Tab references for individual select event handlers
+        # Tab navigation (2 tabs)
         with gr.Tabs() as tabs:
-            # 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:
-                tab2 = images.create_tab()
-
-            # Tab 3: Observations
-            tab_observations = gr.Tab("3. Observations", id=2, elem_id="tab-observations")
-            with tab_observations:
-                tab3 = observations.create_tab()
-
-            # Tab 4: Generate Results
-            tab_results = gr.Tab("4. Generate Results", id=3, elem_id="tab-results")
+            # Tab 1: Input (combined room + images + observations)
+            tab_input = gr.Tab("1. Input", id=0, elem_id="tab-input")
+            with tab_input:
+                tab1 = input_tab.create_tab()
+
+            # Tab 2: Results + Chat
+            tab_results = gr.Tab("2. Results", id=1, elem_id="tab-results")
             with tab_results:
-                tab4 = results.create_tab()
+                tab2 = results_tab.create_tab()
 
         # --- Event Handlers ---
 
@@ -132,13 +140,14 @@ def create_app() -> gr.Blocks:
         def handle_sample_load(scenario_id: str, current_session: SessionState):
             """Handle sample dropdown selection."""
             if not scenario_id:
-                # Empty selection, do nothing
                 return (
-                    current_session,  # session_state unchanged
-                    *room.load_from_session(current_session),  # room form values
-                    gr.update(),  # tabs unchanged
-                    "",  # clear status
-                    "",  # reset dropdown
+                    current_session,
+                    *input_tab.load_room_from_session(current_session),
+                    *input_tab.load_images_from_session(current_session),
+                    *input_tab.load_observations_from_session(current_session),
+                    gr.update(),
+                    "",
+                    "",
                 )
 
             # Load the sample
@@ -146,7 +155,9 @@ def create_app() -> gr.Blocks:
             if not new_session:
                 return (
                     current_session,
-                    *room.load_from_session(current_session),
+                    *input_tab.load_room_from_session(current_session),
+                    *input_tab.load_images_from_session(current_session),
+                    *input_tab.load_observations_from_session(current_session),
                     gr.update(),
                     '<span style="color: #c62828;">Error: Sample not found</span>',
                     "",
@@ -157,14 +168,18 @@ def create_app() -> gr.Blocks:
             name = scenario.name if scenario else scenario_id
 
             # Load form values from new session
-            form_values = room.load_from_session(new_session)
+            room_values = input_tab.load_room_from_session(new_session)
+            image_values = input_tab.load_images_from_session(new_session)
+            obs_values = input_tab.load_observations_from_session(new_session)
 
             return (
-                new_session,  # updated session_state
-                *form_values,  # room form values for Tab 1
-                gr.update(selected=0),  # switch to Tab 1 (Gradio 6.x syntax)
+                new_session,
+                *room_values,
+                *image_values,
+                *obs_values,
+                gr.update(selected=0),  # Stay on Input tab
                 f'<span style="color: #2e7d32;">Loaded sample: {name}</span>',
-                "",  # reset dropdown to empty
+                "",  # reset dropdown
             )
 
         sample_dropdown.change(
@@ -172,6 +187,7 @@ def create_app() -> gr.Blocks:
             inputs=[sample_dropdown, session_state],
             outputs=[
                 session_state,
+                # Room outputs (9)
                 tab1["room_name"],
                 tab1["room_length"],
                 tab1["room_width"],
@@ -181,15 +197,36 @@ def create_app() -> gr.Blocks:
                 tab1["room_volume"],
                 tab1["facility_classification"],
                 tab1["construction_era"],
+                # Image outputs (3)
+                tab1["images_gallery"],
+                tab1["image_count"],
+                tab1["resume_warning"],
+                # Observation outputs (15)
+                tab1["smoke_odor"],
+                tab1["odor_intensity"],
+                tab1["visible_soot"],
+                tab1["soot_description"],
+                tab1["large_char"],
+                tab1["char_density"],
+                tab1["ash_residue"],
+                tab1["ash_description"],
+                tab1["surface_discoloration"],
+                tab1["discoloration_description"],
+                tab1["dust_interference"],
+                tab1["dust_notes"],
+                tab1["wildfire_indicators"],
+                tab1["wildfire_notes"],
+                tab1["additional_notes"],
+                # Navigation
                 tabs,
                 sample_status,
                 sample_dropdown,
             ],
         )
 
-        # Tab 1: Room Assessment
+        # --- Tab 1: Input ---
 
-        # Save room data on field changes
+        # Room field changes - save to session and update calculations
         def on_room_field_change(
             session: SessionState,
             name: str,
@@ -201,16 +238,15 @@ def create_app() -> gr.Blocks:
             construction_era: str,
         ):
             """Save room data and update calculated values."""
-            updated_session = room.save_room_to_session(
+            updated_session = input_tab.save_room_to_session(
                 session, name, length, width, height_preset, height_custom,
                 facility_classification, construction_era
             )
-            floor_area, volume = room.update_calculated_values(
+            floor_area, volume = input_tab.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"],
@@ -238,164 +274,317 @@ def create_app() -> gr.Blocks:
                 outputs=room_outputs,
             )
 
-        # Show/hide custom height input based on preset selection
+        # Show/hide custom height input
         tab1["room_height_preset"].change(
-            fn=room.on_height_preset_change,
+            fn=input_tab.on_height_preset_change,
             inputs=[tab1["room_height_preset"]],
             outputs=[tab1["room_height_custom"]],
         )
 
-        tab1["validate_btn"].click(
-            fn=room.validate_and_continue,
-            inputs=[session_state],
+        # Image handling
+        tab1["add_image_btn"].click(
+            fn=input_tab.add_image,
+            inputs=[
+                session_state,
+                tab1["image_upload"],
+                tab1["image_description"],
+            ],
             outputs=[
                 session_state,
+                tab1["images_gallery"],
                 tab1["validation_status"],
-                tabs,
+                tab1["image_count"],
+                tab1["image_upload"],
+                tab1["image_description"],
             ],
         )
 
-        # Tab 2: Images
-        tab2["add_image_btn"].click(
-            fn=images.add_image,
-            inputs=[
-                session_state,
-                tab2["image_upload"],
-                tab2["image_description"],
+        tab1["clear_upload_btn"].click(
+            fn=lambda: (None, ""),
+            outputs=[
+                tab1["image_upload"],
+                tab1["image_description"],
             ],
+        )
+
+        tab1["remove_last_btn"].click(
+            fn=input_tab.remove_last_image,
+            inputs=[session_state],
             outputs=[
                 session_state,
-                tab2["images_gallery"],
-                tab2["validation_status"],
-                tab2["image_count"],
-                tab2["image_upload"],
-                tab2["image_description"],
+                tab1["images_gallery"],
+                tab1["validation_status"],
+                tab1["image_count"],
             ],
         )
 
-        tab2["clear_upload_btn"].click(
-            fn=lambda: (None, ""),
+        tab1["clear_all_btn"].click(
+            fn=input_tab.clear_all_images,
+            inputs=[session_state],
             outputs=[
-                tab2["image_upload"],
-                tab2["image_description"],
+                session_state,
+                tab1["images_gallery"],
+                tab1["validation_status"],
+                tab1["image_count"],
             ],
         )
 
-        tab2["remove_last_btn"].click(
-            fn=images.remove_last_image,
-            inputs=[session_state],
+        # Generate button - validate and switch to results
+        def on_generate_click(
+            session: SessionState,
+            smoke_odor: bool,
+            odor_intensity: str,
+            visible_soot: bool,
+            soot_description: str,
+            large_char: bool,
+            char_density: str,
+            ash_residue: bool,
+            ash_description: str,
+            surface_discoloration: bool,
+            discoloration_description: str,
+            dust_interference: bool,
+            dust_notes: str,
+            wildfire_indicators: bool,
+            wildfire_notes: str,
+            additional_notes: str,
+        ):
+            """Save observations and validate before generating."""
+            # Save observations first
+            session = input_tab.save_observations_to_session(
+                session,
+                smoke_odor, odor_intensity, visible_soot, soot_description,
+                large_char, char_density, ash_residue, ash_description,
+                surface_discoloration, discoloration_description,
+                dust_interference, dust_notes, wildfire_indicators,
+                wildfire_notes, additional_notes,
+            )
+            # Validate and potentially switch tabs
+            return input_tab.validate_and_generate(session)
+
+        tab1["generate_btn"].click(
+            fn=on_generate_click,
+            inputs=[
+                session_state,
+                tab1["smoke_odor"],
+                tab1["odor_intensity"],
+                tab1["visible_soot"],
+                tab1["soot_description"],
+                tab1["large_char"],
+                tab1["char_density"],
+                tab1["ash_residue"],
+                tab1["ash_description"],
+                tab1["surface_discoloration"],
+                tab1["discoloration_description"],
+                tab1["dust_interference"],
+                tab1["dust_notes"],
+                tab1["wildfire_indicators"],
+                tab1["wildfire_notes"],
+                tab1["additional_notes"],
+            ],
             outputs=[
                 session_state,
-                tab2["images_gallery"],
-                tab2["validation_status"],
-                tab2["image_count"],
+                tab1["validation_status"],
+                tabs,
             ],
         )
 
-        tab2["clear_all_btn"].click(
-            fn=images.clear_all_images,
+        # --- Tab 2: Results + Chat ---
+
+        # Generate assessment
+        tab2["generate_btn"].click(
+            fn=results_tab.generate_assessment,
             inputs=[session_state],
             outputs=[
                 session_state,
-                tab2["images_gallery"],
-                tab2["validation_status"],
-                tab2["image_count"],
+                tab2["processing_status"],
+                tab2["progress_html"],
+                tab2["annotated_gallery"],
+                tab2["stats_output"],
+                tab2["sow_output"],
+                tab2["download_md"],
+                tab2["download_pdf"],
+                tab2["chatbot"],
             ],
         )
 
-        tab2["validate_btn"].click(
-            fn=images.validate_and_continue,
+        tab2["regenerate_btn"].click(
+            fn=results_tab.generate_assessment,
             inputs=[session_state],
             outputs=[
                 session_state,
-                tab2["validation_status"],
-                tabs,
+                tab2["processing_status"],
+                tab2["progress_html"],
+                tab2["annotated_gallery"],
+                tab2["stats_output"],
+                tab2["sow_output"],
+                tab2["download_md"],
+                tab2["download_pdf"],
+                tab2["chatbot"],
             ],
         )
 
+        # Back to input
         tab2["back_btn"].click(
             fn=lambda: gr.update(selected=0),
             outputs=[tabs],
         )
 
-        # Tab 3: Observations
-        tab3["validate_btn"].click(
-            fn=observations.validate_and_continue,
-            inputs=[
+        # Reset document
+        def on_reset_document(session: SessionState):
+            """Reset document to original and regenerate downloads."""
+            session, doc = results_tab.reset_document(session)
+            md_path, pdf_path = results_tab.regenerate_downloads(session)
+            return session, doc, md_path, pdf_path
+
+        tab2["reset_doc_btn"].click(
+            fn=on_reset_document,
+            inputs=[session_state],
+            outputs=[
                 session_state,
-                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"],
+                tab2["sow_output"],
+                tab2["download_md"],
+                tab2["download_pdf"],
             ],
+        )
+
+        # Chat functionality
+        def handle_chat_message(
+            message: str,
+            session: SessionState,
+            chat_history: list[dict],
+        ):
+            """Process chat message and update UI."""
+            if not message.strip():
+                return session, chat_history, "", session.generated_document or "", None, None
+
+            response, edit, updated_history = chat_handler.process_message(
+                message, session, chat_history
+            )
+
+            # Apply document edit if present
+            if edit and session.generated_document:
+                session.generated_document = chat_handler.apply_document_edit(
+                    session.generated_document, edit
+                )
+                session.update_timestamp()
+                # Regenerate downloads
+                md_path, pdf_path = results_tab.regenerate_downloads(session)
+            else:
+                md_path, pdf_path = None, None
+
+            # Store chat history in session
+            session.chat_history = updated_history
+
+            return (
+                session,
+                updated_history,
+                "",  # Clear input
+                session.generated_document or "",
+                md_path,
+                pdf_path,
+            )
+
+        # Chat send button
+        tab2["chat_send_btn"].click(
+            fn=handle_chat_message,
+            inputs=[tab2["chat_input"], session_state, tab2["chatbot"]],
             outputs=[
                 session_state,
-                tab3["validation_status"],
-                tabs,
+                tab2["chatbot"],
+                tab2["chat_input"],
+                tab2["sow_output"],
+                tab2["download_md"],
+                tab2["download_pdf"],
             ],
         )
 
-        tab3["back_btn"].click(
-            fn=lambda: gr.update(selected=1),
-            outputs=[tabs],
+        # Chat input enter key
+        tab2["chat_input"].submit(
+            fn=handle_chat_message,
+            inputs=[tab2["chat_input"], session_state, tab2["chatbot"]],
+            outputs=[
+                session_state,
+                tab2["chatbot"],
+                tab2["chat_input"],
+                tab2["sow_output"],
+                tab2["download_md"],
+                tab2["download_pdf"],
+            ],
         )
 
-        # Tab 4: Generate Results
-        tab4["generate_btn"].click(
-            fn=results.generate_assessment,
-            inputs=[session_state],
+        # Quick action buttons
+        def send_quick_action(action_key: str, session: SessionState, chat_history: list[dict]):
+            """Send a quick action message."""
+            message = get_quick_action_message(action_key)
+            return handle_chat_message(message, session, chat_history)
+
+        tab2["quick_explain_zones"].click(
+            fn=lambda s, h: send_quick_action("explain_zones", s, h),
+            inputs=[session_state, tab2["chatbot"]],
             outputs=[
                 session_state,
-                tab4["processing_status"],
-                tab4["progress_html"],
-                tab4["annotated_gallery"],
-                tab4["stats_output"],
-                tab4["sow_output"],
-                tab4["download_md"],
-                tab4["download_pdf"],
+                tab2["chatbot"],
+                tab2["chat_input"],
+                tab2["sow_output"],
+                tab2["download_md"],
+                tab2["download_pdf"],
             ],
         )
 
-        tab4["regenerate_btn"].click(
-            fn=results.generate_assessment,
-            inputs=[session_state],
+        tab2["quick_explain_materials"].click(
+            fn=lambda s, h: send_quick_action("explain_materials", s, h),
+            inputs=[session_state, tab2["chatbot"]],
             outputs=[
                 session_state,
-                tab4["processing_status"],
-                tab4["progress_html"],
-                tab4["annotated_gallery"],
-                tab4["stats_output"],
-                tab4["sow_output"],
-                tab4["download_md"],
-                tab4["download_pdf"],
+                tab2["chatbot"],
+                tab2["chat_input"],
+                tab2["sow_output"],
+                tab2["download_md"],
+                tab2["download_pdf"],
             ],
         )
 
-        tab4["back_btn"].click(
-            fn=lambda: gr.update(selected=2),
-            outputs=[tabs],
+        tab2["quick_sampling"].click(
+            fn=lambda s, h: send_quick_action("explain_sampling", s, h),
+            inputs=[session_state, tab2["chatbot"]],
+            outputs=[
+                session_state,
+                tab2["chatbot"],
+                tab2["chat_input"],
+                tab2["sow_output"],
+                tab2["download_md"],
+                tab2["download_pdf"],
+            ],
+        )
+
+        tab2["quick_add_note"].click(
+            fn=lambda s, h: send_quick_action("add_note", s, h),
+            inputs=[session_state, tab2["chatbot"]],
+            outputs=[
+                session_state,
+                tab2["chatbot"],
+                tab2["chat_input"],
+                tab2["sow_output"],
+                tab2["download_md"],
+                tab2["download_pdf"],
+            ],
         )
 
-        # --- Individual Tab Select Handlers ---
-        # 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 Select Handlers ---
+
+        # Load data when switching to Input tab
+        def load_input_tab(session: SessionState):
+            """Load all input data when tab is selected."""
+            room_values = input_tab.load_room_from_session(session)
+            image_values = input_tab.load_images_from_session(session)
+            obs_values = input_tab.load_observations_from_session(session)
+            return (*room_values, *image_values, *obs_values)
 
-        # Tab 1 (Room): Load room form fields when selected
-        tab_room.select(
-            fn=room.load_from_session,
+        tab_input.select(
+            fn=load_input_tab,
             inputs=[session_state],
             outputs=[
+                # Room (9)
                 tab1["room_name"],
                 tab1["room_length"],
                 tab1["room_width"],
@@ -405,55 +594,45 @@ def create_app() -> gr.Blocks:
                 tab1["room_volume"],
                 tab1["facility_classification"],
                 tab1["construction_era"],
+                # Images (3)
+                tab1["images_gallery"],
+                tab1["image_count"],
+                tab1["resume_warning"],
+                # Observations (15)
+                tab1["smoke_odor"],
+                tab1["odor_intensity"],
+                tab1["visible_soot"],
+                tab1["soot_description"],
+                tab1["large_char"],
+                tab1["char_density"],
+                tab1["ash_residue"],
+                tab1["ash_description"],
+                tab1["surface_discoloration"],
+                tab1["discoloration_description"],
+                tab1["dust_interference"],
+                tab1["dust_notes"],
+                tab1["wildfire_indicators"],
+                tab1["wildfire_notes"],
+                tab1["additional_notes"],
             ],
         )
 
-        # Tab 2 (Images): Load gallery and count when selected
-        def load_images_tab(session: SessionState):
-            """Load all images tab data."""
-            gallery, count, warning = images.load_from_session(session)
-            return gallery, count, warning
+        # Load data when switching to Results tab
+        def load_results_tab(session: SessionState):
+            """Load results data when tab is selected."""
+            doc = session.generated_document or "*Generate an assessment to see results here.*"
+            chat = session.chat_history or []
+            return doc, chat
 
-        tab_images.select(
-            fn=load_images_tab,
-            inputs=[session_state],
-            outputs=[
-                tab2["images_gallery"],
-                tab2["image_count"],
-                tab2["resume_warning"],
-            ],
-        )
-
-        # Tab 3 (Observations): Load observation form fields when selected
-        tab_observations.select(
-            fn=observations.load_form_from_session,
+        tab_results.select(
+            fn=load_results_tab,
             inputs=[session_state],
             outputs=[
-                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"],
+                tab2["sow_output"],
+                tab2["chatbot"],
             ],
         )
 
-        # Tab 4 (Results): Check preflight status when selected
-        tab_results.select(
-            fn=results.check_preflight,
-            inputs=[session_state],
-            outputs=[tab4["preflight_status"]],
-        )
-
     return app
 
 
@@ -469,7 +648,6 @@ def main():
         server_name=settings.server_host,
         server_port=settings.server_port,
         share=False,
-        head=get_head_html(KEYBOARD_JS),  # Inject localStorage + keyboard shortcuts
     )
 
 

config/settings.py

@@ -14,7 +14,8 @@ class Settings(BaseSettings):
     log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "INFO"
 
     # Model loading - set MOCK_MODELS=true for local dev on RTX 4090
-    mock_models: bool = True
+    # Default is False for production (HuggingFace Spaces)
+    mock_models: bool = False
 
     # Model paths (for production on HuggingFace Spaces)
     # Single 30B-A3B MoE model with FP8 quantization via vLLM (official, reasoning-enhanced)

pipeline/__init__.py

@@ -3,15 +3,12 @@
 This module provides the core processing pipeline for generating
 fire damage assessment reports using AI vision analysis and
 RAG-enhanced methodology lookup.
-"""
 
-from .calculations import FDAMCalculator
-from .dispositions import DispositionEngine
-from .generator import DocumentGenerator
-from .main import FDAMPipeline, PipelineResult
-from .pdf_generator import PDFGenerator, PDFResult, generate_sow_pdf
+Lazy imports to avoid chromadb dependency at module load time for local development.
+"""
 
 __all__ = [
+    "ChatHandler",
     "FDAMCalculator",
     "DispositionEngine",
     "DocumentGenerator",
@@ -21,3 +18,35 @@ __all__ = [
     "PDFResult",
     "generate_sow_pdf",
 ]
+
+
+def __getattr__(name):
+    """Lazy import pipeline modules only when accessed."""
+    if name == "FDAMCalculator":
+        from .calculations import FDAMCalculator
+        return FDAMCalculator
+    elif name == "ChatHandler":
+        from .chat import ChatHandler
+        return ChatHandler
+    elif name == "DispositionEngine":
+        from .dispositions import DispositionEngine
+        return DispositionEngine
+    elif name == "DocumentGenerator":
+        from .generator import DocumentGenerator
+        return DocumentGenerator
+    elif name == "FDAMPipeline":
+        from .main import FDAMPipeline
+        return FDAMPipeline
+    elif name == "PipelineResult":
+        from .main import PipelineResult
+        return PipelineResult
+    elif name == "PDFGenerator":
+        from .pdf_generator import PDFGenerator
+        return PDFGenerator
+    elif name == "PDFResult":
+        from .pdf_generator import PDFResult
+        return PDFResult
+    elif name == "generate_sow_pdf":
+        from .pdf_generator import generate_sow_pdf
+        return generate_sow_pdf
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

pipeline/calculations.py

@@ -84,7 +84,7 @@ METALS_THRESHOLDS = {
         facility_type="Operational",
     ),
     "public-childcare": MetalsThresholds(
-        lead_ug_100cm2=4.3,  # EPA/HUD October 2024 for floors
+        lead_ug_100cm2=0.54,  # EPA/HUD October 2024: 0.54 µg/100cm² floors per FDAM §1.4
         cadmium_ug_100cm2=3.3,  # Use non-operational as baseline
         arsenic_ug_100cm2=6.7,
         chromium_vi_ug_100cm2=3.3,
@@ -177,7 +177,7 @@ class FDAMCalculator:
         """
         notes = []
 
-        # Base sample density by area size
+        # Base sample density by area size per FDAM §2.3
         if total_area_sf < 5000:
             tape_min, tape_max = 3, 5
             wipe_min, wipe_max = 3, 5
@@ -186,11 +186,15 @@ class FDAMCalculator:
             tape_min, tape_max = 5, 10
             wipe_min, wipe_max = 5, 10
             notes.append("Medium area (5,000-25,000 SF): moderate sampling density")
-        else:
-            # Scale for larger areas
-            tape_min, tape_max = 10, 15
+        elif total_area_sf <= 100000:
+            tape_min, tape_max = 10, 20
             wipe_min, wipe_max = 10, 15
-            notes.append("Large area (>25,000 SF): enhanced sampling density")
+            notes.append("Large area (25,000-100,000 SF): enhanced sampling density")
+        else:
+            # > 100,000 SF per FDAM §2.3
+            tape_min, tape_max = 20, 30
+            wipe_min, wipe_max = 15, 25
+            notes.append("Very large area (>100,000 SF): maximum sampling density")
 
         # Multiply by surface types
         tape_min *= surface_types_count

pipeline/chat.py

@@ -0,0 +1,376 @@
+"""Chat handler for Q&A and document modifications.
+
+Uses the vision model (Qwen3-VL-30B-A3B-Thinking-FP8) in text-only mode
+for chat interactions. The model handles both Q&A about assessment results
+and document modification requests.
+"""
+
+import json
+import logging
+import re
+from typing import Optional
+
+from config.settings import settings
+
+logger = logging.getLogger(__name__)
+
+
+# Chat system prompt
+CHAT_SYSTEM_PROMPT = """You are an expert industrial hygienist assistant helping with fire damage assessment. You have access to the assessment results and can answer questions or modify the generated document.
+
+## Your Capabilities
+1. **Answer Questions**: Explain zone classifications, material detections, sampling recommendations, and methodology.
+2. **Document Modifications**: Add notes, update sections, or make changes to the generated Scope of Work document.
+
+## When Modifying Documents
+If the user requests a document change, include a modification command in your response using this format:
+
+<document_edit>
+{
+    "action": "add_note" | "add_section" | "append_to_section",
+    "section": "Section Name",
+    "content": "Content to add..."
+}
+</document_edit>
+
+Available sections:
+- Additional Notes (for general notes)
+- Room Information
+- Scope Summary
+- AI Vision Analysis Summary
+- Field Observations
+- Material Dispositions
+- Cleaning Specifications
+- Air Filtration Requirements
+- Sampling Plan
+- Regulatory References
+- Threshold Documentation
+- Disclaimer
+
+## Guidelines
+- Be concise and professional
+- Reference specific assessment data when answering questions
+- For modifications, only change what the user requests
+- Always explain changes you're making"""
+
+
+class ChatHandler:
+    """Handles chat interactions for assessment Q&A and document modifications."""
+
+    def __init__(self, model_stack=None):
+        """Initialize chat handler.
+
+        Args:
+            model_stack: Model stack (RealModelStack or MockModelStack).
+                        If None, will be loaded from get_models().
+        """
+        self.model_stack = model_stack
+
+    def process_message(
+        self,
+        user_message: str,
+        session_state,
+        chat_history: list[dict],
+    ) -> tuple[str, Optional[dict], list[dict]]:
+        """Process a chat message and return response.
+
+        Args:
+            user_message: The user's message
+            session_state: Current SessionState with assessment data
+            chat_history: Previous chat messages in Gradio messages format
+
+        Returns:
+            Tuple of (response_text, document_edit_or_none, updated_chat_history)
+        """
+        # Lazy load model stack if not provided
+        if self.model_stack is None:
+            from models.loader import get_models
+            self.model_stack = get_models()
+
+        # Build context from session
+        context = self._build_context(session_state)
+
+        # Generate response
+        if settings.mock_models:
+            response = self._generate_mock_response(user_message, context)
+        else:
+            response = self._generate_real_response(
+                user_message, context, chat_history
+            )
+
+        # Parse for document edits
+        document_edit = self._parse_document_edit(response)
+
+        # Clean response (remove document_edit tags for display)
+        display_response = re.sub(
+            r'<document_edit>.*?</document_edit>',
+            '',
+            response,
+            flags=re.DOTALL
+        ).strip()
+
+        # Update chat history
+        updated_history = chat_history.copy()
+        updated_history.append({"role": "user", "content": user_message})
+        updated_history.append({"role": "assistant", "content": display_response})
+
+        return display_response, document_edit, updated_history
+
+    def _build_context(self, session_state) -> str:
+        """Build context string from session state for chat."""
+        context_parts = []
+
+        # Room info
+        room = session_state.room
+        context_parts.append(f"Room: {room.name}")
+        context_parts.append(f"Dimensions: {room.length_ft}' x {room.width_ft}' x {room.ceiling_height_ft}'")
+        context_parts.append(f"Facility: {room.facility_classification}")
+        context_parts.append(f"Era: {room.construction_era}")
+
+        # Images summary
+        context_parts.append(f"Images analyzed: {len(session_state.images)}")
+
+        # Pipeline results if available
+        if session_state.pipeline_result_json:
+            try:
+                result = json.loads(session_state.pipeline_result_json)
+                if result.get("vision_results"):
+                    context_parts.append("\nVision Analysis Summary:")
+                    for img_id, analysis in result["vision_results"].items():
+                        zone = analysis.get("zone", {}).get("classification", "unknown")
+                        condition = analysis.get("condition", {}).get("level", "unknown")
+                        context_parts.append(f"  - {img_id}: zone={zone}, condition={condition}")
+
+                if result.get("dispositions"):
+                    context_parts.append(f"\nDispositions: {len(result['dispositions'])} materials analyzed")
+
+            except json.JSONDecodeError:
+                pass
+
+        return "\n".join(context_parts)
+
+    def _generate_real_response(
+        self,
+        user_message: str,
+        context: str,
+        chat_history: list[dict],
+    ) -> str:
+        """Generate response using real vision model in text-only mode."""
+        try:
+            # Get vision model components
+            vision = self.model_stack.vision
+            model = vision.model
+            processor = vision.processor
+            sampling_params = vision.sampling_params
+
+            # Build messages (text-only, no image)
+            messages = [
+                {"role": "system", "content": CHAT_SYSTEM_PROMPT},
+            ]
+
+            # Add context as first user message
+            messages.append({
+                "role": "user",
+                "content": f"Assessment Context:\n{context}"
+            })
+            messages.append({
+                "role": "assistant",
+                "content": "I understand the assessment context. How can I help you?"
+            })
+
+            # Add chat history
+            for msg in chat_history:
+                messages.append(msg)
+
+            # Add current user message
+            messages.append({"role": "user", "content": user_message})
+
+            # Apply chat template
+            prompt = processor.apply_chat_template(
+                messages,
+                tokenize=False,
+                add_generation_prompt=True,
+            )
+
+            # Generate (text-only: no multi_modal_data)
+            outputs = model.generate(
+                prompts=[prompt],  # Just prompt string, no image
+                sampling_params=sampling_params,
+            )
+
+            return outputs[0].outputs[0].text
+
+        except Exception as e:
+            logger.error(f"Chat generation failed: {e}")
+            return f"I apologize, but I encountered an error processing your request: {str(e)}"
+
+    def _generate_mock_response(self, user_message: str, context: str) -> str:
+        """Generate mock response for local development."""
+        user_lower = user_message.lower()
+
+        # Pattern matching for common questions
+        if "zone" in user_lower or "classification" in user_lower:
+            return """Zone classifications per FDAM §4.1 (IICRC/RIA/CIRI Technical Guide):
+
+- **Burn Zone**: Direct fire involvement with structural char and complete combustion
+- **Near-Field**: Adjacent to burn zone, heavy smoke/heat exposure, visible contamination
+- **Far-Field**: Smoke migration only, light deposits, no structural damage
+
+The AI analyzed each image to determine which zone best describes the visible conditions based on these criteria."""
+
+        if "material" in user_lower:
+            return """Materials are categorized by porosity, which affects cleaning requirements:
+
+- **Non-porous**: Steel, concrete, glass, CMU - can typically be cleaned
+- **Semi-porous**: Painted drywall, sealed wood - may require evaluation
+- **Porous**: Carpet, insulation, acoustic tile - often require removal
+
+The assessment identified materials visible in each image and assigned dispositions based on contamination level."""
+
+        if "sampling" in user_lower or "sample" in user_lower:
+            return """The sampling plan follows FDAM §2.3 requirements:
+
+- **Tape lifts**: For particle identification via PLM (polarized light microscopy)
+- **Surface wipes**: For metals quantification per NIOSH Method 9100 / BNL SOP IH75190
+
+**Sample Density per FDAM §2.3:**
+- <5,000 SF: 3-5 samples per surface type
+- 5,000-25,000 SF: 5-10 samples per surface type
+- 25,000-100,000 SF: 10-20 samples per surface type
+- >100,000 SF: 20+ samples per surface type
+
+**Ceiling Deck Enhancement (FDAM §4.5):** 1 sample per 2,500 SF due to 82.4% pass rate vs 95%+ for other surfaces."""
+
+        if "add" in user_lower and "note" in user_lower:
+            # Extract what they want to add
+            return """I'll add that note to the document.
+
+<document_edit>
+{
+    "action": "add_note",
+    "section": "Additional Notes",
+    "content": "Note added per assessor request during review."
+}
+</document_edit>
+
+The note has been added to the Additional Notes section."""
+
+        if "explain" in user_lower or "why" in user_lower:
+            return """Based on the visual analysis and FDAM methodology:
+
+The zone and condition classifications are determined by analyzing:
+1. Distance from fire origin indicators
+2. Visible contamination patterns
+3. Structural damage presence
+4. Material surface conditions
+
+Each factor contributes to the overall assessment with confidence scores reflecting certainty."""
+
+        # Default response
+        return """I can help you understand the assessment results or make changes to the document.
+
+**Questions I can answer:**
+- Zone classification explanations
+- Material detection details
+- Sampling plan rationale
+- Methodology references
+
+**Changes I can make:**
+- Add notes to any section
+- Update specific content
+- Add clarifications
+
+What would you like to know or change?"""
+
+    def _parse_document_edit(self, response: str) -> Optional[dict]:
+        """Parse document edit command from response."""
+        match = re.search(
+            r'<document_edit>\s*(\{.*?\})\s*</document_edit>',
+            response,
+            re.DOTALL
+        )
+        if match:
+            try:
+                return json.loads(match.group(1))
+            except json.JSONDecodeError:
+                logger.warning("Failed to parse document edit JSON")
+                return None
+        return None
+
+    def apply_document_edit(
+        self,
+        document: str,
+        edit: dict,
+    ) -> str:
+        """Apply a document edit to the current document.
+
+        Args:
+            document: Current markdown document
+            edit: Edit command with action, section, content
+
+        Returns:
+            Modified document
+        """
+        action = edit.get("action", "")
+        section = edit.get("section", "")
+        content = edit.get("content", "")
+
+        if not content:
+            return document
+
+        if action == "add_note":
+            # Add note to Additional Notes section, or create it
+            if "## Additional Notes" in document:
+                # Append to existing section
+                document = document.replace(
+                    "## Additional Notes",
+                    f"## Additional Notes\n\n{content}"
+                )
+            else:
+                # Add before Disclaimer
+                if "## Disclaimer" in document:
+                    document = document.replace(
+                        "## Disclaimer",
+                        f"## Additional Notes\n\n{content}\n\n---\n\n## Disclaimer"
+                    )
+                else:
+                    # Add at end
+                    document += f"\n\n---\n\n## Additional Notes\n\n{content}"
+
+        elif action == "add_section":
+            # Add new section before Disclaimer
+            new_section = f"## {section}\n\n{content}"
+            if "## Disclaimer" in document:
+                document = document.replace(
+                    "## Disclaimer",
+                    f"{new_section}\n\n---\n\n## Disclaimer"
+                )
+            else:
+                document += f"\n\n---\n\n{new_section}"
+
+        elif action == "append_to_section":
+            # Find section and append content
+            section_pattern = rf"(## {re.escape(section)}.*?)(\n---|\Z)"
+            match = re.search(section_pattern, document, re.DOTALL)
+            if match:
+                section_content = match.group(1)
+                document = document.replace(
+                    section_content,
+                    f"{section_content}\n\n{content}"
+                )
+
+        return document
+
+
+# Quick action messages
+QUICK_ACTIONS = {
+    "explain_zones": "Explain how the zone classifications were determined for this assessment.",
+    "explain_materials": "What materials were detected and why were they categorized this way?",
+    "explain_sampling": "Explain the sampling plan recommendations.",
+    "add_note": "I need to add a note to the document. Please tell me what note you'd like to add.",
+}
+
+
+def get_quick_action_message(action_key: str) -> str:
+    """Get the message for a quick action button."""
+    return QUICK_ACTIONS.get(action_key, "")

pipeline/dispositions.py

@@ -6,9 +6,11 @@ condition level, and RAG-retrieved methodology context.
 
 import logging
 from dataclasses import dataclass, field
-from typing import Literal, Optional
+from typing import Literal, Optional, TYPE_CHECKING
 
-from rag import FDAMRetriever, ChromaVectorStore
+# Type hints only - actual import deferred to retriever property
+if TYPE_CHECKING:
+    from rag import FDAMRetriever, ChromaVectorStore
 
 logger = logging.getLogger(__name__)
 
@@ -99,7 +101,7 @@ class SurfaceDisposition:
 class DispositionEngine:
     """Determines cleaning dispositions using FDAM methodology and RAG."""
 
-    def __init__(self, retriever: Optional[FDAMRetriever] = None):
+    def __init__(self, retriever: Optional["FDAMRetriever"] = None):
         """Initialize disposition engine.
 
         Args:
@@ -108,9 +110,11 @@ class DispositionEngine:
         self._retriever = retriever
 
     @property
-    def retriever(self) -> FDAMRetriever:
+    def retriever(self) -> "FDAMRetriever":
         """Get or create RAG retriever."""
         if self._retriever is None:
+            # Lazy import to avoid chromadb dependency at module load
+            from rag import FDAMRetriever, ChromaVectorStore
             try:
                 vs = ChromaVectorStore(persist_directory="chroma_db")
                 self._retriever = FDAMRetriever(vectorstore=vs)

pipeline/generator.py

@@ -7,12 +7,16 @@ with RAG-enhanced content from the FDAM knowledge base.
 import logging
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Optional
+from typing import Optional, TYPE_CHECKING
 
 from ui.state import SessionState
 
 logger = logging.getLogger(__name__)
-from rag import FDAMRetriever, ChromaVectorStore
+
+# Type hints only - actual import deferred to retriever property
+if TYPE_CHECKING:
+    from rag import FDAMRetriever, ChromaVectorStore
+
 from .calculations import FDAMCalculator, AirFiltrationResult, SampleDensityResult, RegulatoryFlags
 from .dispositions import DispositionEngine, SurfaceDisposition
 
@@ -35,7 +39,7 @@ class DocumentGenerator:
         self,
         calculator: Optional[FDAMCalculator] = None,
         disposition_engine: Optional[DispositionEngine] = None,
-        retriever: Optional[FDAMRetriever] = None,
+        retriever: Optional["FDAMRetriever"] = None,
     ):
         """Initialize document generator.
 
@@ -49,9 +53,11 @@ class DocumentGenerator:
         self._retriever = retriever
 
     @property
-    def retriever(self) -> FDAMRetriever:
+    def retriever(self) -> "FDAMRetriever":
         """Get or create RAG retriever."""
         if self._retriever is None:
+            # Lazy import to avoid chromadb dependency at module load
+            from rag import FDAMRetriever, ChromaVectorStore
             try:
                 vs = ChromaVectorStore(persist_directory="chroma_db")
                 self._retriever = FDAMRetriever(vectorstore=vs)

pipeline/main.py

@@ -13,7 +13,7 @@ import logging
 import time
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Callable, Optional
+from typing import Callable, Optional, TYPE_CHECKING
 from PIL import Image
 import io
 
@@ -22,7 +22,10 @@ from ui.components import image_store
 from models.loader import get_models
 
 logger = logging.getLogger(__name__)
-from rag import FDAMRetriever, ChromaVectorStore
+
+# Type hints only - actual import deferred to retriever property
+if TYPE_CHECKING:
+    from rag import FDAMRetriever, ChromaVectorStore
 
 from .calculations import FDAMCalculator
 from .dispositions import DispositionEngine, SurfaceDisposition
@@ -90,7 +93,7 @@ class FDAMPipeline:
         calculator: Optional[FDAMCalculator] = None,
         disposition_engine: Optional[DispositionEngine] = None,
         generator: Optional[DocumentGenerator] = None,
-        retriever: Optional[FDAMRetriever] = None,
+        retriever: Optional["FDAMRetriever"] = None,
     ):
         """Initialize pipeline with optional component overrides.
 
@@ -112,9 +115,11 @@ class FDAMPipeline:
         )
 
     @property
-    def retriever(self) -> FDAMRetriever:
+    def retriever(self) -> "FDAMRetriever":
         """Get or create RAG retriever."""
         if self._retriever is None:
+            # Lazy import to avoid chromadb dependency at module load
+            from rag import FDAMRetriever, ChromaVectorStore
             try:
                 vs = ChromaVectorStore(persist_directory="chroma_db")
                 self._retriever = FDAMRetriever(vectorstore=vs)

rag/__init__.py

@@ -2,11 +2,9 @@
 
 This module provides document chunking, vector storage, and retrieval
 for the FDAM knowledge base.
-"""
 
-from .chunker import SemanticChunker, Chunk
-from .vectorstore import ChromaVectorStore
-from .retriever import FDAMRetriever
+Lazy imports to avoid chromadb dependency at module load time for local development.
+"""
 
 __all__ = [
     "SemanticChunker",
@@ -14,3 +12,20 @@ __all__ = [
     "ChromaVectorStore",
     "FDAMRetriever",
 ]
+
+
+def __getattr__(name):
+    """Lazy import RAG modules only when accessed."""
+    if name == "SemanticChunker":
+        from .chunker import SemanticChunker
+        return SemanticChunker
+    elif name == "Chunk":
+        from .chunker import Chunk
+        return Chunk
+    elif name == "ChromaVectorStore":
+        from .vectorstore import ChromaVectorStore
+        return ChromaVectorStore
+    elif name == "FDAMRetriever":
+        from .retriever import FDAMRetriever
+        return FDAMRetriever
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

rag/retriever.py

@@ -8,11 +8,14 @@ Implements tiered retrieval:
 
 import logging
 import time
-from typing import Optional
+from typing import Optional, TYPE_CHECKING
 from dataclasses import dataclass
 
 from config.settings import settings
-from .vectorstore import ChromaVectorStore
+
+# Type hints only - actual import deferred to __init__
+if TYPE_CHECKING:
+    from .vectorstore import ChromaVectorStore
 
 logger = logging.getLogger(__name__)
 
@@ -141,7 +144,7 @@ class FDAMRetriever:
 
     def __init__(
         self,
-        vectorstore: Optional[ChromaVectorStore] = None,
+        vectorstore: Optional["ChromaVectorStore"] = None,
         reranker=None,
         use_reranking: bool = True,
     ):
@@ -153,7 +156,11 @@ class FDAMRetriever:
             reranker: Reranker instance. If None, uses appropriate default.
             use_reranking: Whether to apply reranking step.
         """
-        self.vectorstore = vectorstore or ChromaVectorStore()
+        if vectorstore is None:
+            # Lazy import to avoid chromadb dependency at module load
+            from .vectorstore import ChromaVectorStore
+            vectorstore = ChromaVectorStore()
+        self.vectorstore = vectorstore
         self.reranker = reranker if reranker is not None else get_reranker()
         self.use_reranking = use_reranking
 

ui/state.py

@@ -77,8 +77,7 @@ 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
+    MVP Simplification: Single room, 2 tabs (Input + Results/Chat).
     """
 
     # Session metadata
@@ -87,10 +86,8 @@ class SessionState(BaseModel):
     updated_at: str = Field(default_factory=lambda: datetime.now().isoformat())
     name: str = ""  # Display name for history list
 
-    # Tab completion status (3 input tabs)
-    tab1_complete: bool = False  # Room Assessment
-    tab2_complete: bool = False  # Images
-    tab3_complete: bool = False  # Observations
+    # Input completion status (single flag replaces 3 tab flags)
+    input_complete: bool = False
 
     # Form data - single room (not list)
     room: RoomFormData = Field(default_factory=RoomFormData)
@@ -101,6 +98,16 @@ class SessionState(BaseModel):
     has_results: bool = False
     results_generated_at: Optional[str] = None
 
+    # Chat history (Gradio 6 messages format)
+    chat_history: list[dict] = Field(default_factory=list)
+
+    # Serializable subset of PipelineResult (excludes PIL images)
+    pipeline_result_json: Optional[str] = None
+
+    # Document state for modifications
+    generated_document: Optional[str] = None
+    original_document: Optional[str] = None
+
     def update_timestamp(self) -> None:
         """Update the updated_at timestamp."""
         self.updated_at = datetime.now().isoformat()
@@ -247,6 +254,14 @@ def session_from_json(json_str: str) -> SessionState:
         if "tab4_complete" in data:
             del data["tab4_complete"]
 
+        # Migration: Convert old tab1/2/3_complete to input_complete
+        if "tab1_complete" in data or "tab2_complete" in data or "tab3_complete" in data:
+            # Input is complete if all three old tabs were complete
+            tab1 = data.pop("tab1_complete", False)
+            tab2 = data.pop("tab2_complete", False)
+            tab3 = data.pop("tab3_complete", False)
+            data["input_complete"] = tab1 and tab2 and tab3
+
         return SessionState.model_validate(data)
     except Exception:
         return create_new_session()

ui/tabs/__init__.py

@@ -1,13 +1,36 @@
-"""Tab modules for FDAM AI Pipeline UI."""
+"""Tab modules for FDAM AI Pipeline UI.
 
-from . import room
-from . import images
-from . import observations
-from . import results
+Simplified 2-tab structure:
+- input_tab: Combined room, images, and observations
+- results_tab: Results display with chat interface
+
+Legacy modules (room, images, observations, results) available but not pre-imported
+to avoid triggering heavy dependencies (chromadb, etc.) during local development.
+"""
+
+# Only import the new simplified tabs by default
+from . import input_tab
+from . import results_tab
 
 __all__ = [
-    "room",
-    "images",
-    "observations",
-    "results",
+    # New simplified tabs (always available)
+    "input_tab",
+    "results_tab",
 ]
+
+
+def __getattr__(name):
+    """Lazy import legacy modules only when accessed."""
+    if name == "room":
+        from . import room
+        return room
+    elif name == "images":
+        from . import images
+        return images
+    elif name == "observations":
+        from . import observations
+        return observations
+    elif name == "results":
+        from . import results
+        return results
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

ui/tabs/input_tab.py

@@ -0,0 +1,684 @@
+"""Tab 1: Input - Combined Room, Images, and Observations.
+
+Consolidated input tab using Accordions for collapsible sections.
+Room and Images are open by default, Observations is collapsed.
+"""
+
+import uuid
+import io
+import gradio as gr
+from typing import Any
+from PIL import Image
+
+from ui.state import SessionState, ImageFormData, ObservationsFormData
+from ui.constants import CEILING_HEIGHT_PRESETS
+from ui.components import image_store
+from config.settings import settings
+
+
+# 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"),
+]
+
+# Odor mapping
+ODOR_MAP = {
+    "None": "none",
+    "Faint": "faint",
+    "Moderate": "moderate",
+    "Strong": "strong",
+}
+ODOR_MAP_REVERSE = {v: k for k, v in ODOR_MAP.items()}
+
+# Char density mapping
+CHAR_DENSITY_MAP = {
+    "None": None,
+    "Sparse": "sparse",
+    "Moderate": "moderate",
+    "Dense": "dense",
+}
+CHAR_DENSITY_MAP_REVERSE = {v: k for k, v in CHAR_DENSITY_MAP.items()}
+
+
+def create_tab() -> dict[str, Any]:
+    """Create combined Input tab with accordions.
+
+    Returns:
+        Dictionary of component references for event wiring.
+    """
+    # --- Room Details Accordion (OPEN by default) ---
+    with gr.Accordion("Room Details", open=True):
+        room_name = gr.Textbox(
+            label="Room/Area Name *",
+            placeholder="e.g., Warehouse Bay A, Office 101",
+            elem_id="room_name",
+        )
+
+        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():
+            floor_area = gr.Textbox(
+                label="Floor Area (SF)",
+                value="0",
+                interactive=False,
+            )
+            room_volume = gr.Textbox(
+                label="Volume (CF)",
+                value="0",
+                interactive=False,
+            )
+
+        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",
+        )
+
+    # --- Images Accordion (OPEN by default) ---
+    with gr.Accordion("Images", open=True):
+        gr.Markdown(
+            f"*Upload up to {settings.max_images_per_assessment} images for AI analysis.*"
+        )
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                image_upload = gr.Files(
+                    label="Upload Images (select multiple)",
+                    file_count="multiple",
+                    file_types=["image"],
+                    elem_id="image_upload",
+                )
+                image_description = gr.Textbox(
+                    label="Description (optional)",
+                    placeholder="e.g., View of ceiling deck from center aisle",
+                    elem_id="image_description",
+                    info="Applied to all images in batch",
+                )
+
+                with gr.Row():
+                    add_image_btn = gr.Button("Add Images", variant="primary")
+                    clear_upload_btn = gr.Button("Clear", variant="secondary")
+
+            with gr.Column(scale=3):
+                images_gallery = gr.Gallery(
+                    label="Images Added",
+                    columns=3,
+                    height="auto",
+                    elem_id="images_gallery",
+                )
+                with gr.Row():
+                    remove_last_btn = gr.Button("Remove Last", variant="secondary")
+                    clear_all_btn = gr.Button("Clear All", variant="stop")
+
+        with gr.Row():
+            image_count = gr.Textbox(
+                label="Images Added",
+                value="0 / 20",
+                interactive=False,
+            )
+
+        # Resume warning (shown when images need re-upload)
+        resume_warning = gr.HTML(
+            value="",
+            elem_id="resume_warning",
+            visible=False,
+        )
+
+    # --- Observations Accordion (COLLAPSED by default) ---
+    with gr.Accordion("Field Observations (Optional)", open=False):
+        gr.Markdown("*Document observations per FDAM §2.3. All fields optional.*")
+
+        with gr.Row():
+            with gr.Column():
+                smoke_odor = gr.Checkbox(
+                    label="Smoke/fire odor present?",
+                    elem_id="smoke_odor",
+                )
+                odor_intensity = gr.Radio(
+                    choices=["None", "Faint", "Moderate", "Strong"],
+                    label="Odor Intensity",
+                    value="None",
+                    elem_id="odor_intensity",
+                )
+
+                visible_soot = gr.Checkbox(
+                    label="Visible soot deposits?",
+                    elem_id="visible_soot",
+                )
+                soot_description = gr.Textbox(
+                    label="Soot Pattern Description",
+                    placeholder="e.g., Heavy deposits on ceiling",
+                    elem_id="soot_description",
+                )
+
+                large_char = gr.Checkbox(
+                    label="Large char particles observed?",
+                    elem_id="large_char",
+                )
+                char_density = gr.Radio(
+                    choices=["None", "Sparse", "Moderate", "Dense"],
+                    label="Char Density",
+                    value="None",
+                    elem_id="char_density",
+                )
+
+                ash_residue = gr.Checkbox(
+                    label="Ash-like residue present?",
+                    elem_id="ash_residue",
+                )
+                ash_description = gr.Textbox(
+                    label="Ash Color/Texture",
+                    placeholder="e.g., Gray powdery residue",
+                    elem_id="ash_description",
+                )
+
+            with gr.Column():
+                surface_discoloration = gr.Checkbox(
+                    label="Surface discoloration?",
+                    elem_id="surface_discoloration",
+                )
+                discoloration_description = gr.Textbox(
+                    label="Discoloration Description",
+                    placeholder="e.g., Yellowing on painted surfaces",
+                    elem_id="discoloration_description",
+                )
+
+                dust_interference = gr.Checkbox(
+                    label="Dust loading or interference?",
+                    info="Pre-existing dust may affect samples",
+                    elem_id="dust_interference",
+                )
+                dust_notes = gr.Textbox(
+                    label="Dust Notes",
+                    placeholder="e.g., Heavy ambient dust",
+                    elem_id="dust_notes",
+                )
+
+                wildfire_indicators = gr.Checkbox(
+                    label="Wildfire indicators (vegetation/pollen)?",
+                    info="May indicate wildfire vs structural fire",
+                    elem_id="wildfire_indicators",
+                )
+                wildfire_notes = gr.Textbox(
+                    label="Wildfire Notes",
+                    placeholder="e.g., Burned pine pollen visible",
+                    elem_id="wildfire_notes",
+                )
+
+                additional_notes = gr.Textbox(
+                    label="Additional Observations",
+                    lines=3,
+                    placeholder="Any other relevant observations...",
+                    elem_id="additional_notes",
+                )
+
+    # --- Generate Button and Validation ---
+    validation_status = gr.HTML(
+        value="",
+        elem_id="input_validation",
+    )
+
+    generate_btn = gr.Button(
+        "Generate Assessment →",
+        variant="primary",
+        size="lg",
+    )
+
+    return {
+        # Room components
+        "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,
+        # Image components
+        "image_upload": image_upload,
+        "image_description": image_description,
+        "add_image_btn": add_image_btn,
+        "clear_upload_btn": clear_upload_btn,
+        "images_gallery": images_gallery,
+        "remove_last_btn": remove_last_btn,
+        "clear_all_btn": clear_all_btn,
+        "image_count": image_count,
+        "resume_warning": resume_warning,
+        # Observation components
+        "smoke_odor": smoke_odor,
+        "odor_intensity": odor_intensity,
+        "visible_soot": visible_soot,
+        "soot_description": soot_description,
+        "large_char": large_char,
+        "char_density": char_density,
+        "ash_residue": ash_residue,
+        "ash_description": ash_description,
+        "surface_discoloration": surface_discoloration,
+        "discoloration_description": discoloration_description,
+        "dust_interference": dust_interference,
+        "dust_notes": dust_notes,
+        "wildfire_indicators": wildfire_indicators,
+        "wildfire_notes": wildfire_notes,
+        "additional_notes": additional_notes,
+        # Validation and generation
+        "validation_status": validation_status,
+        "generate_btn": generate_btn,
+    }
+
+
+# --- Room Functions ---
+
+
+def on_height_preset_change(preset_value: int | None) -> dict:
+    """Show/hide custom height input based on preset selection."""
+    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."""
+    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
+
+    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."""
+    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
+
+    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 load_room_from_session(
+    session: SessionState,
+) -> tuple[str, float | None, float | None, int | None, float | None, str, str, str, str]:
+    """Load room data from session."""
+    r = session.room
+
+    height_preset = None
+    height_custom = None
+    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
+
+    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,
+    )
+
+
+# --- Image Functions ---
+
+
+def add_image(
+    session: SessionState,
+    files: list | None,
+    description: str,
+) -> tuple[SessionState, list[tuple], str, str, None, str]:
+    """Add images to the session."""
+    validation_html = ""
+
+    errors = []
+    if not files or len(files) == 0:
+        errors.append("Please upload at least one image")
+
+    current_count = len(session.images)
+    max_allowed = settings.max_images_per_assessment
+    if files and current_count + len(files) > max_allowed:
+        remaining = max_allowed - current_count
+        if remaining <= 0:
+            errors.append(f"Maximum of {max_allowed} images allowed")
+        else:
+            errors.append(f"Can only add {remaining} more image(s)")
+
+    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>
+        """
+        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 = session.room.id
+    room_name = session.room.name.replace(" ", "_")[:20] if session.room.name else "room"
+
+    added_count = 0
+    for file_obj in files:
+        if len(session.images) >= max_allowed:
+            break
+
+        try:
+            img = Image.open(file_obj.name)
+            image_id = f"img-{uuid.uuid4().hex[:8]}"
+
+            img_bytes = io.BytesIO()
+            img.save(img_bytes, format="PNG")
+            image_store.store(image_id, img_bytes.getvalue())
+
+            img_meta = ImageFormData(
+                id=image_id,
+                filename=f"{room_name}_{image_id}.png",
+                room_id=room_id,
+                description=description.strip() if description else "",
+            )
+            session.images.append(img_meta)
+            added_count += 1
+        except Exception:
+            continue
+
+    session.update_timestamp()
+
+    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</span>
+        </div>
+        """
+    else:
+        validation_html = """
+        <div style="background: #fff3e0; border: 1px solid #ffb74d; border-radius: 4px; padding: 10px;">
+            <span style="color: #e65100;">No images could be processed</span>
+        </div>
+        """
+
+    gallery_data = _get_gallery_data(session)
+    count_str = f"{len(session.images)} / {max_allowed}"
+    return session, gallery_data, validation_html, count_str, None, ""
+
+
+def remove_last_image(
+    session: SessionState,
+) -> tuple[SessionState, list[tuple], str, str]:
+    """Remove the last image from the session."""
+    validation_html = ""
+
+    if session.images:
+        removed = session.images.pop()
+        image_store.remove(removed.id)
+        session.update_timestamp()
+        validation_html = f"""
+        <div style="background: #fff3e0; border: 1px solid #ffb74d; border-radius: 4px; padding: 10px;">
+            <span style="color: #e65100;">Removed: {removed.filename}</span>
+        </div>
+        """
+
+    gallery_data = _get_gallery_data(session)
+    count_str = f"{len(session.images)} / {settings.max_images_per_assessment}"
+    return session, gallery_data, validation_html, count_str
+
+
+def clear_all_images(session: SessionState) -> tuple[SessionState, list[tuple], str, str]:
+    """Clear all images from the session."""
+    count = len(session.images)
+
+    for img in session.images:
+        image_store.remove(img.id)
+
+    session.images = []
+    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} image(s)</span>
+        </div>
+        """
+
+    count_str = f"0 / {settings.max_images_per_assessment}"
+    return session, [], validation_html, count_str
+
+
+def load_images_from_session(session: SessionState) -> tuple[list[tuple], str, str]:
+    """Load gallery data and count from session."""
+    gallery_data = _get_gallery_data(session)
+    count_str = f"{len(session.images)} / {settings.max_images_per_assessment}"
+
+    expected_ids = [img.id for img in session.images]
+    missing_ids = image_store.get_missing_ids(expected_ids)
+
+    resume_html = ""
+    if missing_ids and session.images:
+        resume_html = f"""
+        <div style="background: #fff3e0; border: 1px solid #ffb74d; border-radius: 4px; padding: 10px;">
+            <strong style="color: #e65100;">⚠ {len(missing_ids)} image(s) need re-upload</strong>
+        </div>
+        """
+
+    return gallery_data, count_str, resume_html
+
+
+def _get_gallery_data(session: SessionState) -> list[tuple]:
+    """Get gallery data from session images."""
+    gallery_data = []
+    for img_meta in session.images:
+        img_bytes = image_store.get(img_meta.id)
+        if img_bytes:
+            pil_image = Image.open(io.BytesIO(img_bytes))
+            caption = img_meta.description or img_meta.filename
+            gallery_data.append((pil_image, caption))
+    return gallery_data
+
+
+# --- Observations Functions ---
+
+
+def save_observations_to_session(
+    session: SessionState,
+    smoke_odor: bool,
+    odor_intensity: str,
+    visible_soot: bool,
+    soot_description: str,
+    large_char: bool,
+    char_density: str,
+    ash_residue: bool,
+    ash_description: str,
+    surface_discoloration: bool,
+    discoloration_description: str,
+    dust_interference: bool,
+    dust_notes: str,
+    wildfire_indicators: bool,
+    wildfire_notes: str,
+    additional_notes: str,
+) -> SessionState:
+    """Update session state from observation form values."""
+    session.observations = ObservationsFormData(
+        smoke_fire_odor=smoke_odor or False,
+        odor_intensity=ODOR_MAP.get(odor_intensity, "none"),
+        visible_soot_deposits=visible_soot or False,
+        soot_pattern_description=soot_description or "",
+        large_char_particles=large_char or False,
+        char_density_estimate=CHAR_DENSITY_MAP.get(char_density),
+        ash_like_residue=ash_residue or False,
+        ash_color_texture=ash_description or "",
+        surface_discoloration=surface_discoloration or False,
+        discoloration_description=discoloration_description or "",
+        dust_loading_interference=dust_interference or False,
+        dust_notes=dust_notes or "",
+        wildfire_indicators=wildfire_indicators or False,
+        wildfire_notes=wildfire_notes or "",
+        additional_notes=additional_notes or "",
+    )
+    session.update_timestamp()
+    return session
+
+
+def load_observations_from_session(session: SessionState) -> tuple:
+    """Load observation form values from session state."""
+    obs = session.observations
+    return (
+        obs.smoke_fire_odor,
+        ODOR_MAP_REVERSE.get(obs.odor_intensity, "None"),
+        obs.visible_soot_deposits,
+        obs.soot_pattern_description,
+        obs.large_char_particles,
+        CHAR_DENSITY_MAP_REVERSE.get(obs.char_density_estimate, "None"),
+        obs.ash_like_residue,
+        obs.ash_color_texture,
+        obs.surface_discoloration,
+        obs.discoloration_description,
+        obs.dust_loading_interference,
+        obs.dust_notes,
+        obs.wildfire_indicators,
+        obs.wildfire_notes,
+        obs.additional_notes,
+    )
+
+
+# --- Validation and Generation ---
+
+
+def validate_input(session: SessionState) -> tuple[bool, list[str]]:
+    """Validate all input sections."""
+    errors = []
+
+    # Room validation
+    r = session.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")
+
+    # Image validation
+    if not session.images:
+        errors.append("At least one image is required")
+
+    # Check for missing images in memory
+    expected_ids = [img.id for img in session.images]
+    missing_ids = image_store.get_missing_ids(expected_ids)
+    if missing_ids:
+        errors.append(f"{len(missing_ids)} image(s) need to be re-uploaded")
+
+    return len(errors) == 0, errors
+
+
+def validate_and_generate(session: SessionState) -> tuple[SessionState, str, dict]:
+    """Validate input and switch to Results tab if valid.
+
+    Returns:
+        Tuple of (session, validation_html, tabs_update).
+    """
+    is_valid, errors = validate_input(session)
+
+    if is_valid:
+        session.input_complete = True
+        session.update_timestamp()
+        html = """
+        <div style="background: #e8f5e9; border: 1px solid #66bb6a; border-radius: 4px; padding: 10px;">
+            <span style="color: #2e7d32;">✓ All inputs valid. Switching to Results...</span>
+        </div>
+        """
+        return session, html, gr.update(selected=1)  # Go to Results tab (index 1)
+    else:
+        session.input_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 Input tab

ui/tabs/results_tab.py

@@ -0,0 +1,391 @@
+"""Tab 2: Results + Chat.
+
+Display generated assessment results with integrated chat for Q&A and modifications.
+"""
+
+import json
+import gradio as gr
+from typing import Any, Optional, TYPE_CHECKING
+from datetime import datetime
+import tempfile
+
+from ui.state import SessionState
+from ui.components import create_stats_dict, create_progress_html, image_store
+
+# Lazy imports to avoid chromadb dependency at module load time
+# These are imported when generate_assessment() is called
+if TYPE_CHECKING:
+    from pipeline import FDAMPipeline, PipelineResult, PDFGenerator
+
+
+def create_tab() -> dict[str, Any]:
+    """Create Results + Chat tab UI components.
+
+    Returns:
+        Dictionary of component references for event wiring.
+    """
+    # --- Processing Section ---
+    with gr.Row():
+        generate_btn = gr.Button(
+            "Generate Assessment",
+            variant="primary",
+            scale=2,
+            elem_id="generate_btn",
+        )
+        processing_status = gr.Textbox(
+            label="Status",
+            value="Ready",
+            interactive=False,
+            elem_id="processing_status",
+        )
+
+    progress_html = gr.HTML(
+        value="",
+        elem_id="progress_html",
+    )
+
+    # --- Results Display ---
+    gr.Markdown("---")
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            gr.Markdown("#### Annotated Images")
+            annotated_gallery = gr.Gallery(
+                label="AI-Analyzed Images",
+                columns=2,
+                height="auto",
+                elem_id="annotated_gallery",
+            )
+
+        with gr.Column(scale=1):
+            gr.Markdown("#### Assessment Summary")
+            stats_output = gr.JSON(
+                label="Statistics",
+                elem_id="stats_output",
+            )
+
+    gr.Markdown("---")
+    gr.Markdown("### Cleaning Specification / Scope of Work")
+
+    sow_output = gr.Markdown(
+        value="*Generate an assessment to see results here.*",
+        elem_id="sow_output",
+    )
+
+    # --- Downloads ---
+    gr.Markdown("#### Downloads")
+    with gr.Row():
+        download_md = gr.File(
+            label="Download Markdown (.md)",
+            elem_id="download_md",
+        )
+        download_pdf = gr.File(
+            label="Download PDF (.pdf)",
+            elem_id="download_pdf",
+        )
+
+    # --- Chat Interface ---
+    gr.Markdown("---")
+    gr.Markdown("### Ask Questions or Request Changes")
+    gr.Markdown(
+        "*Chat with the AI about the assessment results or request document modifications.*"
+    )
+
+    chatbot = gr.Chatbot(
+        label="Chat",
+        type="messages",  # Gradio 6 format: [{"role": "user", "content": "..."}, ...]
+        height=300,
+        elem_id="chatbot",
+    )
+
+    with gr.Row():
+        chat_input = gr.Textbox(
+            label="Message",
+            placeholder="Ask a question or request a change...",
+            scale=4,
+            elem_id="chat_input",
+        )
+        chat_send_btn = gr.Button("Send", variant="primary", scale=1)
+
+    # Quick action buttons
+    with gr.Row():
+        gr.Markdown("**Quick Actions:**")
+    with gr.Row():
+        quick_explain_zones = gr.Button("Explain zone classifications", size="sm")
+        quick_explain_materials = gr.Button("Explain detected materials", size="sm")
+        quick_sampling = gr.Button("Explain sampling plan", size="sm")
+        quick_add_note = gr.Button("Add a note to document", size="sm")
+
+    # Navigation
+    with gr.Row():
+        back_btn = gr.Button("← Back to Input")
+        regenerate_btn = gr.Button(
+            "Regenerate Assessment",
+            variant="secondary",
+        )
+        reset_doc_btn = gr.Button(
+            "Reset Document",
+            variant="secondary",
+        )
+
+    return {
+        # Generation controls
+        "generate_btn": generate_btn,
+        "processing_status": processing_status,
+        "progress_html": progress_html,
+        # Results display
+        "annotated_gallery": annotated_gallery,
+        "stats_output": stats_output,
+        "sow_output": sow_output,
+        # Downloads
+        "download_md": download_md,
+        "download_pdf": download_pdf,
+        # Chat interface
+        "chatbot": chatbot,
+        "chat_input": chat_input,
+        "chat_send_btn": chat_send_btn,
+        # Quick actions
+        "quick_explain_zones": quick_explain_zones,
+        "quick_explain_materials": quick_explain_materials,
+        "quick_sampling": quick_sampling,
+        "quick_add_note": quick_add_note,
+        # Navigation
+        "back_btn": back_btn,
+        "regenerate_btn": regenerate_btn,
+        "reset_doc_btn": reset_doc_btn,
+    }
+
+
+def check_preflight(session: SessionState) -> str:
+    """Check if assessment can be generated.
+
+    Returns:
+        HTML string with preflight status.
+    """
+    can_generate, errors = session.can_generate()
+
+    # Also check if images are in memory
+    expected_ids = [img.id for img in session.images]
+    missing_ids = image_store.get_missing_ids(expected_ids)
+    if missing_ids:
+        errors.append(f"{len(missing_ids)} image(s) need to be re-uploaded")
+        can_generate = False
+
+    if can_generate:
+        stats = create_stats_dict(session)
+        return f"""
+        <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>Room:</strong> {stats['room_name']}<br>
+                <strong>Images:</strong> {stats['images']}<br>
+                <strong>Total Area:</strong> {stats['total_floor_area_sf']} SF
+            </div>
+        </div>
+        """
+    else:
+        error_items = "".join(f"<li>{e}</li>" for e in errors)
+        return f"""
+        <div style="background: #ffebee; border: 1px solid #ef5350; border-radius: 4px; padding: 15px;">
+            <strong style="color: #c62828;">Cannot Generate - Please Fix:</strong>
+            <ul style="margin: 10px 0 0 0; padding-left: 20px; color: #c62828;">{error_items}</ul>
+        </div>
+        """
+
+
+def generate_assessment(
+    session: SessionState,
+    progress: Optional[gr.Progress] = None,
+) -> tuple[SessionState, str, str, list[tuple], dict, str, Optional[str], Optional[str], list[dict]]:
+    """Generate the assessment using the FDAM pipeline.
+
+    Returns:
+        Tuple of (session, status, progress_html, annotated_images,
+                  stats, sow_markdown, md_file_path, pdf_file_path, chat_history).
+    """
+    # Lazy import to avoid chromadb dependency at module load
+    from pipeline import FDAMPipeline, PipelineResult, PDFGenerator
+
+    # Create pipeline instance
+    pipeline = FDAMPipeline()
+
+    # Define progress callback for Gradio
+    def progress_callback(prog):
+        if progress:
+            progress(prog.percent, desc=prog.message)
+
+    # Execute pipeline
+    result: PipelineResult = pipeline.execute(
+        session=session,
+        progress_callback=progress_callback,
+    )
+
+    # Handle errors
+    if not result.success:
+        error_msg = "**Error:** Please fix the following before generating:\n\n"
+        error_msg += "\n".join(f"- {e}" for e in result.errors)
+        return (
+            result.session,
+            "Error: Cannot generate",
+            "",
+            [],
+            {},
+            error_msg,
+            None,
+            None,
+            [],  # Clear chat on error
+        )
+
+    # Generate stats dictionary for UI
+    stats = pipeline.generate_stats_dict(result)
+
+    # Get markdown content
+    sow_markdown = result.document.markdown if result.document else ""
+
+    # Store document in session for chat modifications
+    session.generated_document = sow_markdown
+    session.original_document = sow_markdown
+
+    # Store serializable subset of PipelineResult for chat context
+    session.pipeline_result_json = _serialize_pipeline_result(result)
+
+    # Clear chat history on new generation
+    session.chat_history = []
+
+    # Save markdown file
+    md_path = None
+    pdf_path = None
+
+    try:
+        if sow_markdown:
+            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_{room_name_safe}_",
+            ) as f:
+                f.write(sow_markdown)
+                md_path = f.name
+
+            # Generate PDF
+            pdf_generator = PDFGenerator()
+            pdf_result = pdf_generator.generate_pdf(sow_markdown)
+            if pdf_result.success:
+                pdf_path = pdf_result.pdf_path
+            else:
+                result.warnings.append(f"PDF generation failed: {pdf_result.error_message}")
+
+    except Exception as e:
+        print(f"Error saving files: {e}")
+
+    # Add warnings to status if any
+    status = "Complete"
+    if result.warnings:
+        status = f"Complete ({len(result.warnings)} warnings)"
+
+    session.has_results = True
+    session.results_generated_at = datetime.now().isoformat()
+    session.update_timestamp()
+
+    return (
+        session,
+        status,
+        create_progress_html(6, 6, f"Complete! ({result.execution_time_seconds:.1f}s)"),
+        result.annotated_images,
+        stats,
+        sow_markdown,
+        md_path,
+        pdf_path,
+        [],  # Reset chat history
+    )
+
+
+def _serialize_pipeline_result(result: "PipelineResult") -> str:
+    """Serialize PipelineResult to JSON, excluding non-serializable fields.
+
+    Excludes:
+    - annotated_images (contains PIL.Image objects)
+    - session (complex SessionState object)
+    - document (GeneratedDocument object)
+    """
+    # Convert VisionResult dataclasses to dicts
+    vision_results_dict = {}
+    for img_id, vr in result.vision_results.items():
+        vision_results_dict[img_id] = {
+            "zone": vr.zone,
+            "condition": vr.condition,
+            "materials": vr.materials,
+            "bounding_boxes": vr.bounding_boxes,
+        }
+
+    # Convert SurfaceDisposition dataclasses to dicts
+    dispositions_list = []
+    for disp in result.dispositions:
+        dispositions_list.append({
+            "room_name": disp.room_name,
+            "surface_type": disp.surface_type,
+            "zone": disp.zone,
+            "condition": disp.condition,
+            "disposition": disp.disposition,
+            "cleaning_method": disp.cleaning_method,
+            "notes": disp.notes,
+        })
+
+    serializable = {
+        "success": result.success,
+        "errors": result.errors,
+        "warnings": result.warnings,
+        "execution_time_seconds": result.execution_time_seconds,
+        "vision_results": vision_results_dict,
+        "dispositions": dispositions_list,
+        "calculations": result.calculations,
+    }
+    return json.dumps(serializable, default=str)
+
+
+def reset_document(session: SessionState) -> tuple[SessionState, str]:
+    """Reset document to original generated version."""
+    if session.original_document:
+        session.generated_document = session.original_document
+        session.update_timestamp()
+        return session, session.original_document
+    return session, session.generated_document or ""
+
+
+def regenerate_downloads(
+    session: SessionState,
+) -> tuple[Optional[str], Optional[str]]:
+    """Regenerate download files from current document.
+
+    Used after chat modifications to update downloads.
+    """
+    sow_markdown = session.generated_document
+    if not sow_markdown:
+        return None, None
+
+    md_path = None
+    pdf_path = None
+
+    try:
+        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_{room_name_safe}_",
+        ) as f:
+            f.write(sow_markdown)
+            md_path = f.name
+
+        # Lazy import PDFGenerator
+        from pipeline import PDFGenerator
+        pdf_generator = PDFGenerator()
+        pdf_result = pdf_generator.generate_pdf(sow_markdown)
+        if pdf_result.success:
+            pdf_path = pdf_result.pdf_path
+
+    except Exception as e:
+        print(f"Error regenerating files: {e}")
+
+    return md_path, pdf_path