From 79894ff7a662313227a546dc516f53430f460ecf Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 3 Dec 2025 23:24:04 +0000
Subject: [PATCH 1/6] Initial plan


From b65294ff6283806799b287fa0a0df16638a8b818 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 3 Dec 2025 23:32:47 +0000
Subject: [PATCH 2/6] Skip blank rows and section headers in Excel processing

Co-authored-by: mcasalaina <1323111+mcasalaina@users.noreply.github.com>
---
 src/excel/loader.py                 |  93 ++++++++++++--
 src/utils/data_types.py             |   4 +
 tests/unit/test_excel_blank_rows.py | 187 ++++++++++++++++++++++++++++
 3 files changed, 275 insertions(+), 9 deletions(-)
 create mode 100644 tests/unit/test_excel_blank_rows.py

diff --git a/src/excel/loader.py b/src/excel/loader.py
index 93c1ff2..719ecb0 100644
--- a/src/excel/loader.py
+++ b/src/excel/loader.py
@@ -84,13 +84,26 @@ def load_workbook(self, file_path: str) -> WorkbookData:
                 continue
             
             # Extract questions from identified question column (0-based to 1-based for openpyxl)
+            # Skip blank rows and section headers, tracking original row indices
             questions = []
+            row_indices = []  # Track original Excel row numbers (1-based)
+            
             for row in ws.iter_rows(min_row=2, min_col=question_col+1, max_col=question_col+1):
                 cell = row[0]
-                if cell.value and str(cell.value).strip():
-                    questions.append(str(cell.value).strip())
-                else:
-                    break  # Stop at first empty cell
+                cell_value = str(cell.value).strip() if cell.value else ''
+                
+                # Skip blank cells
+                if not cell_value:
+                    logger.debug(f"Skipping blank row {cell.row} in sheet '{sheet_name}'")
+                    continue
+                
+                # Skip section headers (heuristic detection)
+                if self._is_section_header(cell_value):
+                    logger.info(f"Skipping section header at row {cell.row} in sheet '{sheet_name}': '{cell_value}'")
+                    continue
+                
+                questions.append(cell_value)
+                row_indices.append(cell.row)  # Store the actual Excel row number (1-based)
             
             if not questions:
                 logger.warning(f"Sheet '{sheet_name}' has no questions, skipping")
@@ -100,8 +113,9 @@ def load_workbook(self, file_path: str) -> WorkbookData:
             if len(questions) > 100:
                 logger.warning(f"Sheet '{sheet_name}' has {len(questions)} questions, limiting to 100")
                 questions = questions[:100]
+                row_indices = row_indices[:100]
             
-            # Create SheetData with column mapping
+            # Create SheetData with column mapping and row indices
             sheet_data = SheetData(
                 sheet_name=sheet_name,
                 sheet_index=len(sheets),  # Reindex after filtering
@@ -110,7 +124,8 @@ def load_workbook(self, file_path: str) -> WorkbookData:
                 cell_states=[CellState.PENDING] * len(questions),
                 question_col_index=question_col,
                 response_col_index=response_col,
-                documentation_col_index=doc_col
+                documentation_col_index=doc_col,
+                row_indices=row_indices
             )
             sheets.append(sheet_data)
         
@@ -127,6 +142,61 @@ def load_workbook(self, file_path: str) -> WorkbookData:
         
         return WorkbookData(file_path=file_path, sheets=sheets)
     
+    def _is_section_header(self, text: str) -> bool:
+        """Determine if text appears to be a section header rather than a question.
+        
+        Uses heuristic rules to detect common section header patterns.
+        
+        Args:
+            text: The cell text to analyze
+            
+        Returns:
+            True if the text appears to be a section header, False otherwise
+        """
+        import re
+        
+        text = text.strip()
+        
+        # Empty or very short text
+        if len(text) < 3:
+            return True
+        
+        # Pattern 1: Starts with common section prefixes like "Section", "Part", "Chapter"
+        section_prefixes = (
+            'section ', 'part ', 'chapter ', 'category ', 'topic ', 
+            'section:', 'part:', 'chapter:', 'category:', 'topic:',
+            '---', '===', '***', '###'
+        )
+        if text.lower().startswith(section_prefixes):
+            return True
+        
+        # Pattern 2: Entirely wrapped in decorators (dashes, equals, asterisks)
+        if re.match(r'^[-=*#]+\s*.*\s*[-=*#]+$', text):
+            return True
+        
+        # Pattern 3: Numbered sections like "1.", "1.1", "I.", "A." followed by short title
+        if re.match(r'^(?:\d+\.|\d+\.\d+|[IVXLCDM]+\.|[A-Z]\.)\s+[^?]*$', text):
+            # Only consider it a header if it doesn't end with '?'
+            if not text.rstrip().endswith('?'):
+                # And if it's relatively short (less than 60 chars without punctuation at end)
+                if len(text) < 60 and not text.rstrip().endswith(('.', '!', '?')):
+                    return True
+        
+        # Pattern 4: All uppercase text (likely a header)
+        if text.isupper() and len(text.split()) <= 6:
+            return True
+        
+        # Pattern 5: Text that contains only title-like content (no question marks, short)
+        # and looks like a category label
+        words = text.split()
+        if (len(words) <= 5 and 
+            not text.endswith('?') and 
+            text.istitle() and 
+            ':' in text):
+            return True
+        
+        return False
+    
     def save_workbook(self, workbook_data: WorkbookData, output_path: str = None) -> str:
         """Save all answers back to the Excel file.
         
@@ -166,10 +236,15 @@ def save_workbook(self, workbook_data: WorkbookData, output_path: str = None) ->
             if ws.cell(row=1, column=response_col + 1).value is None:
                 ws.cell(row=1, column=response_col + 1, value="Response")
             
-            # Write answers starting from row 2
-            for row_idx, answer in enumerate(sheet_data.answers, start=2):
+            # Write answers to the correct rows using stored row indices
+            for i, answer in enumerate(sheet_data.answers):
                 if answer:
-                    ws.cell(row=row_idx, column=response_col + 1, value=answer)
+                    # Use the original row index if available, otherwise fall back to sequential
+                    if sheet_data.row_indices and i < len(sheet_data.row_indices):
+                        row_num = sheet_data.row_indices[i]
+                    else:
+                        row_num = i + 2  # Fallback to sequential starting from row 2
+                    ws.cell(row=row_num, column=response_col + 1, value=answer)
         
         try:
             wb.save(save_path)
diff --git a/src/utils/data_types.py b/src/utils/data_types.py
index 22d30ec..489c6ad 100644
--- a/src/utils/data_types.py
+++ b/src/utils/data_types.py
@@ -330,12 +330,16 @@ class SheetData:
     question_col_index: Optional[int] = None
     response_col_index: Optional[int] = None
     documentation_col_index: Optional[int] = None
+    row_indices: Optional[List[int]] = None  # Original Excel row numbers (1-based) for each question
     
     def __post_init__(self):
         """Validate invariants."""
         if len(self.questions) != len(self.answers) or len(self.questions) != len(self.cell_states):
             raise ValueError("Questions, answers, and cell_states must have the same length")
         
+        if self.row_indices is not None and len(self.row_indices) != len(self.questions):
+            raise ValueError("Row indices must have the same length as questions")
+        
         if len(self.sheet_name) > 31:
             raise ValueError("Sheet name cannot exceed 31 characters (Excel limit)")
     
diff --git a/tests/unit/test_excel_blank_rows.py b/tests/unit/test_excel_blank_rows.py
new file mode 100644
index 0000000..8049a1a
--- /dev/null
+++ b/tests/unit/test_excel_blank_rows.py
@@ -0,0 +1,187 @@
+"""Unit tests for Excel blank row and section header handling."""
+
+import pytest
+import sys
+import os
+
+# Add src to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
+
+from excel.loader import ExcelLoader
+
+
+class TestSectionHeaderDetection:
+    """Test heuristic detection of section headers."""
+    
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.loader = ExcelLoader()
+    
+    def test_detect_section_prefix(self):
+        """Test detection of common section prefixes."""
+        assert self.loader._is_section_header("Section 1: Introduction") is True
+        assert self.loader._is_section_header("Part A: Basic Questions") is True
+        assert self.loader._is_section_header("Chapter 3: Advanced Topics") is True
+        assert self.loader._is_section_header("Category: General") is True
+        assert self.loader._is_section_header("Topic 5: Cloud Services") is True
+    
+    def test_detect_decorated_headers(self):
+        """Test detection of headers wrapped in decorators."""
+        assert self.loader._is_section_header("--- Advanced Topics ---") is True
+        assert self.loader._is_section_header("=== Section 2 ===") is True
+        assert self.loader._is_section_header("*** Important ***") is True
+        assert self.loader._is_section_header("### Headers ###") is True
+    
+    def test_detect_uppercase_headers(self):
+        """Test detection of all-uppercase short headers."""
+        assert self.loader._is_section_header("ADVANCED TOPICS") is True
+        assert self.loader._is_section_header("SECTION TWO") is True
+        # Long uppercase text might be a question
+        assert self.loader._is_section_header("A" * 50) is True  # Still detected as header (all caps)
+    
+    def test_allow_valid_questions(self):
+        """Test that valid questions are not detected as headers."""
+        assert self.loader._is_section_header("What is Azure?") is False
+        assert self.loader._is_section_header("How does machine learning work?") is False
+        assert self.loader._is_section_header("Can you explain the concept of containerization?") is False
+        assert self.loader._is_section_header("What are the benefits of cloud computing?") is False
+        assert self.loader._is_section_header("Why should I use Azure Cognitive Services?") is False
+    
+    def test_short_text_detected(self):
+        """Test that very short text is detected as potential header."""
+        assert self.loader._is_section_header("A") is True
+        assert self.loader._is_section_header("OK") is True
+        assert self.loader._is_section_header("") is True
+    
+    def test_numbered_sections(self):
+        """Test detection of numbered section headers."""
+        assert self.loader._is_section_header("1. Introduction") is True
+        assert self.loader._is_section_header("1.1 Overview") is True
+        assert self.loader._is_section_header("I. First Section") is True
+        # Numbered questions should NOT be detected as headers
+        assert self.loader._is_section_header("1. What is your question?") is False
+
+
+class TestBlankRowHandling:
+    """Test blank row handling in Excel loading."""
+    
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.loader = ExcelLoader()
+        self.temp_dir = '/tmp/test_excel_blank_rows'
+        os.makedirs(self.temp_dir, exist_ok=True)
+    
+    def test_load_with_blank_rows(self):
+        """Test loading Excel file with blank rows."""
+        import openpyxl
+        from openpyxl.workbook import Workbook
+        
+        # Create test file
+        wb = Workbook()
+        ws = wb.active
+        ws.title = 'Questions'
+        ws['A1'] = 'Question'
+        ws['B1'] = 'Response'
+        
+        ws['A2'] = 'Question 1?'
+        ws['A3'] = 'Question 2?'
+        # Row 4 is blank
+        ws['A5'] = 'Question 3?'
+        # Row 6 is blank
+        ws['A7'] = 'Question 4?'
+        
+        file_path = os.path.join(self.temp_dir, 'blank_rows_test.xlsx')
+        wb.save(file_path)
+        wb.close()
+        
+        # Load and verify
+        workbook_data = self.loader.load_workbook(file_path)
+        assert len(workbook_data.sheets) == 1
+        
+        sheet = workbook_data.sheets[0]
+        assert len(sheet.questions) == 4
+        assert sheet.questions == [
+            'Question 1?',
+            'Question 2?',
+            'Question 3?',
+            'Question 4?'
+        ]
+        assert sheet.row_indices == [2, 3, 5, 7]
+    
+    def test_load_with_section_headers(self):
+        """Test loading Excel file with section headers."""
+        import openpyxl
+        from openpyxl.workbook import Workbook
+        
+        # Create test file
+        wb = Workbook()
+        ws = wb.active
+        ws.title = 'Questions'
+        ws['A1'] = 'Question'
+        ws['B1'] = 'Response'
+        
+        ws['A2'] = 'Question 1?'
+        ws['A3'] = 'Section 2: Advanced Topics'  # Section header
+        ws['A4'] = 'Question 2?'
+        ws['A5'] = '--- Category ---'  # Decorated header
+        ws['A6'] = 'Question 3?'
+        
+        file_path = os.path.join(self.temp_dir, 'section_headers_test.xlsx')
+        wb.save(file_path)
+        wb.close()
+        
+        # Load and verify
+        workbook_data = self.loader.load_workbook(file_path)
+        sheet = workbook_data.sheets[0]
+        
+        assert len(sheet.questions) == 3
+        assert sheet.questions == [
+            'Question 1?',
+            'Question 2?',
+            'Question 3?'
+        ]
+        assert sheet.row_indices == [2, 4, 6]
+    
+    def test_save_with_row_indices(self):
+        """Test saving answers to correct rows when using row indices."""
+        import openpyxl
+        from openpyxl.workbook import Workbook
+        
+        # Create test file
+        wb = Workbook()
+        ws = wb.active
+        ws.title = 'Questions'
+        ws['A1'] = 'Question'
+        ws['B1'] = 'Response'
+        
+        ws['A2'] = 'Question 1?'
+        # Row 3 blank
+        ws['A4'] = 'Section header'
+        ws['A5'] = 'Question 2?'
+        
+        file_path = os.path.join(self.temp_dir, 'save_rows_test.xlsx')
+        wb.save(file_path)
+        wb.close()
+        
+        # Load, add answers, and save
+        workbook_data = self.loader.load_workbook(file_path)
+        sheet = workbook_data.sheets[0]
+        sheet.answers[0] = 'Answer 1'
+        sheet.answers[1] = 'Answer 2'
+        
+        output_path = os.path.join(self.temp_dir, 'save_rows_output.xlsx')
+        self.loader.save_workbook(workbook_data, output_path)
+        
+        # Verify output
+        wb = openpyxl.load_workbook(output_path)
+        ws = wb.active
+        
+        assert ws.cell(row=2, column=2).value == 'Answer 1'
+        assert ws.cell(row=3, column=2).value is None  # Blank row
+        assert ws.cell(row=4, column=2).value is None  # Section header row
+        assert ws.cell(row=5, column=2).value == 'Answer 2'
+        wb.close()
+
+
+if __name__ == '__main__':
+    pytest.main([__file__, '-v'])

From c391fb701b2d9193e8af173aa281c0af63718df1 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 3 Dec 2025 23:35:03 +0000
Subject: [PATCH 3/6] Extract magic numbers into class constants

Co-authored-by: mcasalaina <1323111+mcasalaina@users.noreply.github.com>
---
 src/excel/loader.py | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/src/excel/loader.py b/src/excel/loader.py
index 719ecb0..f76d804 100644
--- a/src/excel/loader.py
+++ b/src/excel/loader.py
@@ -142,6 +142,12 @@ def load_workbook(self, file_path: str) -> WorkbookData:
         
         return WorkbookData(file_path=file_path, sheets=sheets)
     
+    # Constants for section header detection heuristics
+    _MIN_TEXT_LENGTH = 3
+    _MAX_NUMBERED_HEADER_LENGTH = 60
+    _MAX_UPPERCASE_HEADER_WORDS = 6
+    _MAX_TITLE_HEADER_WORDS = 5
+    
     def _is_section_header(self, text: str) -> bool:
         """Determine if text appears to be a section header rather than a question.
         
@@ -158,7 +164,7 @@ def _is_section_header(self, text: str) -> bool:
         text = text.strip()
         
         # Empty or very short text
-        if len(text) < 3:
+        if len(text) < self._MIN_TEXT_LENGTH:
             return True
         
         # Pattern 1: Starts with common section prefixes like "Section", "Part", "Chapter"
@@ -178,18 +184,18 @@ def _is_section_header(self, text: str) -> bool:
         if re.match(r'^(?:\d+\.|\d+\.\d+|[IVXLCDM]+\.|[A-Z]\.)\s+[^?]*$', text):
             # Only consider it a header if it doesn't end with '?'
             if not text.rstrip().endswith('?'):
-                # And if it's relatively short (less than 60 chars without punctuation at end)
-                if len(text) < 60 and not text.rstrip().endswith(('.', '!', '?')):
+                # And if it's relatively short without punctuation at end
+                if len(text) < self._MAX_NUMBERED_HEADER_LENGTH and not text.rstrip().endswith(('.', '!', '?')):
                     return True
         
         # Pattern 4: All uppercase text (likely a header)
-        if text.isupper() and len(text.split()) <= 6:
+        if text.isupper() and len(text.split()) <= self._MAX_UPPERCASE_HEADER_WORDS:
             return True
         
         # Pattern 5: Text that contains only title-like content (no question marks, short)
         # and looks like a category label
         words = text.split()
-        if (len(words) <= 5 and 
+        if (len(words) <= self._MAX_TITLE_HEADER_WORDS and 
             not text.endswith('?') and 
             text.istitle() and 
             ':' in text):

From a9430c8fde999be0b57434db17c3ab2a79793bc2 Mon Sep 17 00:00:00 2001
From: Marco Casalaina <mcasalaina@microsoft.com>
Date: Sun, 11 Jan 2026 21:02:52 -0800
Subject: [PATCH 4/6] Add LLM-based header detection and question filtering for
 Excel files

- Use Azure AI to intelligently detect which row contains column headers
- Use LLM to filter out section titles and labels, keeping only actual questions
- Fix web app to use detected header row instead of assuming row 1
- Add automated tests for Excel files with non-standard header positions
- Add test file with headers in row 3 and section titles to filter
- Preserve original row numbers for correct answer placement

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
---
 AGENTS.md                                     |   85 ++
 run_app.py                                    |  203 ++-
 src/agents/workflow_manager.py                |   19 +-
 src/excel/loader.py                           |  381 ++++-
 src/utils/azure_auth.py                       |   36 +-
 src/utils/data_types.py                       |    1 +
 src/utils/exceptions.py                       |    1 +
 src/web/__init__.py                           |    5 +
 src/web/app.py                                | 1231 +++++++++++++++++
 src/web/mock_agents.py                        |  200 +++
 src/web/models.py                             |  256 ++++
 src/web/session_manager.py                    |  247 ++++
 src/web/sse_manager.py                        |  274 ++++
 src/web/static/app.js                         |  894 ++++++++++++
 src/web/static/favicon.svg                    |    4 +
 src/web/static/index.html                     |  231 ++++
 src/web/static/spreadsheet.js                 |  744 ++++++++++
 src/web/static/styles.css                     |  978 +++++++++++++
 ...e_questionnaire_simple_headers_blanks.xlsx |  Bin 0 -> 5249 bytes
 ...questionnaire_with_headers_and_blanks.xlsx |  Bin 0 -> 81438 bytes
 tests/unit/test_sample_file_headers_blanks.py |  164 +++
 21 files changed, 5915 insertions(+), 39 deletions(-)
 create mode 100644 AGENTS.md
 create mode 100644 src/web/__init__.py
 create mode 100644 src/web/app.py
 create mode 100644 src/web/mock_agents.py
 create mode 100644 src/web/models.py
 create mode 100644 src/web/session_manager.py
 create mode 100644 src/web/sse_manager.py
 create mode 100644 src/web/static/app.js
 create mode 100644 src/web/static/favicon.svg
 create mode 100644 src/web/static/index.html
 create mode 100644 src/web/static/spreadsheet.js
 create mode 100644 src/web/static/styles.css
 create mode 100644 tests/sample_questionnaire_simple_headers_blanks.xlsx
 create mode 100644 tests/sample_questionnaire_with_headers_and_blanks.xlsx
 create mode 100644 tests/unit/test_sample_file_headers_blanks.py

diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000..08d20f5
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,85 @@
+# QuestionnaireAgent_v3 Development Guidelines
+
+Auto-generated from all feature plans. Last updated: 2025-10-09
+
+## Virtual Environment
+
+**IMPORTANT**: All development and testing work must be done in the `.venv312` virtual environment.
+
+### Activating the Virtual Environment
+
+```bash
+source .venv312/bin/activate
+```
+
+### Running Tests
+
+Always activate the virtual environment before running tests:
+
+```bash
+source .venv312/bin/activate
+python -m pytest tests/unit/test_name.py -v
+```
+
+### Running the Application
+
+```bash
+source .venv312/bin/activate
+python src/main.py
+```
+
+## Active Technologies
+- Python 3.11+ + agent-framework-azure-ai (--pre), azure-ai-projects, azure-identity, tkinter, openpyxl, pandas, playwright, pytest (001-rewrite-questionnaire-agent)
+- Python 3.11+ + tkinter (GUI), openpyxl (Excel), agent-framework-azure-ai (multi-agent), azure-ai-projects, azure-identity (002-amend-the-answer)
+- Excel files (.xlsx) on local filesystem (002-amend-the-answer)
+- Python 3.11+ + FastAPI (web server), Uvicorn (ASGI server), Jinja2 (templates), ag-Grid Community Edition or Handsontable (spreadsheet), Playwright (testing) (004-add-web-mode)
+- Server-side session storage (in-memory dict with session IDs), temporary file storage for uploaded Excel files (004-add-web-mode)
+
+## Project Structure
+```
+src/
+tests/
+```
+
+## Commands
+cd src; pytest; ruff check .
+
+## Code Style
+Python 3.11+: Follow standard conventions
+
+## Recent Changes
+- 004-add-web-mode: Added Python 3.11+ + FastAPI (web server), Uvicorn (ASGI server), Jinja2 (templates), ag-Grid Community Edition or Handsontable (spreadsheet), Playwright (testing)
+- 002-amend-the-answer: Added Python 3.11+ + tkinter (GUI), openpyxl (Excel), agent-framework-azure-ai (multi-agent), azure-ai-projects, azure-identity
+- 001-rewrite-questionnaire-agent: Added Python 3.11+ + agent-framework-azure-ai (--pre), azure-ai-projects, azure-identity, tkinter, openpyxl, pandas, playwright, pytest
+
+---
+
+## Running the Web Application
+
+### For Automated Testing (Playwright, CI/CD)
+
+**Always use `--no-browser` when running Playwright tests or any automated browser testing:**
+
+```bash
+# Correct: Start server without opening a browser tab
+python run_app.py --web --port 8080 --no-browser
+
+# Incorrect: This will pop up a browser tab on your default browser
+python run_app.py --web --port 8080
+```
+
+**Why this matters:**
+- When an AI agent runs Playwright or automated tests, it controls its own browser instance
+- Without `--no-browser`, the app will open a tab in the user's default browser every time
+- This causes random browser popups during test runs, which is disruptive
+- The Playwright-controlled browser is separate from the user's browser
+
+**Rule:** If you are writing or running automated tests that involve the web interface, always include `--no-browser` in the server start command.
+
+### For Manual Testing
+
+When you want to manually interact with the UI:
+```bash
+python run_app.py --web --port 8080
+```
+This will start the server AND open a browser tab automatically.
diff --git a/run_app.py b/run_app.py
index 7d1fc47..274a9e8 100644
--- a/run_app.py
+++ b/run_app.py
@@ -5,6 +5,10 @@
 import os
 import asyncio
 import argparse
+import threading
+import time
+import webbrowser
+import socket
 from pathlib import Path
 
 # Add the src directory to Python path
@@ -122,24 +126,211 @@ def parse_arguments():
         default=None,
         help="Path to Excel spreadsheet to process immediately after initialization"
     )
-    
+
+    parser.add_argument(
+        "--web",
+        action="store_true",
+        help="Launch in web interface mode instead of desktop GUI"
+    )
+
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8080,
+        help="Port for web server (default: 8080, only used with --web)"
+    )
+
+    parser.add_argument(
+        "--no-browser",
+        action="store_true",
+        help="Don't automatically open browser (only used with --web)"
+    )
+
+    parser.add_argument(
+        "--mockagents",
+        action="store_true",
+        help="Use mock agents for testing (only used with --web)"
+    )
+
     return parser.parse_args()
 
 
+def is_port_in_use(port: int) -> bool:
+    """Check if a port is already in use.
+
+    Args:
+        port: Port number to check
+
+    Returns:
+        True if port is in use, False otherwise
+    """
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        try:
+            s.bind(("127.0.0.1", port))
+            return False
+        except socket.error:
+            return True
+
+
+def wait_for_server(port: int, timeout: float = 10.0) -> bool:
+    """Wait for the web server to become available.
+
+    Args:
+        port: Port to check
+        timeout: Maximum time to wait in seconds
+
+    Returns:
+        True if server is available, False if timeout
+    """
+    import requests
+    start_time = time.time()
+    url = f"http://127.0.0.1:{port}/health"
+
+    while time.time() - start_time < timeout:
+        try:
+            response = requests.get(url, timeout=1)
+            if response.status_code == 200:
+                return True
+        except requests.exceptions.RequestException:
+            pass
+        time.sleep(0.5)
+
+    return False
+
+
+async def initialize_and_run_web(args):
+    """Initialize and run the web interface.
+
+    Args:
+        args: Parsed command line arguments
+
+    Returns:
+        Exit code (0 for success)
+    """
+    from utils.azure_auth import test_authentication
+    from utils.config import config_manager
+    from utils.exceptions import AuthenticationError, ConfigurationError
+
+    try:
+        # Step 1: Check port availability
+        if is_port_in_use(args.port):
+            print(f"\n❌ Port {args.port} is already in use.")
+            print(f"   Try a different port with: python run_app.py --web --port {args.port + 1}")
+            return 1
+
+        # Step 2: Validate configuration
+        print("Validating configuration...")
+        validation_result = config_manager.validate_configuration()
+
+        if not validation_result.is_valid:
+            error_details = "; ".join(validation_result.error_details)
+            print(f"\n❌ Configuration Error: {error_details}")
+            print("\nPlease check:")
+            print("1. .env file exists and contains required values")
+            print("2. AZURE_OPENAI_ENDPOINT is set")
+            print("3. AZURE_OPENAI_MODEL_DEPLOYMENT is set")
+            print("4. BING_CONNECTION_ID is set")
+            return 1
+
+        print("✓ Configuration validated successfully")
+
+        # Step 3: Test Azure authentication (skip if using mock agents)
+        if not args.mockagents:
+            print("\nTesting Azure authentication...")
+            print("(Checking for existing 'az login' or 'azd login' session)")
+
+            try:
+                await test_authentication()
+                print("✓ Azure authentication successful")
+            except AuthenticationError as e:
+                print(f"\n❌ Authentication Error: {e}")
+                return 1
+        else:
+            print("\nSkipping Azure authentication (mock agents mode)")
+
+        # Step 4: Start web server
+        print(f"\nStarting web server on http://127.0.0.1:{args.port}")
+        if args.mockagents:
+            print("*** MOCK AGENTS ENABLED - Using mock agents for testing ***")
+
+        from web.app import run_server, cleanup, set_mock_agents_mode
+
+        # Set mock agents mode if requested
+        if args.mockagents:
+            set_mock_agents_mode(True)
+
+        # Start server in background thread
+        server_thread = threading.Thread(
+            target=run_server,
+            kwargs={"host": "127.0.0.1", "port": args.port, "log_level": "warning"},
+            daemon=True
+        )
+        server_thread.start()
+
+        # Wait for server to be ready
+        print("Waiting for server to start...")
+        if wait_for_server(args.port):
+            print("✓ Web server started successfully")
+        else:
+            print("\n⚠️  Server may still be starting...")
+
+        # Step 5: Open browser (unless --no-browser flag is set)
+        url = f"http://127.0.0.1:{args.port}"
+        if not args.no_browser:
+            print(f"\nOpening browser to: {url}")
+            webbrowser.open(url)
+        else:
+            print(f"\nServer ready at: {url}")
+
+        print("\n" + "=" * 50)
+        print("Web interface is running!")
+        print(f"URL: {url}")
+        print("Press Ctrl+C to stop the server")
+        print("=" * 50 + "\n")
+
+        # Keep main thread alive
+        try:
+            server_thread.join()
+        except KeyboardInterrupt:
+            print("\n\nShutting down web server...")
+            cleanup()
+            print("Web server stopped.")
+
+        return 0
+
+    except ConfigurationError as e:
+        print(f"\n❌ Configuration Error: {e}")
+        return 1
+    except AuthenticationError as e:
+        print(f"\n❌ Authentication Error: {e}")
+        return 1
+    except Exception as e:
+        print(f"\n❌ Unexpected Error: {e}")
+        import traceback
+        traceback.print_exc()
+        return 1
+
+
 # Now import and run the application
 if __name__ == "__main__":
     try:
         # Parse command line arguments
         args = parse_arguments()
-        
+
         # Set up event loop policy for Windows
         if sys.platform == "win32":
             asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
-        
-        # Run async initialization
-        exit_code = asyncio.run(initialize_and_run(args))
+
+        # Choose mode based on --web flag
+        if args.web:
+            # Web interface mode
+            exit_code = asyncio.run(initialize_and_run_web(args))
+        else:
+            # Desktop GUI mode (tkinter)
+            exit_code = asyncio.run(initialize_and_run(args))
+
         sys.exit(exit_code)
-        
+
     except KeyboardInterrupt:
         print("\nApplication interrupted by user")
         sys.exit(0)
diff --git a/src/agents/workflow_manager.py b/src/agents/workflow_manager.py
index ffe0d70..8ff526f 100644
--- a/src/agents/workflow_manager.py
+++ b/src/agents/workflow_manager.py
@@ -27,18 +27,20 @@
 class AgentCoordinator:
     """Orchestrates multi-agent workflow using Microsoft Agent Framework."""
     
-    def __init__(self, azure_client: AzureAIAgentClient, bing_connection_id: str, 
-                 browser_automation_connection_id: str):
+    def __init__(self, azure_client: AzureAIAgentClient, bing_connection_id: str,
+                 browser_automation_connection_id: str, project_client=None):
         """Initialize the agent coordinator.
-        
+
         Args:
             azure_client: Azure AI Agent client for creating agents.
             bing_connection_id: Bing search connection ID for web grounding.
             browser_automation_connection_id: Browser automation connection ID for link checking.
+            project_client: Azure AI Project client for connection resolution (optional).
         """
         self.azure_client = azure_client
         self.bing_connection_id = bing_connection_id
         self.browser_automation_connection_id = browser_automation_connection_id
+        self.project_client = project_client
         self.workflow: Optional[Workflow] = None
         self.executors_created = False
         
@@ -450,20 +452,21 @@ async def cleanup_agents(self) -> None:
             logger.warning(f"Error during agent cleanup: {e}")
 
 
-async def create_agent_coordinator(azure_client: AzureAIAgentClient, bing_connection_id: str, 
-                                  browser_automation_connection_id: str) -> AgentCoordinator:
+async def create_agent_coordinator(azure_client: AzureAIAgentClient, bing_connection_id: str,
+                                  browser_automation_connection_id: str, project_client=None) -> AgentCoordinator:
     """Create and initialize an agent coordinator.
-    
+
     Args:
         azure_client: Azure AI Agent client.
         bing_connection_id: Bing search connection ID.
         browser_automation_connection_id: Browser automation connection ID for link checking.
-        
+        project_client: Optional Azure AI Project client for browser automation.
+
     Returns:
         Initialized AgentCoordinator instance.
     """
     logger.info("Creating agent coordinator...")
-    coordinator = AgentCoordinator(azure_client, bing_connection_id, browser_automation_connection_id)
+    coordinator = AgentCoordinator(azure_client, bing_connection_id, browser_automation_connection_id, project_client)
     
     logger.info("Creating agents with 60 second timeout...")
     try:
diff --git a/src/excel/loader.py b/src/excel/loader.py
index f76d804..d53c903 100644
--- a/src/excel/loader.py
+++ b/src/excel/loader.py
@@ -15,12 +15,112 @@ class ExcelLoader:
     
     def __init__(self, column_identifier=None):
         """Initialize Excel loader.
-        
+
         Args:
             column_identifier: Optional ColumnIdentifier instance for detecting columns.
                              If None, will use fallback (column A = Question, B = Response).
         """
         self.column_identifier = column_identifier
+
+    def _run_async_in_thread(self, coro):
+        """Run an async coroutine in a separate thread with its own event loop.
+
+        This is necessary when calling async code from a context that already
+        has a running event loop (like FastAPI).
+
+        Args:
+            coro: The coroutine to run
+
+        Returns:
+            The result of the coroutine
+        """
+        import asyncio
+        import threading
+
+        result = None
+        error = None
+
+        def run_in_thread():
+            nonlocal result, error
+            try:
+                # Create a new event loop for this thread
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                try:
+                    result = loop.run_until_complete(coro)
+                finally:
+                    # Clean up pending tasks before closing the loop
+                    pending = asyncio.all_tasks(loop)
+                    for task in pending:
+                        task.cancel()
+                    # Give tasks a chance to complete cancellation
+                    if pending:
+                        loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
+                    loop.close()
+            except Exception as e:
+                error = e
+
+        thread = threading.Thread(target=run_in_thread)
+        thread.start()
+        thread.join(timeout=60)  # Add timeout to prevent hanging
+
+        if thread.is_alive():
+            raise TimeoutError("Async operation timed out after 60 seconds")
+
+        if error:
+            raise error
+        return result
+
+    def _run_async_in_thread_v2(self, async_func):
+        """Run an async function in a separate thread with its own event loop.
+
+        This version takes an async function (not a coroutine), so the coroutine
+        is created inside the thread's event loop, avoiding issues with event loop
+        references.
+
+        Args:
+            async_func: An async function to call (not a coroutine)
+
+        Returns:
+            The result of the async function
+        """
+        import asyncio
+        import threading
+
+        result = None
+        error = None
+
+        def run_in_thread():
+            nonlocal result, error
+            try:
+                # Create a new event loop for this thread
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                try:
+                    # Call the async function inside this thread's event loop
+                    result = loop.run_until_complete(async_func())
+                finally:
+                    # Clean up pending tasks before closing the loop
+                    pending = asyncio.all_tasks(loop)
+                    for task in pending:
+                        task.cancel()
+                    # Give tasks a chance to complete cancellation
+                    if pending:
+                        loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
+                    loop.close()
+            except Exception as e:
+                error = e
+
+        thread = threading.Thread(target=run_in_thread)
+        thread.start()
+        thread.join(timeout=60)  # Add timeout to prevent hanging
+
+        if thread.is_alive():
+            raise TimeoutError("Async operation timed out after 60 seconds")
+
+        if error:
+            raise error
+        return result
     
     def load_workbook(self, file_path: str) -> WorkbookData:
         """Load Excel file into WorkbookData structure.
@@ -55,15 +155,23 @@ def load_workbook(self, file_path: str) -> WorkbookData:
             if ws.sheet_state != 'visible':
                 logger.info(f"Skipping hidden sheet: {sheet_name}")
                 continue
-            
-            # Get headers from first row
+
+            # Find the actual header row (it may not be row 1)
+            header_row_num = self._find_header_row(ws)
+            if header_row_num is None:
+                logger.warning(f"Sheet '{sheet_name}' has no recognizable header row, skipping")
+                continue
+
+            # Get headers from identified header row
             headers = []
-            for cell in ws[1]:
+            for cell in ws[header_row_num]:
                 headers.append(cell.value if cell.value else '')
-            
+
             if not headers:
                 logger.warning(f"Sheet '{sheet_name}' has no headers, skipping")
                 continue
+
+            logger.info(f"Found headers in row {header_row_num} for sheet '{sheet_name}'")
             
             # Identify columns using column identifier or fallback to defaults
             column_mapping = {'question': 0, 'response': 1, 'documentation': None}
@@ -84,26 +192,30 @@ def load_workbook(self, file_path: str) -> WorkbookData:
                 continue
             
             # Extract questions from identified question column (0-based to 1-based for openpyxl)
-            # Skip blank rows and section headers, tracking original row indices
-            questions = []
-            row_indices = []  # Track original Excel row numbers (1-based)
-            
-            for row in ws.iter_rows(min_row=2, min_col=question_col+1, max_col=question_col+1):
+            # Collect all non-blank rows first, then use LLM to filter
+            all_rows = []
+            for row in ws.iter_rows(min_row=header_row_num+1, min_col=question_col+1, max_col=question_col+1):
                 cell = row[0]
                 cell_value = str(cell.value).strip() if cell.value else ''
-                
+
                 # Skip blank cells
                 if not cell_value:
                     logger.debug(f"Skipping blank row {cell.row} in sheet '{sheet_name}'")
                     continue
-                
-                # Skip section headers (heuristic detection)
-                if self._is_section_header(cell_value):
-                    logger.info(f"Skipping section header at row {cell.row} in sheet '{sheet_name}': '{cell_value}'")
-                    continue
-                
-                questions.append(cell_value)
-                row_indices.append(cell.row)  # Store the actual Excel row number (1-based)
+
+                all_rows.append({
+                    'row_num': cell.row,
+                    'text': cell_value
+                })
+
+            # Use LLM to filter out section titles/labels, keeping only actual questions
+            questions = []
+            row_indices = []
+
+            if all_rows:
+                filtered_rows = self._filter_questions_with_llm(all_rows, sheet_name)
+                questions = [r['text'] for r in filtered_rows]
+                row_indices = [r['row_num'] for r in filtered_rows]
             
             if not questions:
                 logger.warning(f"Sheet '{sheet_name}' has no questions, skipping")
@@ -125,7 +237,8 @@ def load_workbook(self, file_path: str) -> WorkbookData:
                 question_col_index=question_col,
                 response_col_index=response_col,
                 documentation_col_index=doc_col,
-                row_indices=row_indices
+                row_indices=row_indices,
+                header_row_num=header_row_num
             )
             sheets.append(sheet_data)
         
@@ -141,7 +254,233 @@ def load_workbook(self, file_path: str) -> WorkbookData:
         logger.info(f"Loaded {len(sheets)} sheets with {total_questions} total questions")
         
         return WorkbookData(file_path=file_path, sheets=sheets)
-    
+
+    def _find_header_row(self, ws) -> int:
+        """Find the row containing column headers using LLM.
+
+        Uses Azure AI to intelligently identify which row contains the actual column headers.
+
+        Args:
+            ws: openpyxl worksheet object
+
+        Returns:
+            Row number (1-based) of the header row
+        """
+        import asyncio
+        import threading
+
+        # Get first 10 rows
+        rows_data = []
+        for row_num in range(1, min(11, ws.max_row + 1)):
+            row_values = []
+            for cell in ws[row_num]:
+                val = str(cell.value) if cell.value else ""
+                row_values.append(val[:100])  # Limit cell length
+            if any(row_values):  # Skip completely empty rows
+                rows_data.append({
+                    'row_number': row_num,
+                    'values': row_values[:10]  # Limit to first 10 columns
+                })
+
+        if not rows_data:
+            return 1
+
+        # Build prompt for LLM
+        rows_text = "\n".join([
+            f"Row {r['row_number']}: {' | '.join([v for v in r['values'] if v])}"
+            for r in rows_data
+        ])
+
+        prompt = f"""You are analyzing an Excel spreadsheet to find the header row.
+
+Here are the first few rows:
+
+{rows_text}
+
+Which row number contains the column headers (the row with column names like "Question", "Answer", "Response", "Index", etc.)?
+
+Respond with ONLY the row number as a single integer, nothing else."""
+
+        try:
+            # Run async code in a separate thread to avoid event loop conflicts
+            async def do_header_detection():
+                return await self._ask_llm_for_header_row(prompt)
+
+            result = self._run_async_in_thread_v2(do_header_detection)
+
+            # Parse the response
+            row_num = int(result.strip())
+            if 1 <= row_num <= min(10, ws.max_row):
+                logger.info(f"LLM identified header row: {row_num}")
+                return row_num
+            else:
+                logger.warning(f"LLM returned invalid row number {row_num}, using fallback")
+                return self._find_header_row_fallback(ws)
+        except Exception as e:
+            logger.warning(f"LLM header detection failed: {e}, using fallback")
+            return self._find_header_row_fallback(ws)
+
+    async def _ask_llm_for_header_row(self, prompt: str) -> str:
+        """Ask LLM to identify header row."""
+        from agent_framework import ChatAgent
+        from agent_framework_azure_ai import AzureAIAgentClient
+        from azure.ai.projects.aio import AIProjectClient
+        from azure.identity.aio import DefaultAzureCredential
+        from utils.config import config_manager
+
+        # Create a fresh Azure client for this thread's event loop
+        endpoint = config_manager.get_azure_endpoint()
+        model_deployment = config_manager.get_model_deployment()
+        credential = DefaultAzureCredential()
+
+        project_client = AIProjectClient(
+            endpoint=endpoint,
+            credential=credential
+        )
+
+        azure_client = AzureAIAgentClient(
+            project_client=project_client,
+            credential=credential,
+            model_deployment_name=model_deployment
+        )
+
+        # Create a ChatAgent for this task
+        agent = ChatAgent(
+            chat_client=azure_client,
+            name="Header Row Identifier",
+            instructions="You are a data analysis assistant that identifies column headers in spreadsheets."
+        )
+
+        # Get the response
+        response = await agent.run(prompt)
+
+        return response.text if response else ""
+
+    def _find_header_row_fallback(self, ws) -> int:
+        """Fallback method to find header row using simple heuristics."""
+        # Look for a row with multiple non-numeric values
+        for row_num in range(1, min(11, ws.max_row + 1)):
+            non_empty_count = 0
+            for cell in ws[row_num]:
+                if cell.value and not str(cell.value).isdigit():
+                    non_empty_count += 1
+            if non_empty_count >= 2:
+                return row_num
+        return 1
+
+    def _filter_questions_with_llm(self, rows: List[dict], sheet_name: str) -> List[dict]:
+        """Filter out section titles/labels, keeping only actual questions using LLM.
+
+        Args:
+            rows: List of dicts with 'row_num' and 'text' keys
+            sheet_name: Name of the sheet being processed
+
+        Returns:
+            Filtered list of rows containing only actual questions
+        """
+        if not rows:
+            return []
+
+        # Build list of rows for LLM analysis
+        rows_text = "\n".join([
+            f"{i+1}. (Row {r['row_num']}): {r['text'][:200]}"
+            for i, r in enumerate(rows)
+        ])
+
+        prompt = f"""You are analyzing an Excel questionnaire to identify actual questions that need answers.
+
+Here are the rows from the "{sheet_name}" sheet Question column:
+
+{rows_text}
+
+Your task: Identify which rows contain items that need to be answered in a questionnaire.
+
+EXCLUDE ONLY these types of rows:
+- Pure section titles with no content expectation (e.g., "Platform Overview", "Section 1: Background")
+- Instructional text for the entire section (e.g., "Answer all questions below", "Provide details in Column C")
+- Decorative separators (e.g., "---", "===", "***")
+
+INCLUDE these types of rows (these ALL need answers):
+- Direct questions (e.g., "What is your platform name?", "Do you support training?")
+- Imperative prompts (e.g., "Describe your capabilities", "List your differentiators", "Explain how...")
+- Feature/capability items in a checklist format (e.g., "Automated ML pipeline orchestration", "Feature store support")
+- Any statement that expects the user to provide information, even if not phrased as a question
+- Items that would have a yes/no, description, or details as an answer
+
+IMPORTANT RULES:
+- If it's a feature, capability, or technical item that expects a response (yes/no/details), INCLUDE it
+- If it's just organizing the questionnaire into sections without expecting an answer, EXCLUDE it
+- When in doubt, INCLUDE it (be permissive, not restrictive)
+
+Respond with ONLY a JSON array of the row numbers (from the original "Row X" labels) that need answers.
+Example response format: [4, 5, 9, 10, 14]
+
+If none of the rows need answers, respond with: []"""
+
+        try:
+            # Run async code in a separate thread to avoid event loop conflicts
+            async def do_filtering():
+                return await self._ask_llm_for_filtering(prompt)
+
+            result = self._run_async_in_thread_v2(do_filtering)
+
+            # Parse JSON response
+            import json
+            try:
+                question_row_nums = json.loads(result.strip())
+                if not isinstance(question_row_nums, list):
+                    logger.warning(f"LLM returned invalid format, using all rows")
+                    return rows
+
+                # Filter to only rows with matching row numbers
+                filtered = [r for r in rows if r['row_num'] in question_row_nums]
+                logger.info(f"LLM filtered {len(rows)} rows down to {len(filtered)} questions in sheet '{sheet_name}'")
+                return filtered
+
+            except json.JSONDecodeError as e:
+                logger.warning(f"Failed to parse LLM filtering response as JSON: {e}, using all rows")
+                return rows
+
+        except Exception as e:
+            logger.warning(f"LLM filtering failed: {e}, using all rows")
+            return rows
+
+    async def _ask_llm_for_filtering(self, prompt: str) -> str:
+        """Ask LLM to identify which rows are actual questions."""
+        from agent_framework import ChatAgent
+        from agent_framework_azure_ai import AzureAIAgentClient
+        from azure.ai.projects.aio import AIProjectClient
+        from azure.identity.aio import DefaultAzureCredential
+        from utils.config import config_manager
+
+        # Create a fresh Azure client for this thread's event loop
+        endpoint = config_manager.get_azure_endpoint()
+        model_deployment = config_manager.get_model_deployment()
+        credential = DefaultAzureCredential()
+
+        project_client = AIProjectClient(
+            endpoint=endpoint,
+            credential=credential
+        )
+
+        azure_client = AzureAIAgentClient(
+            project_client=project_client,
+            credential=credential,
+            model_deployment_name=model_deployment
+        )
+
+        # Create a ChatAgent for this task
+        agent = ChatAgent(
+            chat_client=azure_client,
+            name="Question Filter",
+            instructions="You are a data analysis assistant that identifies actual questions in questionnaires, distinguishing them from section titles and labels."
+        )
+
+        # Get the response
+        response = await agent.run(prompt)
+
+        return response.text if response else ""
+
     # Constants for section header detection heuristics
     _MIN_TEXT_LENGTH = 3
     _MAX_NUMBERED_HEADER_LENGTH = 60
diff --git a/src/utils/azure_auth.py b/src/utils/azure_auth.py
index f9adba0..84a0c84 100644
--- a/src/utils/azure_auth.py
+++ b/src/utils/azure_auth.py
@@ -2,6 +2,7 @@
 
 import asyncio
 import logging
+import os
 from typing import Optional
 from contextlib import asynccontextmanager
 from urllib.parse import urlparse
@@ -14,10 +15,18 @@
     ManagedIdentityCredential
 )
 from azure.core.exceptions import ClientAuthenticationError, ResourceNotFoundError
-from agent_framework_azure_ai import AzureAIAgentClient
 from .config import config_manager
 from .exceptions import AuthenticationError, AzureServiceError
 
+# Set AZURE_AI_PROJECT_ENDPOINT from AZURE_OPENAI_ENDPOINT if not already set
+# The agent_framework_azure_ai SDK expects this environment variable
+if not os.environ.get("AZURE_AI_PROJECT_ENDPOINT"):
+    endpoint = config_manager.get_azure_endpoint()
+    if endpoint:
+        os.environ["AZURE_AI_PROJECT_ENDPOINT"] = endpoint
+
+from agent_framework_azure_ai import AzureAIAgentClient
+
 
 logger = logging.getLogger(__name__)
 
@@ -165,6 +174,7 @@ async def get_azure_client(self) -> AzureAIAgentClient:
             
             self._client = AzureAIAgentClient(
                 project_client=self._project_client,
+                credential=credential,
                 model_deployment_name=model_deployment
             )
             
@@ -334,12 +344,12 @@ async def verify_azure_connectivity() -> bool:
 
 async def get_azure_client() -> AzureAIAgentClient:
     """Get authenticated Azure AI Agent client.
-    
+
     This is a convenience function for getting the global client instance.
-    
+
     Returns:
         Configured AzureAIAgentClient instance.
-        
+
     Raises:
         AuthenticationError: If authentication fails.
         AzureServiceError: If Azure services are unavailable.
@@ -347,6 +357,24 @@ async def get_azure_client() -> AzureAIAgentClient:
     return await azure_authenticator.get_azure_client()
 
 
+async def get_project_client():
+    """Get the Azure AI Project client.
+
+    This is needed for operations that require direct access to the project client,
+    such as resolving connection IDs for browser automation.
+
+    Returns:
+        AIProjectClient instance.
+
+    Raises:
+        AuthenticationError: If authentication fails.
+        AzureServiceError: If Azure services are unavailable.
+    """
+    # Ensure the clients are initialized
+    await azure_authenticator.get_azure_client()
+    return azure_authenticator._project_client
+
+
 def reset_azure_authentication() -> None:
     """Reset Azure authentication state.
     
diff --git a/src/utils/data_types.py b/src/utils/data_types.py
index 489c6ad..f969bc4 100644
--- a/src/utils/data_types.py
+++ b/src/utils/data_types.py
@@ -331,6 +331,7 @@ class SheetData:
     response_col_index: Optional[int] = None
     documentation_col_index: Optional[int] = None
     row_indices: Optional[List[int]] = None  # Original Excel row numbers (1-based) for each question
+    header_row_num: int = 1  # Row number where headers are located (1-based)
     
     def __post_init__(self):
         """Validate invariants."""
diff --git a/src/utils/exceptions.py b/src/utils/exceptions.py
index bb76acc..351b8af 100644
--- a/src/utils/exceptions.py
+++ b/src/utils/exceptions.py
@@ -1,4 +1,5 @@
 """Custom exception classes for the questionnaire application."""
+from __future__ import annotations
 
 
 class QuestionnaireError(Exception):
diff --git a/src/web/__init__.py b/src/web/__init__.py
new file mode 100644
index 0000000..409efbe
--- /dev/null
+++ b/src/web/__init__.py
@@ -0,0 +1,5 @@
+"""Web interface module for the questionnaire application.
+
+This module provides a FastAPI-based web server that serves as an alternative
+to the tkinter desktop GUI. Launch with --web flag to enable.
+"""
diff --git a/src/web/app.py b/src/web/app.py
new file mode 100644
index 0000000..bd191dd
--- /dev/null
+++ b/src/web/app.py
@@ -0,0 +1,1231 @@
+"""FastAPI web application for questionnaire agent.
+
+Provides REST API endpoints and serves the web interface.
+"""
+
+import asyncio
+import logging
+import os
+import shutil
+import tempfile
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from fastapi import FastAPI, HTTPException, UploadFile, File, Form, BackgroundTasks
+from fastapi.responses import FileResponse, StreamingResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+
+from .models import (
+    SessionCreateResponse,
+    SessionGetResponse,
+    SessionConfigUpdate,
+    SessionConfigUpdateResponse,
+    QuestionRequest,
+    QuestionResponse,
+    SpreadsheetUploadResponse,
+    ColumnSuggestions,
+    ProcessingStartRequest,
+    ProcessingStartResponse,
+    ProcessingStatusResponse,
+    StopProcessingRequest,
+    StopProcessingResponse,
+    HealthResponse,
+    ProcessingJob,
+    JobStatus,
+    SSEMessageType,
+)
+from .session_manager import session_manager
+from .sse_manager import sse_manager
+from excel.loader import ExcelLoader
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Global flag for mock agents mode
+_mock_agents_mode = False
+
+
+def set_mock_agents_mode(enabled: bool):
+    """Enable or disable mock agents mode for testing.
+
+    Args:
+        enabled: True to use mock agents, False for real agents
+    """
+    global _mock_agents_mode
+    _mock_agents_mode = enabled
+    logger.info(f"Mock agents mode: {'ENABLED' if enabled else 'DISABLED'}")
+
+# Determine static files directory
+STATIC_DIR = Path(__file__).parent / "static"
+
+# Create FastAPI app
+app = FastAPI(
+    title="Questionnaire Agent Web",
+    description="Web interface for the questionnaire answering agent",
+    version="1.0.0"
+)
+
+# Mount static files
+if STATIC_DIR.exists():
+    app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
+
+
+# ============================================================================
+# Health Check
+# ============================================================================
+
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """Health check endpoint."""
+    azure_auth_status = "authenticated"
+    status = "healthy"
+    message = None
+
+    # Try to verify Azure auth
+    try:
+        from utils.azure_auth import test_authentication
+        # We can't run async here easily, so we'll assume authenticated if module loads
+    except ImportError:
+        azure_auth_status = "unknown"
+        message = "Azure auth module not available"
+    except Exception as e:
+        azure_auth_status = "unauthenticated"
+        status = "degraded"
+        message = str(e)
+
+    return HealthResponse(
+        status=status,
+        timestamp=datetime.now().isoformat(),
+        azure_auth=azure_auth_status,
+        message=message
+    )
+
+
+# ============================================================================
+# Index Route
+# ============================================================================
+
+@app.get("/")
+async def index():
+    """Serve the main web interface."""
+    index_path = STATIC_DIR / "index.html"
+    if not index_path.exists():
+        raise HTTPException(status_code=500, detail="Web interface not found")
+    return FileResponse(str(index_path))
+
+
+@app.get("/favicon.ico")
+async def favicon():
+    """Serve the favicon."""
+    favicon_path = STATIC_DIR / "favicon.svg"
+    if favicon_path.exists():
+        return FileResponse(str(favicon_path), media_type="image/svg+xml")
+    raise HTTPException(status_code=404, detail="Favicon not found")
+
+
+# ============================================================================
+# Session Management
+# ============================================================================
+
+@app.post("/api/session/create", response_model=SessionCreateResponse, status_code=201)
+async def create_session():
+    """Create a new session."""
+    session_id = session_manager.create_session()
+    session = session_manager.get_session(session_id)
+
+    return SessionCreateResponse(
+        session_id=session_id,
+        created_at=session.created_at.isoformat(),
+        config=session.config
+    )
+
+
+@app.get("/api/session/{session_id}", response_model=SessionGetResponse)
+async def get_session(session_id: str):
+    """Get session state."""
+    session = session_manager.get_session(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    processing_status = None
+    if session.processing_job:
+        processing_status = session.processing_job.status.value
+
+    return SessionGetResponse(
+        session_id=session_id,
+        created_at=session.created_at.isoformat(),
+        config=session.config,
+        has_workbook=session.workbook_data is not None,
+        processing_status=processing_status
+    )
+
+
+@app.put("/api/session/{session_id}/config", response_model=SessionConfigUpdateResponse)
+async def update_session_config(session_id: str, update: SessionConfigUpdate):
+    """Update session configuration."""
+    session = session_manager.get_session(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    if not session_manager.update_config(
+        session_id,
+        context=update.context,
+        char_limit=update.char_limit
+    ):
+        raise HTTPException(status_code=500, detail="Failed to update config")
+
+    return SessionConfigUpdateResponse(
+        session_id=session_id,
+        config=session.config
+    )
+
+
+@app.delete("/api/session/{session_id}")
+async def delete_session(session_id: str):
+    """Delete a session."""
+    if not session_manager.delete_session(session_id):
+        raise HTTPException(status_code=404, detail="Session not found")
+    return {"status": "deleted", "session_id": session_id}
+
+
+# ============================================================================
+# Question Processing
+# ============================================================================
+
+@app.post("/api/question", response_model=QuestionResponse)
+async def process_question(request: QuestionRequest):
+    """Process a single question."""
+    session = session_manager.get_session(request.session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    start_time = time.time()
+
+    try:
+        from utils.data_types import Question
+
+        # Create question object
+        question = Question(
+            text=request.question,
+            context=request.context,
+            char_limit=request.char_limit
+        )
+
+        # Create callbacks for processing
+        reasoning_parts = []
+
+        def progress_callback(agent: str, message: str, progress: float):
+            logger.info(f"[{agent}] {message} ({progress:.1%})")
+
+        def reasoning_callback(text: str):
+            reasoning_parts.append(text)
+
+        # Use mock agents if enabled
+        if _mock_agents_mode:
+            from .mock_agents import create_mock_agent_coordinator
+            coordinator = await create_mock_agent_coordinator()
+
+            result = await coordinator.process_question(
+                question,
+                progress_callback=progress_callback,
+                reasoning_callback=reasoning_callback
+            )
+
+            await coordinator.cleanup_agents()
+        else:
+            # Use real agents
+            from agents.workflow_manager import create_agent_coordinator
+            from utils.azure_auth import foundry_agent_session, get_project_client
+            from utils.config import config_manager
+
+            # Get Azure client and project client, then create coordinator
+            async with foundry_agent_session() as azure_client:
+                project_client = await get_project_client()
+                coordinator = await create_agent_coordinator(
+                    azure_client=azure_client,
+                    bing_connection_id=config_manager.get_bing_connection_id(),
+                    browser_automation_connection_id=config_manager.get_browser_automation_connection_id(),
+                    project_client=project_client
+                )
+
+                # Process with agent coordinator
+                result = await coordinator.process_question(
+                    question,
+                    progress_callback=progress_callback,
+                    reasoning_callback=reasoning_callback
+                )
+
+                # Cleanup
+                await coordinator.cleanup_agents()
+
+        processing_time = time.time() - start_time
+
+        # Format reasoning
+        reasoning = _format_reasoning(result, reasoning_parts)
+
+        return QuestionResponse(
+            answer=result.answer.content if result.answer else "No answer generated",
+            reasoning=reasoning,
+            processing_time_seconds=round(processing_time, 2),
+            links_checked=len(result.answer.documentation_links) if result.answer else 0
+        )
+
+    except ImportError as e:
+        logger.error(f"Agent import error: {e}")
+        raise HTTPException(status_code=500, detail="Agent services not available")
+    except Exception as e:
+        logger.error(f"Question processing error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+def _format_reasoning(result, reasoning_parts: list = None) -> str:
+    """Format agent reasoning trace for display."""
+    # Start with any collected reasoning parts
+    output = []
+    if reasoning_parts:
+        output.extend(reasoning_parts)
+
+    try:
+        from utils.reasoning_formatter import format_reasoning_trace
+        if result.answer and result.answer.agent_reasoning:
+            formatted = format_reasoning_trace(result.answer.agent_reasoning)
+            output.append(formatted)
+    except ImportError:
+        # Fallback formatting
+        if result.answer and result.answer.agent_reasoning:
+            output.append("## Agent Workflow\n")
+            for step in result.answer.agent_reasoning:
+                output.append(f"### {step.agent_name.value if hasattr(step.agent_name, 'value') else step.agent_name}")
+                output.append(f"- Status: {step.status.value if hasattr(step.status, 'value') else step.status}")
+                if hasattr(step, 'execution_time'):
+                    output.append(f"- Time: {step.execution_time:.2f}s")
+                if hasattr(step, 'error_message') and step.error_message:
+                    output.append(f"- Error: {step.error_message}")
+                output.append("")
+
+    return "\n".join(output) if output else "No reasoning trace available"
+
+
+# ============================================================================
+# Spreadsheet Operations
+# ============================================================================
+
+@app.post("/api/spreadsheet/upload", response_model=SpreadsheetUploadResponse)
+async def upload_spreadsheet(
+    session_id: str = Form(...),
+    file: UploadFile = File(...)
+):
+    """Upload an Excel file for processing."""
+    session = session_manager.get_session(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    # Validate file extension
+    if not file.filename:
+        raise HTTPException(status_code=400, detail="No filename provided")
+
+    ext = Path(file.filename).suffix.lower()
+    if ext not in ('.xlsx', '.xls'):
+        raise HTTPException(status_code=400, detail="Invalid file format. Only .xlsx and .xls files are supported.")
+
+    try:
+        # Save to temp file
+        temp_fd, temp_path = tempfile.mkstemp(suffix=ext)
+        os.close(temp_fd)
+
+        with open(temp_path, 'wb') as f:
+            shutil.copyfileobj(file.file, f)
+
+        # Load workbook using existing loader
+        from excel.loader import ExcelLoader
+        from excel.column_identifier import ColumnIdentifier
+
+        identifier = ColumnIdentifier()
+        loader = ExcelLoader(column_identifier=identifier)
+        workbook_data = loader.load_workbook(temp_path)
+
+        # Get column info and data
+        columns = {}
+        sheets = []
+        data = {}
+        total_rows = 0
+        for sheet in workbook_data.sheets:
+            sheets.append(sheet.sheet_name)
+            # Get column names from the sheet
+            sheet_columns = _get_column_names(sheet, temp_path)
+            columns[sheet.sheet_name] = sheet_columns
+            # Get row data
+            data[sheet.sheet_name] = _get_sheet_data(temp_path, sheet, sheet_columns)
+            total_rows += len(data[sheet.sheet_name])
+
+        # Get suggestions from the first sheet using AI-based column identification
+        suggestions = await _identify_columns(workbook_data, columns)
+
+        # Store in session
+        session_manager.set_workbook(session_id, workbook_data, temp_path, columns)
+
+        return SpreadsheetUploadResponse(
+            session_id=session_id,
+            filename=file.filename,
+            sheets=sheets,
+            columns=columns,
+            suggested_columns=suggestions,
+            row_count=total_rows,
+            data=data
+        )
+
+    except ImportError as e:
+        logger.error(f"Excel import error: {e}")
+        raise HTTPException(status_code=500, detail="Excel processing not available")
+    except Exception as e:
+        logger.error(f"Upload error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Failed to process file: {str(e)}")
+
+
+def _get_column_names(sheet, file_path: str) -> list:
+    """Extract column names from sheet by reading Excel headers."""
+    import openpyxl
+
+    try:
+        wb = openpyxl.load_workbook(file_path, data_only=True)
+        ws = wb[sheet.sheet_name]
+
+        # Get headers from the actual header row (not always row 1!)
+        header_row = getattr(sheet, 'header_row_num', 1)
+        headers = []
+        for cell in ws[header_row]:
+            if cell.value:
+                headers.append(str(cell.value))
+            else:
+                break
+
+        wb.close()
+        return headers if headers else ["A", "B", "C", "D", "E"]
+
+    except Exception as e:
+        logger.warning(f"Failed to read headers: {e}")
+        # Fallback based on detected column indices
+        columns = []
+        if sheet.question_col_index is not None:
+            columns.append("Question")
+        if sheet.response_col_index is not None:
+            columns.append("Answer")
+        if sheet.documentation_col_index is not None:
+            columns.append("Documentation")
+        return columns if columns else ["A", "B", "C", "D", "E"]
+
+
+def _get_sheet_data(file_path: str, sheet, columns: list) -> list:
+    """Extract all row data from a sheet."""
+    import openpyxl
+
+    rows = []
+    try:
+        wb = openpyxl.load_workbook(file_path, data_only=True)
+        ws = wb[sheet.sheet_name]
+
+        # Skip header row, iterate data rows (header row might not be row 1!)
+        header_row = getattr(sheet, 'header_row_num', 1)
+        for row_idx, row in enumerate(ws.iter_rows(min_row=header_row+1, values_only=True)):
+            row_dict = {"rowIndex": str(row_idx)}
+            for col_idx, col_name in enumerate(columns):
+                if col_idx < len(row):
+                    value = row[col_idx]
+                    row_dict[col_name] = str(value) if value is not None else ""
+                else:
+                    row_dict[col_name] = ""
+            # Only include rows that have some data
+            if any(row_dict.get(col, "") for col in columns):
+                rows.append(row_dict)
+
+        wb.close()
+    except Exception as e:
+        logger.warning(f"Failed to read sheet data: {e}")
+
+    return rows
+
+
+async def _identify_columns(workbook_data, columns: dict = None) -> ColumnSuggestions:
+    """Identify likely question/answer columns using Azure AI LLM.
+
+    Uses ChatAgent to ask the LLM to identify which columns contain questions,
+    responses, and documentation based on the column headers.
+    """
+    if not workbook_data.sheets:
+        return ColumnSuggestions(
+            sheet_name="Sheet1",
+            question_column=None,
+            context_column=None,
+            answer_column=None,
+            documentation_column=None,
+            confidence=0.0,
+            auto_map_success=False
+        )
+
+    sheet = workbook_data.sheets[0]
+    sheet_name = sheet.sheet_name
+
+    # Get actual column names from headers if available
+    sheet_columns = columns.get(sheet_name, []) if columns else []
+
+    if not sheet_columns:
+        return ColumnSuggestions(
+            sheet_name=sheet_name,
+            question_column=None,
+            context_column=None,
+            answer_column=None,
+            documentation_column=None,
+            confidence=0.0,
+            auto_map_success=False
+        )
+
+    # Use Azure AI LLM for column identification
+    try:
+        from utils.azure_auth import get_azure_client
+        from agent_framework import ChatAgent
+        import json
+        import re
+
+        azure_client = await get_azure_client()
+
+        # Create a ChatAgent for column identification
+        agent = ChatAgent(
+            chat_client=azure_client,
+            name="Column Identifier",
+            instructions="""You are a column identification expert. Your job is to analyze spreadsheet column headers and identify which columns contain:
+1. Questions - the column with questions to be answered
+2. Responses/Answers - the column where answers should be written
+3. Documentation - the column for documentation links (optional)
+
+Always respond with valid JSON only. No other text."""
+        )
+
+        # Build the prompt
+        column_list = ', '.join([f'Column {i}: "{col}"' for i, col in enumerate(sheet_columns)])
+        prompt = f"""Analyze these spreadsheet column headers and identify which columns are for questions, responses, and documentation:
+
+{column_list}
+
+Respond ONLY with valid JSON in this exact format:
+{{"question": <column_index>, "response": <column_index>, "documentation": <column_index_or_null>}}
+
+Use 0-based column indices. If a column cannot be identified, use null.
+For example, if "Question" is column 3, "Response" is column 4, and "Documentation" is column 5:
+{{"question": 3, "response": 4, "documentation": 5}}"""
+
+        logger.info(f"Sending column identification request to Azure AI LLM with headers: {sheet_columns}")
+
+        # Call the LLM - pass prompt directly as string
+        response = await agent.run(prompt)
+
+        # Parse the response - use .text property
+        response_text = response.text if response else ""
+        logger.info(f"LLM column identification response: {response_text}")
+
+        # Extract JSON from response
+        json_match = re.search(r'\{[^}]+\}', response_text)
+        if json_match:
+            result = json.loads(json_match.group(0))
+            logger.info(f"Parsed column identification result: {result}")
+
+            # Convert indices to column names
+            question_col = sheet_columns[result['question']] if result.get('question') is not None and result['question'] < len(sheet_columns) else None
+            answer_col = sheet_columns[result['response']] if result.get('response') is not None and result['response'] < len(sheet_columns) else None
+            doc_col = sheet_columns[result['documentation']] if result.get('documentation') is not None and result['documentation'] < len(sheet_columns) else None
+
+            # LLM identification has high confidence
+            confidence = 1.0 if question_col and answer_col else 0.5
+            auto_map_success = question_col is not None and answer_col is not None
+
+            logger.info(f"LLM identified columns - Question: {question_col}, Answer: {answer_col}, Documentation: {doc_col}")
+
+            return ColumnSuggestions(
+                sheet_name=sheet_name,
+                question_column=question_col,
+                context_column=None,
+                answer_column=answer_col,
+                documentation_column=doc_col,
+                confidence=confidence,
+                auto_map_success=auto_map_success
+            )
+        else:
+            logger.warning(f"Could not parse JSON from LLM response: {response_text}")
+
+    except Exception as e:
+        logger.error(f"Azure AI LLM column identification failed: {e}", exc_info=True)
+
+    # Return failure - do NOT fall back to heuristics per user request
+    logger.warning("LLM column identification failed, returning no suggestions")
+    return ColumnSuggestions(
+        sheet_name=sheet_name,
+        question_column=None,
+        context_column=None,
+        answer_column=None,
+        confidence=0.0,
+        auto_map_success=False
+    )
+
+
+def _identify_columns_heuristic(workbook_data, columns: dict = None) -> ColumnSuggestions:
+    """Fallback heuristic-based column identification."""
+    if not workbook_data.sheets:
+        return ColumnSuggestions(
+            sheet_name="Sheet1",
+            question_column=None,
+            context_column=None,
+            answer_column=None,
+            documentation_column=None,
+            confidence=0.0,
+            auto_map_success=False
+        )
+
+    sheet = workbook_data.sheets[0]
+    sheet_name = sheet.sheet_name
+
+    # Get actual column names from headers if available
+    sheet_columns = columns.get(sheet_name, []) if columns else []
+
+    # Question column patterns - ordered by priority (most specific first)
+    # Single-letter patterns only match exactly, not as substrings
+    question_patterns = [
+        ('question', False),  # (pattern, exact_only)
+        ('query', False),
+        ('ask', False),
+        ('q', True),  # 'q' only matches exact "q" column name
+    ]
+    # Answer/Response column patterns - ordered by priority
+    answer_patterns = [
+        ('response', False),
+        ('answer', False),
+        ('reply', False),
+        # Note: 'a' removed - too broad, matches "Status", "Data", etc.
+    ]
+    # Documentation column patterns (optional)
+    doc_patterns = ['documentation', 'docs', 'sources', 'references', 'links']
+
+    question_col = None
+    answer_col = None
+    context_col = None
+    question_confidence = 0.0
+    answer_confidence = 0.0
+
+    for col in sheet_columns:
+        col_lower = col.lower().strip()
+
+        # Check for question column
+        if not question_col:
+            for pattern, exact_only in question_patterns:
+                if col_lower == pattern:
+                    question_col = col
+                    question_confidence = 1.0  # Exact match
+                    break
+                elif not exact_only and pattern in col_lower:
+                    question_col = col
+                    question_confidence = 0.8  # Partial match
+                    break
+
+        # Check for answer column
+        if not answer_col:
+            for pattern, exact_only in answer_patterns:
+                if col_lower == pattern:
+                    answer_col = col
+                    answer_confidence = 1.0  # Exact match
+                    break
+                elif not exact_only and pattern in col_lower:
+                    answer_col = col
+                    answer_confidence = 0.8  # Partial match
+                    break
+
+        # Check for documentation/context column
+        if not context_col:
+            for pattern in doc_patterns:
+                if pattern in col_lower:
+                    context_col = col
+                    break
+
+    # Fallback to loader's identified columns if header matching failed
+    if not question_col and sheet.question_col_index is not None and sheet.question_col_index < len(sheet_columns):
+        question_col = sheet_columns[sheet.question_col_index]
+        question_confidence = 0.6
+
+    if not answer_col and sheet.response_col_index is not None and sheet.response_col_index < len(sheet_columns):
+        answer_col = sheet_columns[sheet.response_col_index]
+        answer_confidence = 0.6
+
+    # Calculate overall confidence
+    # Auto-mapping succeeds if both question and answer columns are found with high confidence
+    confidence = (question_confidence + answer_confidence) / 2
+    auto_map_success = question_col is not None and answer_col is not None and confidence >= 0.7
+
+    return ColumnSuggestions(
+        sheet_name=sheet_name,
+        question_column=question_col,
+        context_column=context_col,
+        answer_column=answer_col,
+        confidence=confidence,
+        auto_map_success=auto_map_success
+    )
+
+
+@app.post("/api/spreadsheet/process", response_model=ProcessingStartResponse, status_code=202)
+async def start_processing(request: ProcessingStartRequest, background_tasks: BackgroundTasks):
+    """Start batch processing of spreadsheet questions."""
+    session = session_manager.get_session(request.session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    if not session.workbook_data:
+        raise HTTPException(status_code=400, detail="No spreadsheet loaded")
+
+    # Check for existing active job
+    if session.processing_job and session.processing_job.status == JobStatus.RUNNING:
+        raise HTTPException(status_code=409, detail="Processing job already running")
+
+    # Find the sheet
+    target_sheet = None
+    for sheet in session.workbook_data.sheets:
+        if sheet.sheet_name == request.sheet_name:
+            target_sheet = sheet
+            break
+
+    if not target_sheet:
+        raise HTTPException(status_code=400, detail=f"Sheet '{request.sheet_name}' not found")
+
+    # Calculate rows to process
+    total_rows = len(target_sheet.questions)
+    start_row = request.start_row
+    end_row = request.end_row if request.end_row is not None else total_rows
+
+    if start_row >= total_rows:
+        raise HTTPException(status_code=422, detail="start_row exceeds available rows")
+
+    # Count actual non-empty questions in the range
+    actual_end = min(end_row, total_rows)
+    rows_to_process = sum(
+        1 for idx in range(start_row, actual_end)
+        if target_sheet.questions[idx] and target_sheet.questions[idx].strip()
+    )
+
+    if rows_to_process == 0:
+        raise HTTPException(status_code=422, detail="No questions found in the selected range")
+
+    # Create processing job
+    job = ProcessingJob(
+        session_id=request.session_id,
+        total_rows=rows_to_process,
+        processed_rows=0,
+        current_row=start_row
+    )
+    session_manager.set_processing_job(request.session_id, job)
+
+    # Start background processing
+    background_tasks.add_task(
+        _process_spreadsheet,
+        request.session_id,
+        target_sheet,
+        request.question_column,
+        request.context_column,
+        request.answer_column,
+        start_row,
+        end_row
+    )
+
+    return ProcessingStartResponse(
+        job_id=job.job_id,
+        session_id=request.session_id,
+        status=job.status,
+        total_rows=rows_to_process,
+        processed_rows=0,
+        started_at=job.started_at.isoformat()
+    )
+
+
+async def _run_spreadsheet_workers(
+    session_id: str,
+    session,
+    job,
+    sheet,
+    coordinators: list,
+    questions_to_process: list,
+    total_questions: int,
+    state_lock,
+    default_context: str,
+    char_limit: int
+) -> int:
+    """Run parallel workers to process spreadsheet questions.
+
+    Args:
+        session_id: Session identifier
+        session: Session data object
+        job: Processing job object
+        sheet: Sheet data to process
+        coordinators: List of agent coordinators
+        questions_to_process: List of (row_idx, question_text) tuples
+        total_questions: Total number of questions
+        state_lock: Asyncio lock for thread-safe state updates
+        default_context: Context for questions
+        char_limit: Character limit for answers
+
+    Returns:
+        Number of completed rows
+    """
+    from utils.data_types import Question
+
+    completed_rows = 0
+    cancelled = False
+
+    # Create work queue
+    work_queue = asyncio.Queue()
+    for item in questions_to_process:
+        await work_queue.put(item)
+
+    async def worker(agent_set_id: int, coordinator):
+        """Worker for a single agent set."""
+        nonlocal completed_rows, cancelled
+        worker_processed = 0
+        worker_failed = 0
+
+        logger.info(f"Agent Set {agent_set_id} starting")
+
+        while not cancelled:
+            # Check if job was cancelled
+            current_job = session_manager.get_processing_job(session_id)
+            if not current_job or current_job.status in (JobStatus.CANCELLED, JobStatus.ERROR):
+                cancelled = True
+                break
+
+            try:
+                # Get next question from queue (with timeout)
+                try:
+                    row_idx, question_text = await asyncio.wait_for(
+                        work_queue.get(),
+                        timeout=0.1
+                    )
+                except asyncio.TimeoutError:
+                    # No more work available
+                    break
+
+                logger.info(f"Agent Set {agent_set_id} processing row {row_idx}")
+
+                # Send ROW_STARTED event
+                await sse_manager.send_row_started(session_id, row_idx, total_questions)
+
+                try:
+                    # Create question and process
+                    question = Question(
+                        text=question_text,
+                        context=default_context,
+                        char_limit=char_limit
+                    )
+
+                    reasoning_parts = []
+                    last_agent = [None]  # Use list to allow modification in nested function
+
+                    async def send_agent_progress_safe(sid, row, agent, msg):
+                        """Safe wrapper to send agent progress with error handling."""
+                        try:
+                            result = await sse_manager.send_agent_progress(sid, row, agent, msg)
+                            logger.debug(f"AGENT_PROGRESS sent for row {row}, agent={agent}, result={result}")
+                        except Exception as e:
+                            logger.error(f"Failed to send AGENT_PROGRESS: {e}")
+
+                    def progress_callback(agent: str, message: str, progress: float):
+                        logger.info(f"[Set {agent_set_id}][Row {row_idx}][{agent}] {message}")
+                        # Send agent progress SSE event if agent changed
+                        if agent != last_agent[0] and agent not in ("workflow", "batch"):
+                            last_agent[0] = agent
+                            logger.info(f"Sending AGENT_PROGRESS SSE for row {row_idx}, agent={agent}")
+                            # Schedule async SSE send
+                            asyncio.create_task(
+                                send_agent_progress_safe(session_id, row_idx, agent, message)
+                            )
+
+                    def reasoning_callback(text: str):
+                        reasoning_parts.append(text)
+
+                    result = await coordinator.process_question(
+                        question,
+                        progress_callback=progress_callback,
+                        reasoning_callback=reasoning_callback
+                    )
+
+                    # Get answer
+                    answer = result.answer.content if result.answer else "Error generating answer"
+
+                    # Get documentation links (newline-separated)
+                    documentation = None
+                    if result.answer and hasattr(result.answer, 'documentation_links') and result.answer.documentation_links:
+                        # Handle both string lists and DocumentationLink objects
+                        links = result.answer.documentation_links
+                        if links and isinstance(links[0], str):
+                            documentation = '\n'.join(links)
+                        else:
+                            documentation = '\n'.join(str(link.url) if hasattr(link, 'url') else str(link) for link in links)
+
+                    # Update sheet data (thread-safe)
+                    async with state_lock:
+                        if hasattr(sheet, 'mark_completed'):
+                            sheet.mark_completed(row_idx, answer, documentation)
+                        else:
+                            sheet.answers[row_idx] = answer
+                            if documentation and hasattr(sheet, 'documentation'):
+                                sheet.documentation[row_idx] = documentation
+
+                        # Increment completed rows
+                        completed_rows += 1
+                        current_completed = completed_rows
+
+                        # Update job progress
+                        session_manager.update_job_progress(session_id, current_completed, row_idx + 1)
+                        job.processed_rows = current_completed
+
+                    # Send answer via SSE
+                    logger.info(f"Sending ANSWER SSE for row {row_idx}")
+                    sent = await sse_manager.send_answer(
+                        session_id,
+                        row_idx,
+                        question_text,
+                        answer,
+                        _format_reasoning(result, reasoning_parts),
+                        documentation
+                    )
+                    logger.info(f"ANSWER SSE sent={sent} for row {row_idx}")
+
+                    # Send progress update
+                    await sse_manager.send_progress(session_id, current_completed, total_questions)
+
+                    worker_processed += 1
+                    logger.info(f"Agent Set {agent_set_id} completed row {row_idx}")
+
+                except Exception as e:
+                    logger.error(f"Agent Set {agent_set_id} error on row {row_idx}: {e}")
+                    await sse_manager.send_error(session_id, str(e), row_idx)
+
+                    # Still count as processed (with error)
+                    async with state_lock:
+                        completed_rows += 1
+                        current_completed = completed_rows
+                        session_manager.update_job_progress(session_id, current_completed, row_idx + 1)
+                        job.processed_rows = current_completed
+
+                    await sse_manager.send_progress(session_id, current_completed, total_questions)
+                    worker_failed += 1
+
+            except Exception as e:
+                logger.error(f"Agent Set {agent_set_id} worker error: {e}", exc_info=True)
+                break
+
+        logger.info(f"Agent Set {agent_set_id} finished: {worker_processed} processed, {worker_failed} failed")
+        return worker_processed, worker_failed
+
+    # Run workers in parallel
+    NUM_AGENT_SETS = len(coordinators)
+    worker_tasks = [
+        asyncio.create_task(worker(i + 1, coordinators[i]))
+        for i in range(NUM_AGENT_SETS)
+    ]
+
+    # Wait for all workers to complete
+    results = await asyncio.gather(*worker_tasks, return_exceptions=True)
+
+    # Log results
+    for i, result in enumerate(results):
+        if isinstance(result, Exception):
+            logger.error(f"Agent Set {i + 1} failed with exception: {result}")
+        else:
+            processed, failed = result
+            logger.info(f"Agent Set {i + 1} result: {processed} processed, {failed} failed")
+
+    # Cleanup all coordinators
+    for i, coordinator in enumerate(coordinators):
+        try:
+            await coordinator.cleanup_agents()
+            logger.info(f"Cleaned up coordinator {i + 1}")
+        except Exception as e:
+            logger.error(f"Error cleaning up coordinator {i + 1}: {e}")
+
+    return completed_rows
+
+
+async def _process_spreadsheet(
+    session_id: str,
+    sheet,
+    question_column: str,
+    context_column: Optional[str],
+    answer_column: str,
+    start_row: int,
+    end_row: int
+):
+    """Background task for spreadsheet processing with 3 parallel agent sets."""
+    start_time = time.time()
+
+    try:
+        from utils.data_types import Question
+
+        session = session_manager.get_session(session_id)
+
+        if not session:
+            return
+
+        job = session.processing_job
+        if not job:
+            return
+
+        # Get context from session config
+        default_context = session.config.context
+        char_limit = session.config.char_limit
+
+        # Calculate actual number of non-empty questions in range
+        actual_end = min(end_row, len(sheet.questions))
+
+        # Build list of (row_idx, question_text) for non-empty questions
+        questions_to_process = [
+            (idx, sheet.questions[idx])
+            for idx in range(start_row, actual_end)
+            if sheet.questions[idx] and sheet.questions[idx].strip()
+        ]
+        total_questions = len(questions_to_process)
+
+        if total_questions == 0:
+            logger.warning("No questions to process")
+            session_manager.update_job_status(session_id, JobStatus.COMPLETED)
+            await sse_manager.send_complete(session_id, 0, 0.0)
+            return
+
+        # Shared state for parallel processing (thread-safe with asyncio.Lock)
+        state_lock = asyncio.Lock()
+        completed_rows = 0
+        cancelled = False
+
+        # Create agent coordinators (mock or real based on mode)
+        NUM_AGENT_SETS = 3
+        coordinators = []
+
+        if _mock_agents_mode:
+            # Use mock agents for testing
+            from .mock_agents import create_mock_agent_coordinator
+            for i in range(NUM_AGENT_SETS):
+                coordinator = await create_mock_agent_coordinator()
+                coordinators.append(coordinator)
+                logger.info(f"Created mock agent coordinator {i + 1}/{NUM_AGENT_SETS}")
+
+            # Process with mock agents (no context manager needed)
+            completed_rows = await _run_spreadsheet_workers(
+                session_id, session, job, sheet, coordinators,
+                questions_to_process, total_questions, state_lock,
+                default_context, char_limit
+            )
+
+            # Mark complete
+            duration = time.time() - start_time
+            session_manager.update_job_status(session_id, JobStatus.COMPLETED)
+            total_sheets = len(session.workbook_data.sheets) if session.workbook_data else 1
+            await sse_manager.send_complete(session_id, completed_rows, duration, total_sheets)
+            return
+
+        # Use real agents with Azure authentication
+        from agents.workflow_manager import create_agent_coordinator
+        from utils.azure_auth import foundry_agent_session, get_project_client
+        from utils.config import config_manager
+
+        async with foundry_agent_session() as azure_client:
+            project_client = await get_project_client()
+
+            for i in range(NUM_AGENT_SETS):
+                coordinator = await create_agent_coordinator(
+                    azure_client=azure_client,
+                    bing_connection_id=config_manager.get_bing_connection_id(),
+                    browser_automation_connection_id=config_manager.get_browser_automation_connection_id(),
+                    project_client=project_client
+                )
+                coordinators.append(coordinator)
+                logger.info(f"Created agent coordinator {i + 1}/{NUM_AGENT_SETS}")
+
+            # Process with real agents using shared worker logic
+            completed_rows = await _run_spreadsheet_workers(
+                session_id, session, job, sheet, coordinators,
+                questions_to_process, total_questions, state_lock,
+                default_context, char_limit
+            )
+
+        # Mark complete
+        duration = time.time() - start_time
+        session_manager.update_job_status(session_id, JobStatus.COMPLETED)
+
+        # Get sheet count for completion message
+        total_sheets = len(session.workbook_data.sheets) if session.workbook_data else 1
+
+        await sse_manager.send_complete(session_id, completed_rows, duration, total_sheets)
+
+    except Exception as e:
+        logger.error(f"Spreadsheet processing error: {e}", exc_info=True)
+        session_manager.update_job_status(session_id, JobStatus.ERROR, str(e))
+        await sse_manager.send_error(session_id, str(e))
+
+
+@app.get("/api/spreadsheet/status/{session_id}", response_model=ProcessingStatusResponse)
+async def get_processing_status(session_id: str):
+    """Get current processing status."""
+    session = session_manager.get_session(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    job = session.processing_job
+    if not job:
+        return ProcessingStatusResponse(
+            status="NO_JOB",
+            message="No processing job active for this session"
+        )
+
+    # Calculate estimated time remaining
+    estimated_remaining = None
+    if job.processed_rows > 0 and job.status == JobStatus.RUNNING:
+        elapsed = (datetime.now() - job.started_at).total_seconds()
+        avg_per_row = elapsed / job.processed_rows
+        remaining_rows = job.total_rows - job.processed_rows
+        estimated_remaining = avg_per_row * remaining_rows
+
+    return ProcessingStatusResponse(
+        job_id=job.job_id,
+        status=job.status.value,
+        processed_rows=job.processed_rows,
+        total_rows=job.total_rows,
+        current_row=job.current_row,
+        estimated_time_remaining_seconds=round(estimated_remaining, 1) if estimated_remaining else None,
+        started_at=job.started_at.isoformat(),
+        completed_at=job.completed_at.isoformat() if job.completed_at else None
+    )
+
+
+@app.get("/api/spreadsheet/data/{session_id}/{sheet_name}")
+async def get_sheet_data(session_id: str, sheet_name: str):
+    """Get current data for a specific sheet including all answers and documentation."""
+    session = session_manager.get_session(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    if not session.workbook_data:
+        raise HTTPException(status_code=400, detail="No workbook data loaded")
+
+    # Find the sheet
+    sheet_data = None
+    for sheet in session.workbook_data.sheets:
+        if sheet.sheet_name == sheet_name:
+            sheet_data = sheet
+            break
+
+    if not sheet_data:
+        raise HTTPException(status_code=404, detail=f"Sheet '{sheet_name}' not found")
+
+    # Return the sheet data with answers and documentation
+    return {
+        "sheet_name": sheet_data.sheet_name,
+        "answers": sheet_data.answers,
+        "documentation": sheet_data.documentation if hasattr(sheet_data, 'documentation') else [None] * len(sheet_data.answers),
+        "cell_states": [state.value for state in sheet_data.cell_states]
+    }
+
+
+@app.post("/api/spreadsheet/stop", response_model=StopProcessingResponse)
+async def stop_processing(request: StopProcessingRequest):
+    """Stop the current processing job."""
+    session = session_manager.get_session(request.session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    job = session.processing_job
+    if not job:
+        raise HTTPException(status_code=400, detail="No active job to stop")
+
+    if job.status != JobStatus.RUNNING:
+        raise HTTPException(status_code=400, detail=f"Job is not running (status: {job.status.value})")
+
+    # Mark as cancelled
+    session_manager.update_job_status(request.session_id, JobStatus.CANCELLED)
+
+    # Send status via SSE
+    await sse_manager.send_status(request.session_id, "CANCELLED", job.job_id)
+
+    return StopProcessingResponse(
+        job_id=job.job_id,
+        status=JobStatus.CANCELLED,
+        processed_rows=job.processed_rows,
+        total_rows=job.total_rows
+    )
+
+
+@app.get("/api/spreadsheet/download/{session_id}")
+async def download_spreadsheet(session_id: str):
+    """Download the processed spreadsheet with answers."""
+    session = session_manager.get_session(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    if not session.temp_file_path or not os.path.exists(session.temp_file_path):
+        raise HTTPException(status_code=400, detail="No spreadsheet available for download")
+
+    if not session.workbook_data:
+        raise HTTPException(status_code=400, detail="No workbook data available")
+
+    # Write answers back to the Excel file
+    try:
+        # Create a new temp file for the download with answers
+        download_file = tempfile.NamedTemporaryFile(delete=False, suffix='.xlsx')
+        download_path = download_file.name
+        download_file.close()
+
+        # Use ExcelLoader to save workbook with answers to the new temp file
+        excel_loader = ExcelLoader()
+        excel_loader.save_workbook(session.workbook_data, output_path=download_path)
+
+        logger.info(f"Saved spreadsheet with answers to {download_path}")
+
+        return FileResponse(
+            download_path,
+            media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            filename="questionnaire_answered.xlsx"
+        )
+    except Exception as e:
+        logger.error(f"Error saving workbook with answers: {e}")
+        raise HTTPException(status_code=500, detail=f"Error preparing download: {str(e)}")
+
+
+# ============================================================================
+# Server-Sent Events
+# ============================================================================
+
+@app.get("/api/sse/{session_id}")
+async def sse_stream(session_id: str):
+    """Server-Sent Events stream for real-time updates."""
+    if not session_manager.session_exists(session_id):
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    return StreamingResponse(
+        sse_manager.stream_events(session_id),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no"
+        }
+    )
+
+
+# ============================================================================
+# Server Runner
+# ============================================================================
+
+def run_server(host: str = "127.0.0.1", port: int = 8080, log_level: str = "info"):
+    """Run the web server."""
+    import uvicorn
+    uvicorn.run(app, host=host, port=port, log_level=log_level)
+
+
+def cleanup():
+    """Clean up resources on shutdown."""
+    session_manager.cleanup_all()
+    sse_manager.cleanup_all()
diff --git a/src/web/mock_agents.py b/src/web/mock_agents.py
new file mode 100644
index 0000000..9899bfa
--- /dev/null
+++ b/src/web/mock_agents.py
@@ -0,0 +1,200 @@
+"""Mock agent coordinator for web server testing.
+
+Provides fast mock responses for testing the web interface without requiring
+Azure AI services or real agent processing.
+"""
+
+import asyncio
+import logging
+import random
+import time
+from typing import Callable, List, Optional
+
+from utils.data_types import (
+    Question, Answer, ProcessingResult, AgentStep, AgentType,
+    ValidationStatus, StepStatus
+)
+
+logger = logging.getLogger(__name__)
+
+
+# Sample documentation links for mock responses
+MOCK_DOCUMENTATION_LINKS = [
+    "https://docs.microsoft.com/azure/ai-services/openai/",
+    "https://learn.microsoft.com/azure/cognitive-services/",
+    "https://docs.microsoft.com/azure/machine-learning/",
+    "https://docs.microsoft.com/azure/ai-foundry/",
+    "https://learn.microsoft.com/azure/architecture/ai-ml/",
+]
+
+# Sample mock answers with documentation
+MOCK_ANSWERS = [
+    {
+        "content": "Azure AI services provide comprehensive machine learning and artificial intelligence capabilities. The platform offers pre-built AI models for vision, speech, language, and decision-making tasks. Azure OpenAI Service provides access to advanced language models like GPT-4 for text generation, code completion, and natural language understanding.",
+        "links": [
+            "https://docs.microsoft.com/azure/ai-services/openai/",
+            "https://docs.microsoft.com/azure/cognitive-services/"
+        ]
+    },
+    {
+        "content": "Microsoft Azure offers a wide range of cloud computing services including virtual machines, storage, networking, and AI/ML capabilities. Azure AI Foundry provides a unified platform for building, training, and deploying AI models. The platform supports both managed AI services and custom model development.",
+        "links": [
+            "https://docs.microsoft.com/azure/ai-foundry/",
+            "https://learn.microsoft.com/azure/machine-learning/"
+        ]
+    },
+    {
+        "content": "Azure Cognitive Services provides AI models as APIs for vision, speech, language, and search capabilities. These pre-built models can be integrated into applications without requiring machine learning expertise. Services include Computer Vision, Speech Services, Language Understanding (LUIS), and Azure Search.",
+        "links": [
+            "https://docs.microsoft.com/azure/cognitive-services/",
+            "https://learn.microsoft.com/azure/architecture/ai-ml/"
+        ]
+    },
+    {
+        "content": "Azure Machine Learning is a cloud-based service for training, deploying, and managing machine learning models at scale. It supports automated ML, MLOps practices, and integration with popular frameworks like TensorFlow and PyTorch. The service provides tools for both no-code and code-first approaches.",
+        "links": [
+            "https://docs.microsoft.com/azure/machine-learning/",
+            "https://docs.microsoft.com/azure/ai-foundry/"
+        ]
+    },
+    {
+        "content": "Azure AI Document Intelligence (formerly Form Recognizer) uses AI to extract text, key-value pairs, tables, and structures from documents. It supports various document types including invoices, receipts, and custom forms. The service can be customized for specific document layouts.",
+        "links": [
+            "https://docs.microsoft.com/azure/ai-services/document-intelligence/",
+            "https://learn.microsoft.com/azure/cognitive-services/"
+        ]
+    }
+]
+
+
+class MockAgentCoordinator:
+    """Mock agent coordinator that returns fast test responses.
+
+    Simulates the multi-agent workflow with realistic delays and
+    provides meaningful mock responses with documentation links.
+    """
+
+    def __init__(self):
+        """Initialize the mock agent coordinator."""
+        self.executors_created = True  # Already "created"
+        self._response_index = 0
+        logger.info("MockAgentCoordinator initialized")
+
+    async def create_agents(self) -> None:
+        """Mock agent creation - no-op since already initialized."""
+        logger.info("Mock agents already created")
+        self.executors_created = True
+
+    async def process_question(
+        self,
+        question: Question,
+        progress_callback: Callable[[str, str, float], None],
+        reasoning_callback: Optional[Callable[[str], None]] = None,
+        agent_conversation_callback: Optional[Callable] = None
+    ) -> ProcessingResult:
+        """Process a question using mock agents.
+
+        Simulates the multi-agent workflow with realistic delays (0.1-0.5s total)
+        and returns meaningful mock responses with documentation links.
+
+        Args:
+            question: Question to process
+            progress_callback: Progress update callback
+            reasoning_callback: Reasoning update callback
+            agent_conversation_callback: Agent conversation callback
+
+        Returns:
+            ProcessingResult with mock answer
+        """
+        start_time = time.time()
+        agent_steps = []
+
+        # Simulate Question Answerer agent
+        progress_callback("question_answerer", "Searching for relevant information...", 0.1)
+        if reasoning_callback:
+            reasoning_callback("Question Answerer: Analyzing question and searching web...")
+        await asyncio.sleep(random.uniform(0.05, 0.15))
+
+        agent_steps.append(AgentStep(
+            agent_name=AgentType.QUESTION_ANSWERER,
+            input_data=question.text,
+            output_data="Generated initial answer",
+            execution_time=0.1,
+            status=StepStatus.SUCCESS
+        ))
+
+        # Simulate Answer Checker agent
+        progress_callback("answer_checker", "Validating answer accuracy...", 0.5)
+        if reasoning_callback:
+            reasoning_callback("Answer Checker: Verifying factual accuracy...")
+        await asyncio.sleep(random.uniform(0.05, 0.15))
+
+        agent_steps.append(AgentStep(
+            agent_name=AgentType.ANSWER_CHECKER,
+            input_data="Initial answer",
+            output_data="APPROVED: Answer is accurate",
+            execution_time=0.1,
+            status=StepStatus.SUCCESS
+        ))
+
+        # Simulate Link Checker agent
+        progress_callback("link_checker", "Verifying documentation links...", 0.8)
+        if reasoning_callback:
+            reasoning_callback("Link Checker: Validating all URLs...")
+        await asyncio.sleep(random.uniform(0.05, 0.2))
+
+        agent_steps.append(AgentStep(
+            agent_name=AgentType.LINK_CHECKER,
+            input_data="Answer with links",
+            output_data="LINKS_VALID: All links verified",
+            execution_time=0.1,
+            status=StepStatus.SUCCESS
+        ))
+
+        # Get mock answer (rotate through available answers)
+        mock_data = MOCK_ANSWERS[self._response_index % len(MOCK_ANSWERS)]
+        self._response_index += 1
+
+        # Create documentation links as strings (the expected format for documentation_links in Answer)
+        doc_links = mock_data["links"]
+
+        # Create answer - documentation_links should be a list of strings (URLs)
+        answer = Answer(
+            content=mock_data["content"],
+            sources=mock_data["links"],
+            agent_reasoning=agent_steps,
+            validation_status=ValidationStatus.APPROVED,
+            retry_count=0,
+            documentation_links=doc_links
+        )
+
+        processing_time = time.time() - start_time
+
+        progress_callback("workflow", "Processing complete!", 1.0)
+        if reasoning_callback:
+            reasoning_callback(f"Completed in {processing_time:.2f}s")
+
+        logger.info(f"Mock question processed in {processing_time:.2f}s")
+
+        return ProcessingResult(
+            success=True,
+            answer=answer,
+            processing_time=processing_time,
+            questions_processed=1,
+            questions_failed=0
+        )
+
+    async def cleanup_agents(self) -> None:
+        """Mock cleanup - no-op."""
+        logger.info("Mock agents cleanup (no-op)")
+
+
+async def create_mock_agent_coordinator() -> MockAgentCoordinator:
+    """Create a mock agent coordinator for testing.
+
+    Returns:
+        MockAgentCoordinator instance ready for use
+    """
+    coordinator = MockAgentCoordinator()
+    await coordinator.create_agents()
+    return coordinator
diff --git a/src/web/models.py b/src/web/models.py
new file mode 100644
index 0000000..d23457e
--- /dev/null
+++ b/src/web/models.py
@@ -0,0 +1,256 @@
+"""Pydantic models for the web interface API.
+
+Defines request/response schemas and data entities for the web module.
+"""
+
+from datetime import datetime
+from enum import Enum
+from typing import Optional, List, Dict, Any
+from pydantic import BaseModel, Field, field_validator
+import uuid
+
+
+# ============================================================================
+# Enums
+# ============================================================================
+
+class JobStatus(str, Enum):
+    """Processing job state enumeration."""
+    RUNNING = "RUNNING"
+    PAUSED = "PAUSED"
+    COMPLETED = "COMPLETED"
+    CANCELLED = "CANCELLED"
+    ERROR = "ERROR"
+
+
+class SSEMessageType(str, Enum):
+    """Server-Sent Event message type discriminator."""
+    PROGRESS = "PROGRESS"
+    ANSWER = "ANSWER"
+    ERROR = "ERROR"
+    COMPLETE = "COMPLETE"
+    STATUS = "STATUS"
+    ROW_STARTED = "ROW_STARTED"  # Sent when a row begins processing
+    AGENT_PROGRESS = "AGENT_PROGRESS"  # Sent when agent changes within a row
+
+
+# ============================================================================
+# Configuration Models
+# ============================================================================
+
+class SessionConfig(BaseModel):
+    """User-configurable settings for question processing."""
+    context: str = Field(default="Microsoft Azure AI", min_length=1)
+    char_limit: int = Field(default=2000, ge=100, le=10000)
+
+
+# ============================================================================
+# Session Models
+# ============================================================================
+
+class WebSession(BaseModel):
+    """Represents an active user session in the web browser."""
+    session_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    created_at: datetime = Field(default_factory=datetime.now)
+    config: SessionConfig = Field(default_factory=SessionConfig)
+    has_workbook: bool = False
+    temp_file_path: Optional[str] = None
+
+    class Config:
+        from_attributes = True
+
+
+class SessionCreateResponse(BaseModel):
+    """Response after creating a new session."""
+    session_id: str
+    created_at: str
+    config: SessionConfig
+
+
+class SessionGetResponse(BaseModel):
+    """Response for getting session state."""
+    session_id: str
+    created_at: str
+    config: SessionConfig
+    has_workbook: bool
+    processing_status: Optional[str] = None
+
+
+class SessionConfigUpdate(BaseModel):
+    """Request to update session configuration."""
+    context: Optional[str] = Field(default=None, min_length=1)
+    char_limit: Optional[int] = Field(default=None, ge=100, le=10000)
+
+
+class SessionConfigUpdateResponse(BaseModel):
+    """Response after updating session config."""
+    session_id: str
+    config: SessionConfig
+
+
+# ============================================================================
+# Processing Job Models
+# ============================================================================
+
+class ProcessingJob(BaseModel):
+    """Represents an active spreadsheet batch processing task."""
+    job_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    session_id: str
+    status: JobStatus = JobStatus.RUNNING
+    started_at: datetime = Field(default_factory=datetime.now)
+    completed_at: Optional[datetime] = None
+    total_rows: int = Field(gt=0)
+    processed_rows: int = Field(default=0, ge=0)
+    current_row: Optional[int] = None
+    error: Optional[str] = None
+
+    @field_validator('processed_rows')
+    @classmethod
+    def validate_processed_rows(cls, v, info):
+        if 'total_rows' in info.data and v > info.data['total_rows']:
+            raise ValueError('processed_rows cannot exceed total_rows')
+        return v
+
+
+# ============================================================================
+# SSE Models
+# ============================================================================
+
+class SSEMessage(BaseModel):
+    """Server-Sent Event message structure for real-time updates."""
+    type: SSEMessageType
+    timestamp: datetime = Field(default_factory=datetime.now)
+    data: Dict[str, Any]
+
+    def to_sse_string(self) -> str:
+        """Convert to SSE wire format."""
+        import json
+        payload = {
+            "type": self.type.value,
+            "timestamp": self.timestamp.isoformat(),
+            "data": self.data
+        }
+        return f"data: {json.dumps(payload)}\n\n"
+
+
+# ============================================================================
+# Question Processing Models
+# ============================================================================
+
+class QuestionRequest(BaseModel):
+    """API request for single question processing."""
+    session_id: str
+    question: str = Field(min_length=5)
+    context: str = Field(default="Microsoft Azure AI", min_length=1)
+    char_limit: int = Field(default=2000, ge=100, le=10000)
+
+
+class QuestionResponse(BaseModel):
+    """API response for single question processing."""
+    answer: str
+    reasoning: str
+    processing_time_seconds: float
+    links_checked: int
+
+
+# ============================================================================
+# Spreadsheet Models
+# ============================================================================
+
+class ColumnSuggestions(BaseModel):
+    """Suggested column mappings from automatic analysis."""
+    sheet_name: str
+    question_column: Optional[str] = None
+    context_column: Optional[str] = None
+    answer_column: Optional[str] = None
+    documentation_column: Optional[str] = None
+    confidence: float = Field(ge=0.0, le=1.0)
+    auto_map_success: bool = False
+
+
+class SpreadsheetUploadResponse(BaseModel):
+    """API response after Excel file upload."""
+    session_id: str
+    filename: str
+    sheets: List[str]
+    columns: Dict[str, List[str]]
+    suggested_columns: ColumnSuggestions
+    row_count: int
+    data: Dict[str, List[Dict[str, str]]] = {}  # Sheet name -> list of row dicts
+
+
+class ProcessingStartRequest(BaseModel):
+    """API request to start spreadsheet processing."""
+    session_id: str
+    sheet_name: str
+    question_column: str
+    context_column: Optional[str] = None
+    answer_column: str
+    start_row: int = Field(default=0, ge=0)
+    end_row: Optional[int] = None
+
+    @field_validator('end_row')
+    @classmethod
+    def validate_end_row(cls, v, info):
+        if v is not None and 'start_row' in info.data and v <= info.data['start_row']:
+            raise ValueError('end_row must be greater than start_row')
+        return v
+
+
+class ProcessingStartResponse(BaseModel):
+    """API response after starting spreadsheet processing."""
+    job_id: str
+    session_id: str
+    status: JobStatus
+    total_rows: int
+    processed_rows: int
+    started_at: str
+
+
+class ProcessingStatusResponse(BaseModel):
+    """API response for processing status queries."""
+    job_id: Optional[str] = None
+    status: str
+    processed_rows: int = 0
+    total_rows: int = 0
+    current_row: Optional[int] = None
+    estimated_time_remaining_seconds: Optional[float] = None
+    started_at: Optional[str] = None
+    completed_at: Optional[str] = None
+    message: Optional[str] = None
+
+
+class StopProcessingRequest(BaseModel):
+    """API request to stop spreadsheet processing."""
+    session_id: str
+
+
+class StopProcessingResponse(BaseModel):
+    """API response after stopping processing."""
+    job_id: str
+    status: JobStatus
+    processed_rows: int
+    total_rows: int
+
+
+# ============================================================================
+# Error Models
+# ============================================================================
+
+class WebErrorResponse(BaseModel):
+    """Standardized error response format."""
+    error: str
+    detail: Optional[str] = None
+    status_code: int
+
+
+# ============================================================================
+# Health Check Models
+# ============================================================================
+
+class HealthResponse(BaseModel):
+    """Health check response."""
+    status: str
+    timestamp: str
+    azure_auth: str
+    message: Optional[str] = None
diff --git a/src/web/session_manager.py b/src/web/session_manager.py
new file mode 100644
index 0000000..86bfe38
--- /dev/null
+++ b/src/web/session_manager.py
@@ -0,0 +1,247 @@
+"""Session management for web interface.
+
+Handles session lifecycle: creation, retrieval, updating, and cleanup.
+Sessions are stored in memory (suitable for localhost single-user deployment).
+"""
+
+import os
+import uuid
+import logging
+from datetime import datetime
+from typing import Dict, Optional, Any
+
+from .models import (
+    WebSession,
+    SessionConfig,
+    ProcessingJob,
+    JobStatus,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class SessionData:
+    """Internal session data container with mutable state."""
+
+    def __init__(self, session_id: str):
+        self.session_id = session_id
+        self.created_at = datetime.now()
+        self.config = SessionConfig()
+        self.workbook_data: Optional[Any] = None  # WorkbookData from utils.data_types
+        self.processing_job: Optional[ProcessingJob] = None
+        self.temp_file_path: Optional[str] = None
+        self.spreadsheet_rows: list = []  # Cached rows for grid display
+        self.spreadsheet_columns: Dict[str, list] = {}  # Sheet -> column names
+
+
+class SessionManager:
+    """Manages web sessions with in-memory storage."""
+
+    def __init__(self):
+        """Initialize the session manager."""
+        self._sessions: Dict[str, SessionData] = {}
+        logger.info("SessionManager initialized")
+
+    def create_session(self) -> str:
+        """Create a new session and return its ID.
+
+        Returns:
+            str: UUID of the newly created session
+        """
+        session_id = str(uuid.uuid4())
+        self._sessions[session_id] = SessionData(session_id)
+        logger.info(f"Created session: {session_id}")
+        return session_id
+
+    def get_session(self, session_id: str) -> Optional[SessionData]:
+        """Retrieve a session by ID.
+
+        Args:
+            session_id: The session UUID
+
+        Returns:
+            SessionData if found, None otherwise
+        """
+        return self._sessions.get(session_id)
+
+    def session_exists(self, session_id: str) -> bool:
+        """Check if a session exists.
+
+        Args:
+            session_id: The session UUID
+
+        Returns:
+            True if session exists
+        """
+        return session_id in self._sessions
+
+    def update_config(self, session_id: str, context: Optional[str] = None,
+                      char_limit: Optional[int] = None) -> bool:
+        """Update session configuration.
+
+        Args:
+            session_id: The session UUID
+            context: New context value (optional)
+            char_limit: New character limit (optional)
+
+        Returns:
+            True if update successful, False if session not found
+        """
+        session = self.get_session(session_id)
+        if not session:
+            return False
+
+        if context is not None:
+            session.config.context = context
+        if char_limit is not None:
+            session.config.char_limit = char_limit
+
+        logger.debug(f"Updated config for session {session_id}: context={context}, char_limit={char_limit}")
+        return True
+
+    def set_workbook(self, session_id: str, workbook_data: Any,
+                     temp_file_path: str, columns: Dict[str, list]) -> bool:
+        """Store workbook data for a session.
+
+        Args:
+            session_id: The session UUID
+            workbook_data: WorkbookData instance from utils.data_types
+            temp_file_path: Path to temporary Excel file
+            columns: Dict mapping sheet names to column name lists
+
+        Returns:
+            True if successful, False if session not found
+        """
+        session = self.get_session(session_id)
+        if not session:
+            return False
+
+        session.workbook_data = workbook_data
+        session.temp_file_path = temp_file_path
+        session.spreadsheet_columns = columns
+        logger.info(f"Set workbook for session {session_id}: {temp_file_path}")
+        return True
+
+    def set_processing_job(self, session_id: str, job: ProcessingJob) -> bool:
+        """Set the active processing job for a session.
+
+        Args:
+            session_id: The session UUID
+            job: ProcessingJob instance
+
+        Returns:
+            True if successful, False if session not found
+        """
+        session = self.get_session(session_id)
+        if not session:
+            return False
+
+        session.processing_job = job
+        logger.info(f"Set processing job {job.job_id} for session {session_id}")
+        return True
+
+    def get_processing_job(self, session_id: str) -> Optional[ProcessingJob]:
+        """Get the active processing job for a session.
+
+        Args:
+            session_id: The session UUID
+
+        Returns:
+            ProcessingJob if exists, None otherwise
+        """
+        session = self.get_session(session_id)
+        if not session:
+            return None
+        return session.processing_job
+
+    def update_job_status(self, session_id: str, status: JobStatus,
+                          error: Optional[str] = None) -> bool:
+        """Update processing job status.
+
+        Args:
+            session_id: The session UUID
+            status: New job status
+            error: Error message (for ERROR status)
+
+        Returns:
+            True if successful, False if session/job not found
+        """
+        session = self.get_session(session_id)
+        if not session or not session.processing_job:
+            return False
+
+        session.processing_job.status = status
+        if error:
+            session.processing_job.error = error
+        if status in (JobStatus.COMPLETED, JobStatus.CANCELLED, JobStatus.ERROR):
+            session.processing_job.completed_at = datetime.now()
+
+        logger.info(f"Updated job status for session {session_id}: {status}")
+        return True
+
+    def update_job_progress(self, session_id: str, processed_rows: int,
+                            current_row: Optional[int] = None) -> bool:
+        """Update processing job progress.
+
+        Args:
+            session_id: The session UUID
+            processed_rows: Number of rows completed
+            current_row: Current row being processed
+
+        Returns:
+            True if successful, False if session/job not found
+        """
+        session = self.get_session(session_id)
+        if not session or not session.processing_job:
+            return False
+
+        session.processing_job.processed_rows = processed_rows
+        session.processing_job.current_row = current_row
+        return True
+
+    def delete_session(self, session_id: str) -> bool:
+        """Delete a session and clean up resources.
+
+        Args:
+            session_id: The session UUID
+
+        Returns:
+            True if deleted, False if not found
+        """
+        session = self.get_session(session_id)
+        if not session:
+            return False
+
+        # Clean up temp file if exists
+        if session.temp_file_path and os.path.exists(session.temp_file_path):
+            try:
+                os.remove(session.temp_file_path)
+                logger.debug(f"Removed temp file: {session.temp_file_path}")
+            except OSError as e:
+                logger.warning(f"Failed to remove temp file: {e}")
+
+        del self._sessions[session_id]
+        logger.info(f"Deleted session: {session_id}")
+        return True
+
+    def cleanup_all(self) -> int:
+        """Clean up all sessions and their resources.
+
+        Returns:
+            Number of sessions cleaned up
+        """
+        count = len(self._sessions)
+        session_ids = list(self._sessions.keys())
+        for session_id in session_ids:
+            self.delete_session(session_id)
+        logger.info(f"Cleaned up {count} sessions")
+        return count
+
+    @property
+    def session_count(self) -> int:
+        """Get the current number of active sessions."""
+        return len(self._sessions)
+
+
+# Global session manager instance
+session_manager = SessionManager()
diff --git a/src/web/sse_manager.py b/src/web/sse_manager.py
new file mode 100644
index 0000000..59224a9
--- /dev/null
+++ b/src/web/sse_manager.py
@@ -0,0 +1,274 @@
+"""Server-Sent Events (SSE) manager for real-time updates.
+
+Handles per-session event queues and streaming to connected clients.
+"""
+
+import asyncio
+import json
+import logging
+from datetime import datetime
+from typing import Dict, Optional, AsyncGenerator, Any
+
+from .models import SSEMessage, SSEMessageType
+
+logger = logging.getLogger(__name__)
+
+
+class SSEManager:
+    """Manages Server-Sent Events streams for web clients."""
+
+    def __init__(self, max_queue_size: int = 100):
+        """Initialize the SSE manager.
+
+        Args:
+            max_queue_size: Maximum number of queued messages per session
+        """
+        self._queues: Dict[str, asyncio.Queue] = {}
+        self._max_queue_size = max_queue_size
+        logger.info("SSEManager initialized")
+
+    def register_session(self, session_id: str) -> asyncio.Queue:
+        """Register a session for SSE events.
+
+        Args:
+            session_id: The session UUID
+
+        Returns:
+            The event queue for this session
+        """
+        if session_id not in self._queues:
+            self._queues[session_id] = asyncio.Queue(maxsize=self._max_queue_size)
+            logger.debug(f"Registered SSE queue for session: {session_id}")
+        return self._queues[session_id]
+
+    def unregister_session(self, session_id: str) -> bool:
+        """Unregister a session's SSE queue.
+
+        Args:
+            session_id: The session UUID
+
+        Returns:
+            True if unregistered, False if not found
+        """
+        if session_id in self._queues:
+            del self._queues[session_id]
+            logger.debug(f"Unregistered SSE queue for session: {session_id}")
+            return True
+        return False
+
+    def is_registered(self, session_id: str) -> bool:
+        """Check if a session has an active SSE queue.
+
+        Args:
+            session_id: The session UUID
+
+        Returns:
+            True if session is registered
+        """
+        return session_id in self._queues
+
+    async def send_event(self, session_id: str, event_type: SSEMessageType,
+                         data: Dict[str, Any]) -> bool:
+        """Send an event to a specific session.
+
+        Args:
+            session_id: The session UUID
+            event_type: Type of SSE message
+            data: Event payload data
+
+        Returns:
+            True if event was queued, False if session not registered
+        """
+        queue = self._queues.get(session_id)
+        if not queue:
+            logger.warning(f"Attempted to send event to unregistered session: {session_id}")
+            return False
+
+        message = SSEMessage(
+            type=event_type,
+            timestamp=datetime.now(),
+            data=data
+        )
+
+        try:
+            # Use put_nowait to avoid blocking if queue is full
+            queue.put_nowait(message)
+            logger.debug(f"Sent {event_type.value} event to session {session_id}")
+            return True
+        except asyncio.QueueFull:
+            logger.warning(f"SSE queue full for session {session_id}, dropping event")
+            return False
+
+    async def send_progress(self, session_id: str, row: int, total: int) -> bool:
+        """Send a progress update event.
+
+        Args:
+            session_id: The session UUID
+            row: Current row number
+            total: Total number of rows
+
+        Returns:
+            True if event was sent
+        """
+        percentage = (row / total * 100) if total > 0 else 0
+        return await self.send_event(
+            session_id,
+            SSEMessageType.PROGRESS,
+            {"row": row, "total": total, "percentage": round(percentage, 1)}
+        )
+
+    async def send_answer(self, session_id: str, row: int, question: str,
+                          answer: str, reasoning: str = "", documentation: str = None) -> bool:
+        """Send an answer completed event.
+
+        Args:
+            session_id: The session UUID
+            row: Row number that was answered
+            question: The question text
+            answer: The generated answer
+            reasoning: Optional reasoning trace
+            documentation: Optional documentation links (newline-separated)
+
+        Returns:
+            True if event was sent
+        """
+        return await self.send_event(
+            session_id,
+            SSEMessageType.ANSWER,
+            {"row": row, "question": question, "answer": answer, "reasoning": reasoning, "documentation": documentation}
+        )
+
+    async def send_error(self, session_id: str, message: str,
+                         row: Optional[int] = None) -> bool:
+        """Send an error event.
+
+        Args:
+            session_id: The session UUID
+            message: Error message
+            row: Optional row number where error occurred
+
+        Returns:
+            True if event was sent
+        """
+        data = {"message": message}
+        if row is not None:
+            data["row"] = row
+        return await self.send_event(session_id, SSEMessageType.ERROR, data)
+
+    async def send_complete(self, session_id: str, total_processed: int,
+                            duration_seconds: float, total_sheets: int = 1) -> bool:
+        """Send a job completion event.
+
+        Args:
+            session_id: The session UUID
+            total_processed: Total rows processed
+            duration_seconds: Total processing time
+            total_sheets: Total number of sheets processed
+
+        Returns:
+            True if event was sent
+        """
+        return await self.send_event(
+            session_id,
+            SSEMessageType.COMPLETE,
+            {
+                "total_processed": total_processed,
+                "duration_seconds": round(duration_seconds, 2),
+                "total_sheets": total_sheets
+            }
+        )
+
+    async def send_status(self, session_id: str, status: str, job_id: str) -> bool:
+        """Send a status change event.
+
+        Args:
+            session_id: The session UUID
+            status: New status string
+            job_id: The job identifier
+
+        Returns:
+            True if event was sent
+        """
+        return await self.send_event(
+            session_id,
+            SSEMessageType.STATUS,
+            {"status": status, "job_id": job_id}
+        )
+
+    async def send_row_started(self, session_id: str, row: int, total: int) -> bool:
+        """Send a row started event when processing begins on a row.
+
+        Args:
+            session_id: The session UUID
+            row: Row index (0-based) that is starting
+            total: Total number of rows to process
+
+        Returns:
+            True if event was sent
+        """
+        return await self.send_event(
+            session_id,
+            SSEMessageType.ROW_STARTED,
+            {"row": row, "total": total}
+        )
+
+    async def send_agent_progress(self, session_id: str, row: int, agent_name: str,
+                                   message: str = "") -> bool:
+        """Send an agent progress event when agent changes within a row.
+
+        Args:
+            session_id: The session UUID
+            row: Row index (0-based) being processed
+            agent_name: Name of the agent currently processing (e.g., "QuestionAnswerer")
+            message: Optional progress message
+
+        Returns:
+            True if event was sent
+        """
+        return await self.send_event(
+            session_id,
+            SSEMessageType.AGENT_PROGRESS,
+            {"row": row, "agent_name": agent_name, "message": message}
+        )
+
+    async def stream_events(self, session_id: str) -> AsyncGenerator[str, None]:
+        """Async generator that yields SSE-formatted events.
+
+        This is used with FastAPI's StreamingResponse for SSE endpoints.
+
+        Args:
+            session_id: The session UUID
+
+        Yields:
+            SSE-formatted event strings
+        """
+        queue = self.register_session(session_id)
+        try:
+            while True:
+                try:
+                    # Wait for next message with timeout for keepalive
+                    message = await asyncio.wait_for(queue.get(), timeout=30.0)
+                    yield message.to_sse_string()
+                except asyncio.TimeoutError:
+                    # Send keepalive comment to prevent connection timeout
+                    yield ": keepalive\n\n"
+        except asyncio.CancelledError:
+            logger.debug(f"SSE stream cancelled for session: {session_id}")
+            raise
+        finally:
+            self.unregister_session(session_id)
+
+    def cleanup_all(self) -> int:
+        """Clean up all SSE queues.
+
+        Returns:
+            Number of queues cleaned up
+        """
+        count = len(self._queues)
+        self._queues.clear()
+        logger.info(f"Cleaned up {count} SSE queues")
+        return count
+
+
+# Global SSE manager instance
+sse_manager = SSEManager()
diff --git a/src/web/static/app.js b/src/web/static/app.js
new file mode 100644
index 0000000..5eb55a3
--- /dev/null
+++ b/src/web/static/app.js
@@ -0,0 +1,894 @@
+/**
+ * Questionnaire Agent Web Interface - Main Application JavaScript
+ */
+
+// ============================================================================
+// Global State
+// ============================================================================
+
+let sessionId = null;
+let eventSource = null;
+let isProcessing = false;
+let processingCompleted = false;  // Flag to ignore stale events after completion
+let currentJobId = null;
+let currentMode = 'question'; // 'question' or 'spreadsheet'
+
+// Store for spreadsheet row reasoning
+const rowReasoningData = {};
+
+// Auto-mapping confidence threshold
+const AUTO_MAP_CONFIDENCE_THRESHOLD = 0.7;
+
+// ============================================================================
+// Initialization
+// ============================================================================
+
+document.addEventListener('DOMContentLoaded', async () => {
+    // Check Azure status first
+    await checkAzureStatus();
+
+    // Initialize session
+    await initializeSession();
+
+    // Set up event listeners
+    setupEventListeners();
+
+    // Connect to SSE
+    connectSSE();
+
+    // Set initial mode
+    switchMode('question');
+});
+
+async function initializeSession() {
+    // Check for existing session in localStorage
+    sessionId = localStorage.getItem('sessionId');
+
+    if (sessionId) {
+        // Verify session still exists
+        try {
+            const response = await fetch(`/api/session/${sessionId}`);
+            if (response.ok) {
+                const data = await response.json();
+                applySessionConfig(data.config);
+
+                // Check for active processing job
+                if (data.processing_status === 'RUNNING') {
+                    await checkProcessingStatus();
+                }
+                return;
+            }
+        } catch (e) {
+            console.warn('Existing session invalid, creating new one');
+        }
+    }
+
+    // Create new session
+    try {
+        const response = await fetch('/api/session/create', { method: 'POST' });
+        if (response.ok) {
+            const data = await response.json();
+            sessionId = data.session_id;
+            localStorage.setItem('sessionId', sessionId);
+            applySessionConfig(data.config);
+        } else {
+            showError('Failed to create session');
+        }
+    } catch (e) {
+        showError('Failed to connect to server');
+        console.error('Session creation error:', e);
+    }
+}
+
+async function checkAzureStatus() {
+    try {
+        const response = await fetch('/health');
+        if (response.ok) {
+            const data = await response.json();
+            if (data.azure_auth === 'authenticated') {
+                updateAzureStatus(true);
+            } else {
+                updateAzureStatus(false, data.message || 'Not authenticated');
+            }
+        } else {
+            updateAzureStatus(false, 'Server error');
+        }
+    } catch (e) {
+        console.error('Health check error:', e);
+        updateAzureStatus(false, 'Connection error');
+    }
+}
+
+function updateAzureStatus(connected, message = null) {
+    const indicator = document.getElementById('azure-status-indicator');
+    const label = document.getElementById('azure-status-text');
+
+    if (indicator) {
+        indicator.classList.remove('checking', 'connected', 'disconnected');
+        indicator.classList.add(connected ? 'connected' : 'disconnected');
+    }
+
+    if (label) {
+        if (connected) {
+            label.textContent = 'Azure: Connected';
+        } else {
+            label.textContent = message ? `Azure: ${message}` : 'Azure: Disconnected';
+        }
+    }
+}
+
+function applySessionConfig(config) {
+    document.getElementById('context-input').value = config.context || 'Microsoft Azure AI';
+    document.getElementById('char-limit-input').value = config.char_limit || 2000;
+}
+
+// ============================================================================
+// Event Listeners
+// ============================================================================
+
+function setupEventListeners() {
+    // Ask button
+    document.getElementById('ask-btn').addEventListener('click', submitQuestion);
+
+    // Enter key for question submission (Ctrl+Enter)
+    document.getElementById('question-input').addEventListener('keydown', (e) => {
+        if (e.ctrlKey && e.key === 'Enter') {
+            submitQuestion();
+        }
+    });
+
+    // File upload
+    document.getElementById('file-upload').addEventListener('change', handleFileUpload);
+
+    // Spreadsheet processing
+    document.getElementById('start-processing-btn').addEventListener('click', startProcessing);
+    document.getElementById('stop-processing-btn').addEventListener('click', stopProcessing);
+    document.getElementById('download-btn').addEventListener('click', downloadResults);
+
+    // Sheet selection change
+    document.getElementById('sheet-select').addEventListener('change', handleSheetChange);
+}
+
+// ============================================================================
+// Mode Switching
+// ============================================================================
+
+function switchMode(mode) {
+    currentMode = mode;
+
+    const questionMode = document.getElementById('question-mode');
+    const spreadsheetMode = document.getElementById('spreadsheet-mode');
+    const spreadsheetControls = document.getElementById('spreadsheet-controls');
+
+    if (mode === 'question') {
+        questionMode.classList.remove('hidden');
+        spreadsheetMode.classList.add('hidden');
+        spreadsheetControls.classList.add('hidden');
+    } else {
+        questionMode.classList.add('hidden');
+        spreadsheetMode.classList.remove('hidden');
+        spreadsheetControls.classList.remove('hidden');
+    }
+}
+
+// ============================================================================
+// Status Bar
+// ============================================================================
+
+function updateStatusBar(message) {
+    const statusText = document.getElementById('status-text');
+    if (statusText) {
+        statusText.textContent = message;
+    }
+}
+
+function updateConnectionIndicator(connected) {
+    const indicator = document.getElementById('connection-indicator');
+    if (indicator) {
+        indicator.classList.remove('connected', 'disconnected', 'connecting');
+        if (connected) {
+            indicator.classList.add('connected');
+        } else {
+            indicator.classList.add('disconnected');
+        }
+    }
+}
+
+// ============================================================================
+// Question Processing
+// ============================================================================
+
+async function submitQuestion() {
+    const questionInput = document.getElementById('question-input');
+    const question = questionInput.value.trim();
+
+    if (!question) {
+        showError('Please enter a question');
+        return;
+    }
+
+    if (question.length < 5) {
+        showError('Question must be at least 5 characters');
+        return;
+    }
+
+    const context = document.getElementById('context-input').value;
+    const charLimit = parseInt(document.getElementById('char-limit-input').value);
+
+    // Show loading state
+    setQuestionLoading(true);
+    updateStatusBar('Working...');
+
+    // Hide empty state
+    document.getElementById('empty-state').classList.add('hidden');
+
+    try {
+        const response = await fetch('/api/question', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                session_id: sessionId,
+                question,
+                context,
+                char_limit: charLimit
+            })
+        });
+
+        if (response.ok) {
+            const data = await response.json();
+            displayAnswer(data);
+            updateStatusBar('Ready');
+        } else {
+            const error = await response.json();
+            showError(error.detail || 'Failed to process question');
+            updateStatusBar('Error');
+        }
+    } catch (e) {
+        showError('Failed to process question');
+        console.error('Question processing error:', e);
+        updateStatusBar('Error');
+    } finally {
+        setQuestionLoading(false);
+    }
+}
+
+function setQuestionLoading(loading) {
+    const askBtn = document.getElementById('ask-btn');
+    const loadingEl = document.getElementById('question-loading');
+    const questionInput = document.getElementById('question-input');
+
+    askBtn.disabled = loading;
+    questionInput.disabled = loading;
+    loadingEl.classList.toggle('hidden', !loading);
+}
+
+function displayAnswer(data) {
+    const answerSection = document.getElementById('answer-section');
+    const answerContent = document.getElementById('answer-content');
+    const answerTime = document.getElementById('answer-time');
+    const answerLinks = document.getElementById('answer-links');
+    const reasoningContent = document.getElementById('reasoning-content');
+
+    // Format answer with clickable links
+    answerContent.innerHTML = formatAnswerWithLinks(data.answer);
+
+    // Meta info
+    answerTime.textContent = `Processing time: ${data.processing_time_seconds.toFixed(1)}s`;
+    answerLinks.textContent = `Links checked: ${data.links_checked}`;
+
+    // Reasoning
+    reasoningContent.textContent = data.reasoning;
+
+    // Show section
+    answerSection.classList.remove('hidden');
+
+    // Scroll into view
+    answerSection.scrollIntoView({ behavior: 'smooth', block: 'start' });
+}
+
+function formatAnswerWithLinks(text) {
+    // Convert URLs to clickable links
+    const urlRegex = /(https?:\/\/[^\s<]+)/g;
+    return text.replace(urlRegex, '<a href="$1" target="_blank" rel="noopener noreferrer">$1</a>');
+}
+
+// ============================================================================
+// Server-Sent Events
+// ============================================================================
+
+function connectSSE() {
+    if (!sessionId) {
+        console.error('[SSE] Cannot connect: sessionId is null');
+        return;
+    }
+
+    if (eventSource) {
+        eventSource.close();
+    }
+
+    updateConnectionIndicator(false);
+
+    console.log(`[SSE] Connecting to /api/sse/${sessionId}`);
+    eventSource = new EventSource(`/api/sse/${sessionId}`);
+    window.eventSource = eventSource;  // Expose for debugging
+
+    eventSource.onopen = () => {
+        console.log('[SSE] Connection opened');
+        updateConnectionIndicator(true);
+    };
+
+    eventSource.onmessage = (event) => {
+        try {
+            const message = JSON.parse(event.data);
+            console.log('[SSE] Received message:', message.type);
+            handleSSEMessage(message);
+        } catch (e) {
+            console.error('[SSE] Message parse error:', e);
+        }
+    };
+
+    eventSource.onerror = (error) => {
+        console.error('[SSE] Connection error:', error, 'ReadyState:', eventSource.readyState);
+        updateConnectionIndicator(false);
+        updateStatusBar('Connection lost. Reconnecting...');
+        // Attempt reconnect after delay
+        setTimeout(connectSSE, 5000);
+    };
+}
+
+function handleSSEMessage(message) {
+    switch (message.type) {
+        case 'PROGRESS':
+            handleProgressUpdate(message.data);
+            break;
+        case 'ANSWER':
+            handleAnswerUpdate(message.data);
+            break;
+        case 'ERROR':
+            handleErrorMessage(message.data);
+            break;
+        case 'COMPLETE':
+            handleProcessingComplete(message.data);
+            break;
+        case 'STATUS':
+            handleStatusChange(message.data);
+            break;
+        case 'ROW_STARTED':
+            handleRowStarted(message.data);
+            break;
+        case 'AGENT_PROGRESS':
+            handleAgentProgress(message.data);
+            break;
+        default:
+            console.log('Unknown SSE message type:', message.type);
+    }
+}
+
+// ============================================================================
+// File Upload
+// ============================================================================
+
+async function handleFileUpload(event) {
+    const file = event.target.files[0];
+    if (!file) return;
+
+    // Update file name display
+    document.getElementById('file-name').textContent = file.name;
+
+    updateStatusBar('Uploading file...');
+
+    // Create form data
+    const formData = new FormData();
+    formData.append('session_id', sessionId);
+    formData.append('file', file);
+
+    try {
+        const response = await fetch('/api/spreadsheet/upload', {
+            method: 'POST',
+            body: formData
+        });
+
+        if (response.ok) {
+            const data = await response.json();
+            handleUploadSuccess(data);
+        } else {
+            const error = await response.json();
+            showError(error.detail || 'Failed to upload file');
+            updateStatusBar('Error: ' + (error.detail || 'Upload failed'));
+        }
+    } catch (e) {
+        showError('Failed to upload file');
+        console.error('File upload error:', e);
+        updateStatusBar('Error: Upload failed');
+    }
+}
+
+function handleUploadSuccess(data) {
+    // Store column data
+    window.uploadedData = data;
+
+    // Switch to spreadsheet mode
+    switchMode('spreadsheet');
+
+    // Populate sheet selector (hidden dropdown, used internally)
+    const sheetSelect = document.getElementById('sheet-select');
+    sheetSelect.innerHTML = data.sheets.map(sheet =>
+        `<option value="${sheet}"${sheet === data.suggested_columns.sheet_name ? ' selected' : ''}>${sheet}</option>`
+    ).join('');
+
+    // Generate sheet tabs at bottom of spreadsheet
+    generateSheetTabs(data.sheets, data.suggested_columns.sheet_name);
+
+    // Populate column selectors for the selected sheet
+    updateColumnSelectors(data.suggested_columns.sheet_name);
+
+    // Check if auto-mapping was successful
+    const autoMapSuccess = data.suggested_columns.confidence >= AUTO_MAP_CONFIDENCE_THRESHOLD &&
+                          data.suggested_columns.question_column &&
+                          data.suggested_columns.answer_column;
+
+    if (autoMapSuccess) {
+        // Apply auto-mapped columns
+        document.getElementById('question-col-select').value = data.suggested_columns.question_column;
+        document.getElementById('answer-col-select').value = data.suggested_columns.answer_column;
+
+        // Set documentation column if identified
+        const docColSelect = document.getElementById('doc-col-select');
+        if (docColSelect && data.suggested_columns.documentation_column) {
+            docColSelect.value = data.suggested_columns.documentation_column;
+        }
+
+        // Hide column mapping UI
+        document.getElementById('column-mapping').classList.add('hidden');
+
+        // Initialize and show grid
+        if (typeof initializeSpreadsheetGrid === 'function') {
+            initializeSpreadsheetGrid();
+        }
+
+        updateStatusBar(`Auto-mapped columns. Processing row 1 of ${data.row_count}...`);
+
+        // Auto-start processing
+        startProcessing();
+    } else {
+        // Show column mapping UI for manual selection
+        document.getElementById('column-mapping').classList.remove('hidden');
+
+        // Apply suggestions if available
+        if (data.suggested_columns.question_column) {
+            document.getElementById('question-col-select').value = data.suggested_columns.question_column;
+        }
+        if (data.suggested_columns.answer_column) {
+            document.getElementById('answer-col-select').value = data.suggested_columns.answer_column;
+        }
+
+        // Set documentation column if suggested
+        const docColSelect = document.getElementById('doc-col-select');
+        if (docColSelect && data.suggested_columns.documentation_column) {
+            docColSelect.value = data.suggested_columns.documentation_column;
+        }
+
+        // Initialize grid but don't start processing
+        if (typeof initializeSpreadsheetGrid === 'function') {
+            initializeSpreadsheetGrid();
+        }
+
+        updateStatusBar('Could not auto-detect columns. Please select manually.');
+    }
+}
+
+// ============================================================================
+// Sheet Tabs
+// ============================================================================
+
+function generateSheetTabs(sheets, activeSheet) {
+    const tabsContainer = document.getElementById('sheet-tabs');
+    if (!tabsContainer) return;
+
+    tabsContainer.innerHTML = sheets.map(sheet => `
+        <div class="sheet-tab${sheet === activeSheet ? ' active' : ''}"
+             data-sheet="${sheet}"
+             onclick="switchSheet('${sheet}')">
+            <span class="sheet-tab-icon">📄</span>
+            ${sheet}
+        </div>
+    `).join('');
+}
+
+function switchSheet(sheetName) {
+    // Don't switch if processing is active
+    if (isProcessing) {
+        showError('Cannot switch sheets while processing is active');
+        return;
+    }
+
+    // Update hidden sheet selector
+    const sheetSelect = document.getElementById('sheet-select');
+    if (sheetSelect) {
+        sheetSelect.value = sheetName;
+    }
+
+    // Update tab active states
+    const tabs = document.querySelectorAll('.sheet-tab');
+    tabs.forEach(tab => {
+        if (tab.dataset.sheet === sheetName) {
+            tab.classList.add('active');
+        } else {
+            tab.classList.remove('active');
+        }
+    });
+
+    // Update column selectors for new sheet
+    updateColumnSelectors(sheetName);
+
+    // Re-initialize grid with new sheet data
+    if (typeof initializeSpreadsheetGrid === 'function') {
+        initializeSpreadsheetGrid();
+    }
+
+    // Clear any stored reasoning data for previous sheet
+    Object.keys(rowReasoningData).forEach(key => delete rowReasoningData[key]);
+
+    updateStatusBar(`Switched to sheet: ${sheetName}`);
+}
+
+function handleSheetChange() {
+    const sheetName = document.getElementById('sheet-select').value;
+    updateColumnSelectors(sheetName);
+
+    // Re-initialize grid for new sheet
+    if (typeof initializeSpreadsheetGrid === 'function') {
+        initializeSpreadsheetGrid();
+    }
+}
+
+function updateColumnSelectors(sheetName) {
+    const data = window.uploadedData;
+    if (!data || !data.columns[sheetName]) return;
+
+    const columns = data.columns[sheetName];
+
+    const questionColSelect = document.getElementById('question-col-select');
+    const contextColSelect = document.getElementById('context-col-select');
+    const answerColSelect = document.getElementById('answer-col-select');
+    const docColSelect = document.getElementById('doc-col-select');
+
+    // Preserve currently selected values
+    const prevQuestion = questionColSelect.value;
+    const prevContext = contextColSelect.value;
+    const prevAnswer = answerColSelect.value;
+    const prevDoc = docColSelect ? docColSelect.value : '';
+
+    const columnOptions = columns.map(col => `<option value="${col}">${col}</option>`).join('');
+
+    // Update options
+    questionColSelect.innerHTML = columnOptions;
+    contextColSelect.innerHTML = '<option value="">Use default context</option>' + columnOptions;
+    answerColSelect.innerHTML = columnOptions;
+    if (docColSelect) {
+        docColSelect.innerHTML = '<option value="">No documentation column</option>' + columnOptions;
+    }
+
+    // Restore previous selections if those columns exist in new sheet
+    if (columns.includes(prevQuestion)) {
+        questionColSelect.value = prevQuestion;
+    }
+    if (prevContext && columns.includes(prevContext)) {
+        contextColSelect.value = prevContext;
+    } else if (!prevContext) {
+        contextColSelect.value = '';  // Restore empty selection
+    }
+    if (columns.includes(prevAnswer)) {
+        answerColSelect.value = prevAnswer;
+    }
+    if (docColSelect) {
+        if (prevDoc && columns.includes(prevDoc)) {
+            docColSelect.value = prevDoc;
+        } else if (!prevDoc) {
+            docColSelect.value = '';  // Restore empty selection
+        }
+    }
+}
+
+// ============================================================================
+// Spreadsheet Processing
+// ============================================================================
+
+async function startProcessing() {
+    const sheetName = document.getElementById('sheet-select').value;
+    const questionColumn = document.getElementById('question-col-select').value;
+    const contextColumn = document.getElementById('context-col-select').value || null;
+    const answerColumn = document.getElementById('answer-col-select').value;
+
+    if (!questionColumn || !answerColumn) {
+        showError('Please select question and answer columns');
+        return;
+    }
+
+    // Hide column mapping if visible
+    document.getElementById('column-mapping').classList.add('hidden');
+
+    try {
+        const response = await fetch('/api/spreadsheet/process', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                session_id: sessionId,
+                sheet_name: sheetName,
+                question_column: questionColumn,
+                context_column: contextColumn,
+                answer_column: answerColumn
+            })
+        });
+
+        if (response.ok) {
+            const data = await response.json();
+            currentJobId = data.job_id;
+            isProcessing = true;
+            processingCompleted = false;  // Reset flag for new job
+            setProcessingUI(true, data.total_rows);
+            updateStatusBar(`Processing row 1 of ${data.total_rows}...`);
+        } else {
+            const error = await response.json();
+            showError(error.detail || 'Failed to start processing');
+            updateStatusBar('Error: ' + (error.detail || 'Failed to start'));
+        }
+    } catch (e) {
+        showError('Failed to start processing');
+        console.error('Start processing error:', e);
+        updateStatusBar('Error: Failed to start processing');
+    }
+}
+
+async function stopProcessing() {
+    try {
+        const response = await fetch('/api/spreadsheet/stop', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ session_id: sessionId })
+        });
+
+        if (response.ok) {
+            const data = await response.json();
+            isProcessing = false;
+            setProcessingUI(false, 0);
+            // Clear all working cells - only completed (green) rows should remain
+            if (typeof clearAllWorkingCells === 'function') {
+                clearAllWorkingCells();
+            }
+            updateStatusBar(`Stopped at row ${data.processed_rows} of ${data.total_rows}`);
+            showSuccess(`Stopped processing. ${data.processed_rows} rows completed.`);
+        } else {
+            const error = await response.json();
+            showError(error.detail || 'Failed to stop processing');
+        }
+    } catch (e) {
+        showError('Failed to stop processing');
+        console.error('Stop processing error:', e);
+    }
+}
+
+function setProcessingUI(processing, totalRows) {
+    document.getElementById('start-processing-btn').disabled = processing;
+    document.getElementById('stop-processing-btn').disabled = !processing;
+    document.getElementById('download-btn').disabled = processing;
+    document.getElementById('file-upload').disabled = processing;
+    document.getElementById('import-btn').disabled = processing;
+}
+
+function handleProgressUpdate(data) {
+    updateStatusBar(`Processing row ${data.row} of ${data.total}...`);
+
+    // Highlight current row in grid
+    if (typeof highlightProcessingRow === 'function') {
+        highlightProcessingRow(data.row - 1);
+    }
+}
+
+function handleRowStarted(data) {
+    // Ignore stale events after processing has completed
+    if (processingCompleted) {
+        console.log('Ignoring stale ROW_STARTED event after completion');
+        return;
+    }
+
+    updateStatusBar(`Processing row ${data.row + 1}...`);
+
+    // Highlight current row with "Working..." indicator
+    if (typeof setRowProcessing === 'function') {
+        setRowProcessing(data.row, true);
+    }
+}
+
+function handleAgentProgress(data) {
+    // Ignore stale agent progress events after processing has completed
+    if (processingCompleted) {
+        console.log('Ignoring stale AGENT_PROGRESS event after completion');
+        return;
+    }
+
+    // Update the agent name for a row being processed
+    if (typeof updateRowAgent === 'function') {
+        updateRowAgent(data.row, data.agent_name);
+    }
+}
+
+function handleAnswerUpdate(data) {
+    // Store reasoning for modal
+    rowReasoningData[data.row] = {
+        question: data.question,
+        answer: data.answer,
+        reasoning: data.reasoning
+    };
+
+    // Update grid if available
+    if (typeof updateGridCell === 'function') {
+        updateGridCell(data.row, data.answer, data.documentation || null);
+    }
+
+    // Clear processing indicator for this row
+    if (typeof setRowProcessing === 'function') {
+        setRowProcessing(data.row, false);
+    }
+}
+
+function handleErrorMessage(data) {
+    if (data.row !== undefined) {
+        updateStatusBar(`Error at row ${data.row + 1}: ${data.message}`);
+        // Mark row as error in grid
+        if (typeof setRowError === 'function') {
+            setRowError(data.row, data.message);
+        }
+    } else {
+        updateStatusBar(`Error: ${data.message}`);
+        showError(data.message);
+    }
+}
+
+async function handleProcessingComplete(data) {
+    isProcessing = false;
+    processingCompleted = true;  // Set flag to ignore stale events
+    setProcessingUI(false, 0);
+
+    // Refresh grid with completed data from server
+    await refreshGridWithCompletedData();
+
+    // Enable and highlight download button
+    const downloadBtn = document.getElementById('download-btn');
+    downloadBtn.disabled = false;
+    downloadBtn.classList.add('highlight-download');
+
+    // Create comprehensive completion message
+    const sheetText = data.total_sheets > 1 ? `across ${data.total_sheets} sheets` : '';
+    const statusMessage = `✅ Complete! Processed ${data.total_processed} questions ${sheetText} in ${data.duration_seconds.toFixed(1)}s. Ready to download.`;
+
+    updateStatusBar(statusMessage);
+
+    // Show longer-lasting success notification
+    showSuccess(`✅ Processing complete! ${data.total_processed} questions answered ${sheetText}. Click Download Results to save your file.`, 10000);
+}
+
+async function refreshGridWithCompletedData() {
+    // Fetch completed data from server for current sheet
+    const sheetName = document.getElementById('sheet-select').value;
+    console.log('[REFRESH] Starting grid refresh for sheet:', sheetName);
+
+    if (!sheetName) {
+        console.error('[REFRESH] No sheet name found');
+        return;
+    }
+
+    try {
+        const url = `/api/spreadsheet/data/${sessionId}/${encodeURIComponent(sheetName)}`;
+        console.log('[REFRESH] Fetching data from:', url);
+
+        const response = await fetch(url);
+        if (!response.ok) {
+            console.error('[REFRESH] Failed to fetch completed data, status:', response.status);
+            return;
+        }
+
+        const sheetData = await response.json();
+        console.log('[REFRESH] Received sheet data:', sheetData);
+
+        // Update grid with all answers and documentation
+        if (typeof updateGridWithCompletedData === 'function') {
+            console.log('[REFRESH] Calling updateGridWithCompletedData');
+            updateGridWithCompletedData(sheetData);
+        } else {
+            console.error('[REFRESH] updateGridWithCompletedData is not a function!');
+            console.log('[REFRESH] typeof updateGridWithCompletedData:', typeof updateGridWithCompletedData);
+        }
+    } catch (error) {
+        console.error('[REFRESH] Error refreshing grid with completed data:', error);
+    }
+}
+
+function handleStatusChange(data) {
+    if (data.status === 'CANCELLED') {
+        isProcessing = false;
+        setProcessingUI(false, 0);
+        // Clear all working cells - only completed (green) rows should remain
+        if (typeof clearAllWorkingCells === 'function') {
+            clearAllWorkingCells();
+        }
+    }
+}
+
+async function checkProcessingStatus() {
+    try {
+        const response = await fetch(`/api/spreadsheet/status/${sessionId}`);
+        if (response.ok) {
+            const data = await response.json();
+            if (data.status === 'RUNNING') {
+                isProcessing = true;
+                currentJobId = data.job_id;
+                setProcessingUI(true, data.total_rows);
+                updateStatusBar(`Processing row ${data.processed_rows + 1} of ${data.total_rows}...`);
+
+                // Switch to spreadsheet mode
+                switchMode('spreadsheet');
+            }
+        }
+    } catch (e) {
+        console.error('Failed to check processing status:', e);
+    }
+}
+
+async function downloadResults() {
+    window.location.href = `/api/spreadsheet/download/${sessionId}`;
+}
+
+// ============================================================================
+// Reasoning Modal
+// ============================================================================
+
+function showReasoningModal(rowIndex) {
+    const data = rowReasoningData[rowIndex];
+    if (!data) return;
+
+    document.getElementById('modal-title').textContent = `Row ${rowIndex + 1} Details`;
+    document.getElementById('modal-question').textContent = data.question;
+    document.getElementById('modal-answer').textContent = data.answer;
+    document.getElementById('modal-reasoning').textContent = data.reasoning;
+
+    document.getElementById('reasoning-modal').classList.remove('hidden');
+}
+
+function closeReasoningModal() {
+    document.getElementById('reasoning-modal').classList.add('hidden');
+}
+
+// ============================================================================
+// Toast Notifications
+// ============================================================================
+
+function showError(message) {
+    const toast = document.getElementById('error-toast');
+    const messageEl = document.getElementById('error-message');
+    messageEl.textContent = message;
+    toast.classList.remove('hidden');
+
+    setTimeout(() => {
+        toast.classList.add('hidden');
+    }, 5000);
+}
+
+function hideToast() {
+    document.getElementById('error-toast').classList.add('hidden');
+}
+
+function showSuccess(message, duration = 3000) {
+    const toast = document.getElementById('success-toast');
+    const messageEl = document.getElementById('success-message');
+    messageEl.textContent = message;
+    toast.classList.remove('hidden');
+
+    setTimeout(() => {
+        toast.classList.add('hidden');
+    }, duration);
+}
+
+function hideSuccessToast() {
+    document.getElementById('success-toast').classList.add('hidden');
+}
diff --git a/src/web/static/favicon.svg b/src/web/static/favicon.svg
new file mode 100644
index 0000000..aba5cc3
--- /dev/null
+++ b/src/web/static/favicon.svg
@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <rect width="32" height="32" rx="4" fill="#0078D4"/>
+  <text x="16" y="23" font-family="Arial" font-size="18" font-weight="bold" text-anchor="middle" fill="white">Q</text>
+</svg>
diff --git a/src/web/static/index.html b/src/web/static/index.html
new file mode 100644
index 0000000..5a3b359
--- /dev/null
+++ b/src/web/static/index.html
@@ -0,0 +1,231 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Questionnaire Agent - Microsoft Agent Framework</title>
+    <link rel="icon" type="image/svg+xml" href="/favicon.ico">
+    <link rel="stylesheet" href="/static/styles.css">
+    <!-- ag-Grid Community Edition -->
+    <script src="https://cdn.jsdelivr.net/npm/ag-grid-community@31.0.1/dist/ag-grid-community.min.js"></script>
+</head>
+<body>
+    <div class="app-container">
+        <!-- Header -->
+        <header class="app-header">
+            <div class="header-content">
+                <div class="header-title">
+                    <img src="https://devblogs.microsoft.com/foundry/wp-content/uploads/sites/89/2025/03/ai-foundry.png"
+                         alt="Azure AI Foundry"
+                         class="header-logo">
+                    <h1 class="app-title">Questionnaire Agent - Microsoft Agent Framework</h1>
+                </div>
+                <div class="azure-status">
+                    <span id="azure-status-indicator" class="status-indicator checking"></span>
+                    <span id="azure-status-text" class="status-label">Checking Azure...</span>
+                </div>
+            </div>
+        </header>
+
+        <!-- Main Content -->
+        <main class="main-content">
+            <!-- Left Sidebar -->
+            <aside class="sidebar">
+                <div class="sidebar-content">
+                    <!-- Context Input -->
+                    <div class="form-group">
+                        <label for="context-input">Context</label>
+                        <input type="text" id="context-input" class="form-input"
+                               value="Microsoft Azure AI"
+                               placeholder="Enter context...">
+                    </div>
+
+                    <!-- Character Limit -->
+                    <div class="form-group">
+                        <label for="char-limit-input">Character Limit</label>
+                        <input type="number" id="char-limit-input" class="form-input"
+                               value="2000" min="100" max="10000">
+                    </div>
+
+                    <!-- Maximum Retries -->
+                    <div class="form-group">
+                        <label for="max-retries-input">Maximum Retries</label>
+                        <input type="number" id="max-retries-input" class="form-input"
+                               value="10" min="1" max="50">
+                    </div>
+
+                    <!-- Question Textarea -->
+                    <div class="form-group">
+                        <label for="question-input">Question</label>
+                        <textarea id="question-input" class="form-textarea"
+                                  rows="4"
+                                  placeholder="Enter your question here..."></textarea>
+                    </div>
+
+                    <!-- Ask Button -->
+                    <button id="ask-btn" class="btn btn-primary btn-full">
+                        Ask!
+                    </button>
+
+                    <!-- Import From Excel Button -->
+                    <div class="file-upload-wrapper">
+                        <input type="file" id="file-upload" class="file-input"
+                               accept=".xlsx,.xls">
+                        <button id="import-btn" class="btn btn-secondary btn-full" onclick="document.getElementById('file-upload').click()">
+                            Import From Excel
+                        </button>
+                        <span id="file-name" class="file-name-display"></span>
+                    </div>
+
+                    <!-- Stop/Download buttons (shown during/after spreadsheet processing) -->
+                    <div id="spreadsheet-controls" class="spreadsheet-controls hidden">
+                        <button id="stop-processing-btn" class="btn btn-danger btn-full" disabled>
+                            Stop Processing
+                        </button>
+                        <button id="download-btn" class="btn btn-secondary btn-full" disabled>
+                            Download Results
+                        </button>
+                    </div>
+                </div>
+            </aside>
+
+            <!-- Main Panel -->
+            <div class="main-panel">
+                <!-- Ask Question Mode Content -->
+                <div id="question-mode" class="mode-content">
+                    <div class="question-response-area">
+                        <!-- Loading Indicator -->
+                        <div id="question-loading" class="loading-indicator hidden">
+                            <div class="spinner"></div>
+                            <span>Processing your question...</span>
+                        </div>
+
+                        <!-- Answer Section -->
+                        <div id="answer-section" class="answer-section hidden">
+                            <h3 class="section-title">Answer</h3>
+                            <div id="answer-content" class="answer-content"></div>
+                            <div class="answer-meta">
+                                <span id="answer-time"></span>
+                                <span id="answer-links"></span>
+                            </div>
+
+                            <!-- Reasoning Toggle -->
+                            <details id="reasoning-details" class="reasoning-section">
+                                <summary class="reasoning-toggle">
+                                    Show Reasoning
+                                </summary>
+                                <div id="reasoning-content" class="reasoning-content"></div>
+                            </details>
+                        </div>
+
+                        <!-- Empty State -->
+                        <div id="empty-state" class="empty-state">
+                            <p>Enter a question and click "Ask!" to get started.</p>
+                            <p class="empty-state-hint">Or import an Excel spreadsheet to process multiple questions.</p>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Spreadsheet Mode Content -->
+                <div id="spreadsheet-mode" class="mode-content hidden">
+                    <!-- Column Mapping Modal (shown when auto-mapping fails) -->
+                    <div id="column-mapping" class="column-mapping hidden">
+                        <div class="mapping-header">
+                            <h3>Column Mapping Required</h3>
+                            <p class="mapping-message">Could not auto-detect columns. Please select manually.</p>
+                        </div>
+                        <div class="column-selectors">
+                            <div class="form-group">
+                                <label for="sheet-select">Worksheet</label>
+                                <select id="sheet-select" class="form-select"></select>
+                            </div>
+                            <div class="form-group">
+                                <label for="question-col-select">Question Column</label>
+                                <select id="question-col-select" class="form-select"></select>
+                            </div>
+                            <div class="form-group">
+                                <label for="answer-col-select">Answer Column</label>
+                                <select id="answer-col-select" class="form-select"></select>
+                            </div>
+                            <div class="form-group">
+                                <label for="context-col-select">Context Column (Optional)</label>
+                                <select id="context-col-select" class="form-select">
+                                    <option value="">Use default context</option>
+                                </select>
+                            </div>
+                            <div class="form-group">
+                                <label for="doc-col-select">Documentation Column (Optional)</label>
+                                <select id="doc-col-select" class="form-select">
+                                    <option value="">No documentation column</option>
+                                </select>
+                            </div>
+                        </div>
+                        <button id="start-processing-btn" class="btn btn-primary">
+                            Start Processing
+                        </button>
+                    </div>
+
+                    <!-- Spreadsheet Container with Grid and Tabs -->
+                    <div class="spreadsheet-container">
+                        <!-- Spreadsheet Grid -->
+                        <div id="spreadsheet-grid" class="spreadsheet-grid"></div>
+
+                        <!-- Sheet Tabs (bottom of spreadsheet) -->
+                        <div id="sheet-tabs" class="sheet-tabs">
+                            <!-- Tabs will be dynamically generated -->
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </main>
+
+        <!-- Status Bar (Fixed at Bottom) -->
+        <footer class="status-bar">
+            <div class="status-bar-content">
+                <span id="connection-indicator" class="connection-indicator connected"></span>
+                <span id="status-text" class="status-text">Ready</span>
+            </div>
+        </footer>
+
+        <!-- Error Toast -->
+        <div id="error-toast" class="toast error-toast hidden">
+            <span id="error-message"></span>
+            <button class="toast-close" onclick="hideToast()">&times;</button>
+        </div>
+
+        <!-- Success Toast -->
+        <div id="success-toast" class="toast success-toast hidden">
+            <span id="success-message"></span>
+            <button class="toast-close" onclick="hideSuccessToast()">&times;</button>
+        </div>
+    </div>
+
+    <!-- Reasoning Modal for Spreadsheet Rows -->
+    <div id="reasoning-modal" class="modal hidden">
+        <div class="modal-overlay" onclick="closeReasoningModal()"></div>
+        <div class="modal-content">
+            <div class="modal-header">
+                <h3 id="modal-title">Reasoning Details</h3>
+                <button class="modal-close" onclick="closeReasoningModal()">&times;</button>
+            </div>
+            <div class="modal-body">
+                <div class="modal-section">
+                    <h4>Question</h4>
+                    <p id="modal-question"></p>
+                </div>
+                <div class="modal-section">
+                    <h4>Answer</h4>
+                    <p id="modal-answer"></p>
+                </div>
+                <div class="modal-section">
+                    <h4>Reasoning</h4>
+                    <div id="modal-reasoning" class="reasoning-content"></div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script src="/static/app.js"></script>
+    <script src="/static/spreadsheet.js"></script>
+</body>
+</html>
diff --git a/src/web/static/spreadsheet.js b/src/web/static/spreadsheet.js
new file mode 100644
index 0000000..b3e7989
--- /dev/null
+++ b/src/web/static/spreadsheet.js
@@ -0,0 +1,744 @@
+/**
+ * Questionnaire Agent Web Interface - Spreadsheet Component
+ * ag-Grid integration for Excel file display and real-time updates
+ */
+
+// ============================================================================
+// Global Grid State
+// ============================================================================
+
+let gridApi = null;
+let gridData = [];
+let currentProcessingRow = null;
+let answerColumnField = null;
+
+// Track which rows are actively processing (max 3 at a time)
+let activeProcessingRows = new Set();
+const MAX_PROCESSING_ROWS = 3;
+
+// Persistent storage for answers across sheet switches
+// Structure: { sheetName: { rowIndex: { answer: '...', documentation: '...', completed: true } } }
+let sheetAnswers = {};
+
+// ============================================================================
+// Grid Initialization
+// ============================================================================
+
+function initializeSpreadsheetGrid() {
+    const gridDiv = document.getElementById('spreadsheet-grid');
+    if (!gridDiv) return;
+
+    const uploadedData = window.uploadedData;
+    if (!uploadedData) return;
+
+    // Get selected sheet
+    const sheetName = document.getElementById('sheet-select').value;
+    const columns = uploadedData.columns[sheetName] || [];
+
+    // Determine the answer column field for highlighting
+    const answerColSelect = document.getElementById('answer-col-select');
+    answerColumnField = answerColSelect ? answerColSelect.value : null;
+
+    // Get question and documentation columns for visibility
+    const questionColSelect = document.getElementById('question-col-select');
+    const docColSelect = document.getElementById('doc-col-select');
+    const questionColumnField = questionColSelect ? questionColSelect.value : null;
+    const docColumnField = docColSelect ? docColSelect.value : null;
+
+    // Create list of relevant columns (Question, Response, Documentation)
+    const relevantColumns = new Set();
+    if (questionColumnField) relevantColumns.add(questionColumnField);
+    if (answerColumnField) relevantColumns.add(answerColumnField);
+    if (docColumnField) relevantColumns.add(docColumnField);
+
+    // Create column definitions (no row number column - user requested removal)
+    const columnDefs = [
+        ...columns.map(col => ({
+            headerName: col,
+            field: col,
+            sortable: true,
+            filter: true,
+            resizable: true,
+            editable: false,
+            minWidth: 150,
+            flex: 1,
+            hide: !relevantColumns.has(col),  // Hide columns that aren't Question, Response, or Documentation
+            cellRenderer: (params) => {
+                // Check if this is the answer column and row is processing
+                if (col === answerColumnField && params.data._processing) {
+                    const agentName = params.data._agentName || 'Working';
+                    // Format agent name for display (e.g., "question_answerer" -> "QuestionAnswerer")
+                    const displayName = formatAgentName(agentName);
+                    return `<span class="working-indicator"><span class="mini-spinner"></span>${displayName}...</span>`;
+                }
+                // Make answer cells clickable to show reasoning
+                if (col === answerColumnField && params.value) {
+                    return `<span class="answer-cell" onclick="showReasoningModal(${params.data.rowIndex})">${escapeHtml(params.value)}</span>`;
+                }
+                return escapeHtml(params.value || '');
+            },
+            cellClass: (params) => {
+                if (col === answerColumnField) {
+                    if (params.data._error) {
+                        return 'answer-error';
+                    }
+                    // Don't apply answer-filled during processing - only when truly completed
+                    if (params.data._processing) {
+                        return 'answer-empty';
+                    }
+                    return params.value ? 'answer-filled' : 'answer-empty';
+                }
+                return '';
+            }
+        }))
+    ];
+
+    // Get actual data from the upload response
+    const sheetData = uploadedData.data && uploadedData.data[sheetName];
+    if (sheetData && sheetData.length > 0) {
+        gridData = sheetData.map((row, idx) => ({
+            ...row,
+            rowIndex: idx,
+            _processing: false,
+            _completed: false,
+            _error: null,
+            _agentName: null
+        }));
+    } else {
+        // Fallback: create placeholder rows if no data available
+        gridData = [];
+        for (let i = 0; i < (uploadedData.row_count || 10); i++) {
+            const row = { rowIndex: i, _processing: false, _completed: false, _error: null, _agentName: null };
+            columns.forEach(col => {
+                row[col] = '';
+            });
+            gridData.push(row);
+        }
+    }
+
+    // Restore answers from persistent storage
+    if (sheetAnswers[sheetName]) {
+        for (const rowIndexStr in sheetAnswers[sheetName]) {
+            const rowIndex = parseInt(rowIndexStr);
+            if (rowIndex < gridData.length) {
+                const storedData = sheetAnswers[sheetName][rowIndex];
+                if (storedData.answer && answerColumnField) {
+                    gridData[rowIndex][answerColumnField] = storedData.answer;
+                }
+                if (storedData.documentation) {
+                    // Find documentation column and populate it
+                    const docColSelect = document.getElementById('doc-col-select');
+                    const docColumnField = docColSelect ? docColSelect.value : null;
+                    if (docColumnField) {
+                        gridData[rowIndex][docColumnField] = storedData.documentation;
+                    }
+                }
+                if (storedData.completed) {
+                    gridData[rowIndex]._completed = true;
+                }
+            }
+        }
+    }
+
+    // Reset active processing rows when initializing new grid
+    activeProcessingRows.clear();
+
+    // Grid options
+    const gridOptions = {
+        columnDefs: columnDefs,
+        rowData: gridData,
+        defaultColDef: {
+            sortable: true,
+            filter: true,
+            resizable: true,
+            minWidth: 100
+        },
+        // Virtual scrolling for large datasets
+        rowBuffer: 20,
+        // Animation
+        animateRows: true,
+        // Row selection
+        rowSelection: 'single',
+        // Header
+        headerHeight: 40,
+        rowHeight: 40,
+        // Suppress horizontal scroll
+        suppressHorizontalScroll: false,
+        // Row class rules for highlighting
+        getRowClass: (params) => {
+            if (params.data._processing) {
+                return 'row-processing';
+            }
+            if (params.data._error) {
+                return 'row-error';
+            }
+            if (params.data._completed) {
+                return 'row-completed';
+            }
+            return '';
+        },
+        // Callbacks
+        onGridReady: (params) => {
+            gridApi = params.api;
+            // Auto-size columns to fit content
+            params.api.sizeColumnsToFit();
+        },
+        onFirstDataRendered: (params) => {
+            params.api.sizeColumnsToFit();
+        },
+        onCellClicked: (params) => {
+            // Show reasoning modal for answer cells
+            if (params.column.colDef.field === answerColumnField && params.value) {
+                showReasoningModal(params.data.rowIndex);
+            }
+        }
+    };
+
+    // Clear existing grid
+    gridDiv.innerHTML = '';
+
+    // Add ag-Grid theme class
+    gridDiv.classList.add('ag-theme-alpine');
+
+    // Create grid using the modern API
+    gridApi = agGrid.createGrid(gridDiv, gridOptions);
+}
+
+// ============================================================================
+// Row State Management
+// ============================================================================
+
+function setRowProcessing(rowIndex, processing) {
+    if (!gridApi || rowIndex >= gridData.length) return;
+
+    // Don't clear processing if row is already completed (has answer)
+    if (!processing && gridData[rowIndex]._completed) {
+        // Row already completed - just remove from active set, don't touch state
+        activeProcessingRows.delete(rowIndex);
+        return;
+    }
+
+    const rowsToRedraw = [];
+
+    if (processing) {
+        // Enforce MAX_PROCESSING_ROWS limit on client side
+        // If we're at the limit, clear the oldest processing row first
+        if (activeProcessingRows.size >= MAX_PROCESSING_ROWS) {
+            // Find rows that are processing but shouldn't show Working anymore
+            for (const oldRowIndex of activeProcessingRows) {
+                if (oldRowIndex !== rowIndex && !gridData[oldRowIndex]._completed) {
+                    // Clear this row's processing state
+                    gridData[oldRowIndex]._processing = false;
+                    gridData[oldRowIndex]._agentName = null;
+                    activeProcessingRows.delete(oldRowIndex);
+                    const oldNode = gridApi.getRowNode(oldRowIndex.toString());
+                    if (oldNode) {
+                        oldNode.setData(gridData[oldRowIndex]);
+                        rowsToRedraw.push(oldNode);
+                    }
+                    break; // Only clear one
+                }
+            }
+        }
+
+        // Always clear completed state when starting to process (for retry scenarios)
+        gridData[rowIndex]._completed = false;
+
+        // Track in active set
+        activeProcessingRows.add(rowIndex);
+    } else {
+        // Remove from active set
+        activeProcessingRows.delete(rowIndex);
+    }
+
+    // Update data
+    gridData[rowIndex]._processing = processing;
+    gridData[rowIndex]._error = null;
+
+    // Clear agent name when not processing
+    if (!processing) {
+        gridData[rowIndex]._agentName = null;
+    }
+
+    // Track current processing row
+    currentProcessingRow = processing ? rowIndex : null;
+
+    // Refresh the row - use redrawRows to update row class (background color)
+    const rowNode = gridApi.getRowNode(rowIndex.toString());
+    if (rowNode) {
+        rowNode.setData(gridData[rowIndex]);
+        rowsToRedraw.push(rowNode);
+    }
+
+    // Redraw all affected rows
+    if (rowsToRedraw.length > 0) {
+        gridApi.redrawRows({ rowNodes: rowsToRedraw });
+    }
+}
+
+function setRowError(rowIndex, errorMessage) {
+    if (!gridApi || rowIndex >= gridData.length) return;
+
+    // Remove from active processing set
+    activeProcessingRows.delete(rowIndex);
+
+    // Update data
+    gridData[rowIndex]._processing = false;
+    gridData[rowIndex]._error = errorMessage;
+    gridData[rowIndex]._agentName = null;
+
+    // Update the answer cell with error message
+    if (answerColumnField) {
+        gridData[rowIndex][answerColumnField] = `Error: ${errorMessage}`;
+    }
+
+    // Refresh the row - use redrawRows to update row class (background color)
+    const rowNode = gridApi.getRowNode(rowIndex.toString());
+    if (rowNode) {
+        rowNode.setData(gridData[rowIndex]);
+        gridApi.redrawRows({ rowNodes: [rowNode] });
+    }
+}
+
+function highlightProcessingRow(rowIndex) {
+    // Clear previous processing row
+    if (currentProcessingRow !== null && currentProcessingRow !== rowIndex) {
+        setRowProcessing(currentProcessingRow, false);
+    }
+    // Set new processing row
+    setRowProcessing(rowIndex, true);
+}
+
+function updateRowAgent(rowIndex, agentName) {
+    if (!gridApi || rowIndex >= gridData.length) return;
+
+    // Only update if row is currently processing
+    if (!gridData[rowIndex]._processing) return;
+
+    // Update agent name
+    gridData[rowIndex]._agentName = agentName;
+
+    // Refresh the row
+    const rowNode = gridApi.getRowNode(rowIndex.toString());
+    if (rowNode) {
+        rowNode.setData(gridData[rowIndex]);
+        gridApi.refreshCells({ rowNodes: [rowNode], force: true });
+    }
+}
+
+function formatAgentName(agentName) {
+    if (!agentName) return 'Working';
+
+    // Map internal agent names to human-readable display names
+    const agentDisplayNames = {
+        'question_answerer': 'Answering Question',
+        'QuestionAnswererExecutor': 'Answering Question',
+        'answer_checker': 'Checking Answer',
+        'AnswerCheckerExecutor': 'Checking Answer',
+        'link_checker': 'Checking Links',
+        'LinkCheckerExecutor': 'Checking Links',
+        'workflow': 'Processing',
+        'batch': 'Processing'
+    };
+
+    // Check for exact match first
+    if (agentDisplayNames[agentName]) {
+        return agentDisplayNames[agentName];
+    }
+
+    // Fallback: return as-is
+    return 'Working';
+}
+
+function clearAllWorkingCells() {
+    if (!gridApi) return;
+
+    // Find all rows that are processing but not completed
+    const rowsToUpdate = [];
+    for (let i = 0; i < gridData.length; i++) {
+        if (gridData[i]._processing && !gridData[i]._completed) {
+            // Clear processing state
+            gridData[i]._processing = false;
+            gridData[i]._agentName = null;
+            gridData[i]._error = null;
+
+            // Clear the answer cell content (it was showing "Working...")
+            if (answerColumnField && gridData[i][answerColumnField]) {
+                // Only clear if it's a "Working..." type message
+                const cellValue = gridData[i][answerColumnField];
+                if (cellValue === 'Working...' || cellValue.includes('Working') ||
+                    cellValue === 'Checking Links...' || cellValue.includes('Checking')) {
+                    gridData[i][answerColumnField] = '';
+                }
+            }
+
+            rowsToUpdate.push(i);
+        }
+    }
+
+    // Clear the active processing set
+    activeProcessingRows.clear();
+    currentProcessingRow = null;
+
+    // Refresh all affected rows - use redrawRows to update row classes (background color)
+    if (rowsToUpdate.length > 0) {
+        const rowNodes = rowsToUpdate.map(i => gridApi.getRowNode(i.toString())).filter(n => n);
+        rowNodes.forEach(node => {
+            const rowIndex = parseInt(node.id);
+            node.setData(gridData[rowIndex]);
+        });
+        // redrawRows triggers getRowClass re-evaluation (needed to clear pink background)
+        gridApi.redrawRows({ rowNodes: rowNodes });
+    }
+}
+
+// ============================================================================
+// Grid Updates
+// ============================================================================
+
+function updateGridCell(rowIndex, answer, documentation = null) {
+    if (!gridApi || rowIndex >= gridData.length) return;
+
+    // Get current sheet name
+    const sheetSelect = document.getElementById('sheet-select');
+    const sheetName = sheetSelect ? sheetSelect.value : null;
+
+    // Store answer in persistent storage
+    if (sheetName) {
+        if (!sheetAnswers[sheetName]) {
+            sheetAnswers[sheetName] = {};
+        }
+        sheetAnswers[sheetName][rowIndex] = {
+            answer: answer,
+            documentation: documentation,
+            completed: true
+        };
+    }
+
+    // Remove from active processing set
+    activeProcessingRows.delete(rowIndex);
+
+    // Clear processing state and mark as completed
+    gridData[rowIndex]._processing = false;
+    gridData[rowIndex]._completed = true;  // Mark as completed for green highlight
+    gridData[rowIndex]._error = null;
+    gridData[rowIndex]._agentName = null;
+
+    // Update the answer in data
+    if (answerColumnField) {
+        gridData[rowIndex][answerColumnField] = answer;
+    }
+
+    // Update documentation if provided
+    if (documentation) {
+        const docColSelect = document.getElementById('doc-col-select');
+        const docColumnField = docColSelect ? docColSelect.value : null;
+        if (docColumnField) {
+            gridData[rowIndex][docColumnField] = documentation;
+        }
+    }
+
+    // Find the row node
+    const rowNode = gridApi.getRowNode(rowIndex.toString());
+    if (!rowNode) return;
+
+    // Update the data
+    rowNode.setData(gridData[rowIndex]);
+
+    // Redraw the row to update row class (pink -> green background)
+    gridApi.redrawRows({ rowNodes: [rowNode] });
+
+    // Flash the updated cell
+    if (answerColumnField) {
+        gridApi.flashCells({
+            rowNodes: [rowNode],
+            columns: [answerColumnField]
+        });
+    }
+}
+
+function setGridRowData(data) {
+    if (!gridApi) return;
+
+    gridData = data;
+    gridApi.setRowData(data);
+}
+
+function updateGridWithCompletedData(sheetData) {
+    if (!gridApi) return;
+
+    const answerColSelect = document.getElementById('answer-col-select');
+    const docColSelect = document.getElementById('doc-col-select');
+    const answerColumnField = answerColSelect ? answerColSelect.value : null;
+    const docColumnField = docColSelect ? docColSelect.value : null;
+
+    // Update each row with completed data
+    // When this function is called (only on COMPLETE event), ALL rows should be marked completed
+    for (let i = 0; i < sheetData.answers.length; i++) {
+        const answer = sheetData.answers[i];
+        const documentation = sheetData.documentation[i];
+
+        if (i >= gridData.length) break;
+
+        // Update answer
+        if (answer && answerColumnField) {
+            gridData[i][answerColumnField] = answer;
+        }
+
+        // Update documentation
+        if (documentation && docColumnField) {
+            gridData[i][docColumnField] = documentation;
+        }
+
+        // Mark ALL rows as completed when refresh is called (only happens on COMPLETE event)
+        // If a row has an answer, it's definitely done
+        if (answer) {
+            gridData[i]._completed = true;
+            gridData[i]._processing = false;
+            gridData[i]._error = null;
+            gridData[i]._agentName = null;
+
+            // Store in persistent storage
+            const sheetName = document.getElementById('sheet-select').value;
+            if (sheetName) {
+                if (!sheetAnswers[sheetName]) {
+                    sheetAnswers[sheetName] = {};
+                }
+                sheetAnswers[sheetName][i] = {
+                    answer: answer,
+                    documentation: documentation,
+                    completed: true
+                };
+            }
+        }
+    }
+
+    // Clear all processing states
+    activeProcessingRows.clear();
+
+    // Refresh the entire grid to update all rows
+    gridApi.setRowData(gridData);
+}
+
+function getGridRowData() {
+    if (!gridApi) return [];
+
+    const rowData = [];
+    gridApi.forEachNode((node) => {
+        rowData.push(node.data);
+    });
+    return rowData;
+}
+
+// ============================================================================
+// Grid Export
+// ============================================================================
+
+function exportGridToClipboard() {
+    // Community edition: manually copy grid data to clipboard
+    if (!gridApi) return;
+
+    const rowData = getGridRowData();
+    if (!rowData || rowData.length === 0) return;
+
+    // Convert to TSV format for clipboard
+    const columns = Object.keys(rowData[0]).filter(k => !k.startsWith('_') && k !== 'rowIndex');
+    const header = columns.join('\t');
+    const rows = rowData.map(row => columns.map(col => row[col] || '').join('\t'));
+    const tsv = [header, ...rows].join('\n');
+
+    navigator.clipboard.writeText(tsv).catch(err => {
+        console.error('Failed to copy to clipboard:', err);
+    });
+}
+
+// ============================================================================
+// Grid Filtering
+// ============================================================================
+
+function filterGrid(searchText) {
+    if (!gridApi) return;
+
+    gridApi.setQuickFilter(searchText);
+}
+
+function clearGridFilters() {
+    if (!gridApi) return;
+
+    gridApi.setFilterModel(null);
+    gridApi.setQuickFilter('');
+}
+
+// ============================================================================
+// Grid Sorting
+// ============================================================================
+
+function sortGridByColumn(columnField, direction = 'asc') {
+    if (!gridApi) return;
+
+    const sortModel = [
+        { colId: columnField, sort: direction }
+    ];
+    gridApi.setSortModel(sortModel);
+}
+
+function clearGridSort() {
+    if (!gridApi) return;
+
+    gridApi.setSortModel([]);
+}
+
+// ============================================================================
+// Utility Functions
+// ============================================================================
+
+function escapeHtml(text) {
+    if (!text) return '';
+    const div = document.createElement('div');
+    div.textContent = text;
+    return div.innerHTML;
+}
+
+// ============================================================================
+// CSS for Grid Cells
+// ============================================================================
+
+// Add custom styles dynamically
+const gridStyles = document.createElement('style');
+gridStyles.textContent = `
+    .ag-theme-alpine .row-number-cell {
+        color: var(--color-text-secondary);
+        font-size: var(--font-size-sm);
+        text-align: center;
+    }
+
+    .ag-theme-alpine .answer-cell {
+        cursor: pointer;
+        color: var(--color-primary);
+    }
+
+    .ag-theme-alpine .answer-cell:hover {
+        text-decoration: underline;
+    }
+
+    .ag-theme-alpine .answer-filled {
+        background-color: rgba(16, 124, 16, 0.1);
+    }
+
+    .ag-theme-alpine .answer-empty {
+        background-color: rgba(0, 0, 0, 0.02);
+    }
+
+    .ag-theme-alpine .answer-error {
+        background-color: rgba(209, 52, 56, 0.1);
+        color: var(--color-danger);
+    }
+
+    .ag-theme-alpine .ag-cell-flash {
+        animation: cell-flash 0.5s ease-out;
+    }
+
+    @keyframes cell-flash {
+        0% { background-color: rgba(0, 120, 212, 0.3); }
+        100% { background-color: transparent; }
+    }
+
+    .ag-theme-alpine .ag-header-cell {
+        font-weight: 600;
+    }
+
+    .ag-theme-alpine .ag-row-hover {
+        background-color: var(--color-surface-hover);
+    }
+
+    .ag-theme-alpine .ag-row-selected {
+        background-color: rgba(0, 120, 212, 0.1);
+    }
+
+    /* Processing row highlight */
+    .ag-theme-alpine .row-processing {
+        background-color: #FFECEC !important;
+    }
+
+    .ag-theme-alpine .row-processing:hover {
+        background-color: #FFE0E0 !important;
+    }
+
+    /* Error row highlight */
+    .ag-theme-alpine .row-error {
+        background-color: #FDE7E9 !important;
+    }
+
+    /* Completed row highlight (light green) */
+    .ag-theme-alpine .row-completed {
+        background-color: #E6F4EA !important;
+    }
+
+    .ag-theme-alpine .row-completed:hover {
+        background-color: #D4EDDA !important;
+    }
+
+    /* Working indicator */
+    .working-indicator {
+        display: inline-flex;
+        align-items: center;
+        gap: 6px;
+        color: #D13438;
+        font-style: italic;
+    }
+
+    .mini-spinner {
+        width: 12px;
+        height: 12px;
+        border: 2px solid #EDEBE9;
+        border-top-color: #D13438;
+        border-radius: 50%;
+        animation: spin 0.8s linear infinite;
+    }
+
+    @keyframes spin {
+        to { transform: rotate(360deg); }
+    }
+`;
+document.head.appendChild(gridStyles);
+
+// ============================================================================
+// Window Resize Handler
+// ============================================================================
+
+window.addEventListener('resize', () => {
+    if (gridApi) {
+        setTimeout(() => {
+            gridApi.sizeColumnsToFit();
+        }, 100);
+    }
+});
+
+// ============================================================================
+// Keyboard Shortcuts
+// ============================================================================
+
+document.addEventListener('keydown', (e) => {
+    // Ctrl+C - Copy selected cells (manually in community edition)
+    if (e.ctrlKey && e.key === 'c' && gridApi) {
+        exportGridToClipboard();
+    }
+
+    // Ctrl+F - Focus filter
+    if (e.ctrlKey && e.key === 'f') {
+        e.preventDefault();
+        // Could add a filter input focus here
+    }
+
+    // Escape - Clear selection
+    if (e.key === 'Escape' && gridApi) {
+        gridApi.deselectAll();
+    }
+});
+
+// ============================================================================
+// Export functions to global scope for cross-module access
+// ============================================================================
+
+// Make updateGridWithCompletedData available to app.js
+window.updateGridWithCompletedData = updateGridWithCompletedData;
diff --git a/src/web/static/styles.css b/src/web/static/styles.css
new file mode 100644
index 0000000..c796f75
--- /dev/null
+++ b/src/web/static/styles.css
@@ -0,0 +1,978 @@
+/* Microsoft Foundry-inspired CSS for Questionnaire Agent Web Interface */
+
+/* ============================================================================
+   CSS Variables (Design Tokens)
+   ============================================================================ */
+
+:root {
+    /* Colors - Microsoft Foundry palette */
+    --color-primary: #0078D4;
+    --color-primary-hover: #106EBE;
+    --color-primary-active: #005A9E;
+    --color-secondary: #605E5C;
+    --color-secondary-hover: #484644;
+
+    --color-success: #107C10;
+    --color-warning: #FFB900;
+    --color-danger: #D13438;
+    --color-info: #0078D4;
+
+    --color-background: #F3F2F1;
+    --color-surface: #FFFFFF;
+    --color-surface-hover: #FAF9F8;
+
+    --color-text-primary: #323130;
+    --color-text-secondary: #605E5C;
+    --color-text-disabled: #A19F9D;
+    --color-text-inverse: #FFFFFF;
+
+    --color-border: #EDEBE9;
+    --color-border-hover: #C8C6C4;
+
+    /* Row states */
+    --color-row-processing: #FFECEC;
+    --color-row-completed: #E6F4EA;  /* Light green for completed rows */
+    --color-row-error: #FDE7E9;
+
+    /* Spacing (4px base unit) */
+    --spacing-xs: 4px;
+    --spacing-sm: 8px;
+    --spacing-md: 12px;
+    --spacing-lg: 16px;
+    --spacing-xl: 24px;
+    --spacing-2xl: 32px;
+    --spacing-3xl: 48px;
+
+    /* Border radius */
+    --radius-sm: 2px;
+    --radius-md: 4px;
+    --radius-lg: 8px;
+    --radius-xl: 12px;
+
+    /* Shadows */
+    --shadow-sm: 0 1.6px 3.6px 0 rgba(0, 0, 0, 0.132), 0 0.3px 0.9px 0 rgba(0, 0, 0, 0.108);
+    --shadow-md: 0 3.2px 7.2px 0 rgba(0, 0, 0, 0.132), 0 0.6px 1.8px 0 rgba(0, 0, 0, 0.108);
+    --shadow-lg: 0 6.4px 14.4px 0 rgba(0, 0, 0, 0.132), 0 1.2px 3.6px 0 rgba(0, 0, 0, 0.108);
+
+    /* Typography */
+    --font-family: 'Segoe UI', -apple-system, BlinkMacSystemFont, 'Roboto', sans-serif;
+    --font-size-xs: 10px;
+    --font-size-sm: 12px;
+    --font-size-md: 14px;
+    --font-size-lg: 16px;
+    --font-size-xl: 20px;
+    --font-size-2xl: 24px;
+    --font-size-3xl: 32px;
+
+    --font-weight-regular: 400;
+    --font-weight-semibold: 600;
+    --font-weight-bold: 700;
+
+    --line-height-tight: 1.2;
+    --line-height-normal: 1.5;
+    --line-height-relaxed: 1.75;
+
+    /* Transitions */
+    --transition-fast: 100ms ease-in-out;
+    --transition-normal: 200ms ease-in-out;
+    --transition-slow: 300ms ease-in-out;
+
+    /* Status bar height */
+    --status-bar-height: 36px;
+}
+
+/* ============================================================================
+   Reset & Base Styles
+   ============================================================================ */
+
+*, *::before, *::after {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+html {
+    font-size: 16px;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+}
+
+body {
+    font-family: var(--font-family);
+    font-size: var(--font-size-md);
+    font-weight: var(--font-weight-regular);
+    line-height: var(--line-height-normal);
+    color: var(--color-text-primary);
+    background-color: var(--color-background);
+    min-height: 100vh;
+}
+
+/* ============================================================================
+   Layout
+   ============================================================================ */
+
+.app-container {
+    display: flex;
+    flex-direction: column;
+    min-height: 100vh;
+}
+
+.app-header {
+    background-color: var(--color-surface);
+    border-bottom: 1px solid var(--color-border);
+    padding: var(--spacing-lg) var(--spacing-xl);
+    position: sticky;
+    top: 0;
+    z-index: 100;
+}
+
+.header-content {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    max-width: 1600px;
+    margin: 0 auto;
+}
+
+.header-title {
+    display: flex;
+    align-items: center;
+    gap: var(--spacing-md);
+}
+
+.header-logo {
+    height: 32px;
+    width: auto;
+    object-fit: contain;
+}
+
+.app-title {
+    font-size: var(--font-size-xl);
+    font-weight: var(--font-weight-semibold);
+    color: var(--color-text-primary);
+}
+
+/* Azure Status Indicator */
+.azure-status {
+    display: flex;
+    align-items: center;
+    gap: var(--spacing-sm);
+    font-size: var(--font-size-sm);
+    padding: var(--spacing-xs) var(--spacing-sm);
+    background-color: var(--color-background);
+    border-radius: var(--radius-sm);
+}
+
+.status-indicator {
+    width: 10px;
+    height: 10px;
+    border-radius: 50%;
+    flex-shrink: 0;
+}
+
+.status-indicator.checking {
+    background-color: var(--color-warning);
+    animation: pulse 1.5s ease-in-out infinite;
+}
+
+.status-indicator.connected {
+    background-color: var(--color-success);
+}
+
+.status-indicator.disconnected {
+    background-color: var(--color-danger);
+}
+
+.status-label {
+    color: var(--color-text-secondary);
+    font-weight: var(--font-weight-medium);
+}
+
+@keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.4; }
+}
+
+.main-content {
+    display: flex;
+    flex: 1;
+    max-width: 1600px;
+    margin: 0 auto;
+    padding: var(--spacing-xl);
+    padding-bottom: calc(var(--spacing-xl) + var(--status-bar-height));
+    gap: var(--spacing-xl);
+    width: 100%;
+}
+
+/* ============================================================================
+   Sidebar
+   ============================================================================ */
+
+.sidebar {
+    width: 280px;
+    flex-shrink: 0;
+}
+
+.sidebar-content {
+    background-color: var(--color-surface);
+    border-radius: var(--radius-lg);
+    box-shadow: var(--shadow-sm);
+    padding: var(--spacing-xl);
+    display: flex;
+    flex-direction: column;
+    gap: var(--spacing-md);
+}
+
+/* ============================================================================
+   Main Panel
+   ============================================================================ */
+
+.main-panel {
+    flex: 1;
+    min-width: 0;
+    background-color: var(--color-surface);
+    border-radius: var(--radius-lg);
+    box-shadow: var(--shadow-sm);
+    padding: var(--spacing-xl);
+    display: flex;
+    flex-direction: column;
+}
+
+.mode-content {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+}
+
+.question-response-area {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+}
+
+/* ============================================================================
+   Status Bar
+   ============================================================================ */
+
+.status-bar {
+    position: fixed;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    height: var(--status-bar-height);
+    background-color: #E1DFDD;
+    border-top: 1px solid var(--color-border);
+    z-index: 100;
+}
+
+.status-bar-content {
+    display: flex;
+    align-items: center;
+    gap: var(--spacing-sm);
+    height: 100%;
+    padding: 0 var(--spacing-xl);
+    max-width: 1600px;
+    margin: 0 auto;
+}
+
+.connection-indicator {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    flex-shrink: 0;
+}
+
+.connection-indicator.connected {
+    background-color: var(--color-success);
+}
+
+.connection-indicator.disconnected {
+    background-color: var(--color-danger);
+}
+
+.connection-indicator.connecting {
+    background-color: var(--color-warning);
+    animation: pulse 1.5s infinite;
+}
+
+.status-text {
+    font-size: var(--font-size-sm);
+    color: var(--color-text-primary);
+}
+
+/* ============================================================================
+   Forms
+   ============================================================================ */
+
+.form-group {
+    margin-bottom: var(--spacing-md);
+}
+
+.form-group:last-child {
+    margin-bottom: 0;
+}
+
+.form-group label {
+    display: block;
+    font-size: var(--font-size-sm);
+    font-weight: var(--font-weight-semibold);
+    color: var(--color-text-primary);
+    margin-bottom: var(--spacing-xs);
+}
+
+.form-input,
+.form-select,
+.form-textarea {
+    width: 100%;
+    padding: var(--spacing-sm) var(--spacing-md);
+    font-family: var(--font-family);
+    font-size: var(--font-size-md);
+    color: var(--color-text-primary);
+    background-color: var(--color-surface);
+    border: 1px solid var(--color-border);
+    border-radius: var(--radius-md);
+    transition: border-color var(--transition-fast), box-shadow var(--transition-fast);
+}
+
+.form-input:hover,
+.form-select:hover,
+.form-textarea:hover {
+    border-color: var(--color-border-hover);
+}
+
+.form-input:focus,
+.form-select:focus,
+.form-textarea:focus {
+    outline: none;
+    border-color: var(--color-primary);
+    box-shadow: 0 0 0 2px rgba(0, 120, 212, 0.2);
+}
+
+.form-textarea {
+    resize: vertical;
+    min-height: 80px;
+}
+
+/* ============================================================================
+   Buttons
+   ============================================================================ */
+
+.btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: var(--spacing-sm);
+    padding: var(--spacing-sm) var(--spacing-lg);
+    font-family: var(--font-family);
+    font-size: var(--font-size-md);
+    font-weight: var(--font-weight-semibold);
+    text-decoration: none;
+    border: none;
+    border-radius: var(--radius-md);
+    cursor: pointer;
+    transition: background-color var(--transition-fast), box-shadow var(--transition-fast);
+}
+
+.btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.btn-full {
+    width: 100%;
+}
+
+.btn-primary {
+    background-color: var(--color-primary);
+    color: var(--color-text-inverse);
+}
+
+.btn-primary:hover:not(:disabled) {
+    background-color: var(--color-primary-hover);
+}
+
+.btn-primary:active:not(:disabled) {
+    background-color: var(--color-primary-active);
+}
+
+.btn-secondary {
+    background-color: var(--color-surface);
+    color: var(--color-text-primary);
+    border: 1px solid var(--color-border);
+}
+
+.btn-secondary:hover:not(:disabled) {
+    background-color: var(--color-surface-hover);
+    border-color: var(--color-border-hover);
+}
+
+.btn-danger {
+    background-color: var(--color-danger);
+    color: var(--color-text-inverse);
+}
+
+.btn-danger:hover:not(:disabled) {
+    background-color: #B52E31;
+}
+
+.button-group {
+    display: flex;
+    gap: var(--spacing-md);
+    margin-top: var(--spacing-lg);
+}
+
+/* ============================================================================
+   File Upload
+   ============================================================================ */
+
+.file-upload-wrapper {
+    margin-top: var(--spacing-md);
+}
+
+.file-input {
+    display: none;
+}
+
+.file-name-display {
+    display: block;
+    margin-top: var(--spacing-xs);
+    font-size: var(--font-size-sm);
+    color: var(--color-text-secondary);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+/* ============================================================================
+   Spreadsheet Controls
+   ============================================================================ */
+
+.spreadsheet-controls {
+    display: flex;
+    flex-direction: column;
+    gap: var(--spacing-sm);
+    margin-top: var(--spacing-md);
+}
+
+/* ============================================================================
+   Empty State
+   ============================================================================ */
+
+.empty-state {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    flex: 1;
+    min-height: 300px;
+    text-align: center;
+    color: var(--color-text-secondary);
+}
+
+.empty-state p {
+    font-size: var(--font-size-lg);
+    margin-bottom: var(--spacing-sm);
+}
+
+.empty-state-hint {
+    font-size: var(--font-size-md) !important;
+    color: var(--color-text-disabled);
+}
+
+/* ============================================================================
+   Loading Indicator
+   ============================================================================ */
+
+.loading-indicator {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: var(--spacing-md);
+    padding: var(--spacing-xl);
+    color: var(--color-text-secondary);
+}
+
+.spinner {
+    width: 20px;
+    height: 20px;
+    border: 2px solid var(--color-border);
+    border-top-color: var(--color-primary);
+    border-radius: 50%;
+    animation: spin 0.8s linear infinite;
+}
+
+@keyframes spin {
+    to { transform: rotate(360deg); }
+}
+
+@keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.5; }
+}
+
+/* ============================================================================
+   Answer Section
+   ============================================================================ */
+
+.answer-section {
+    padding: var(--spacing-xl);
+}
+
+.section-title {
+    font-size: var(--font-size-lg);
+    font-weight: var(--font-weight-semibold);
+    margin-bottom: var(--spacing-md);
+    color: var(--color-text-primary);
+}
+
+.answer-content {
+    background-color: var(--color-background);
+    padding: var(--spacing-lg);
+    border-radius: var(--radius-md);
+    line-height: var(--line-height-relaxed);
+    white-space: pre-wrap;
+}
+
+.answer-content a {
+    color: var(--color-primary);
+    text-decoration: none;
+}
+
+.answer-content a:hover {
+    text-decoration: underline;
+}
+
+.answer-meta {
+    display: flex;
+    gap: var(--spacing-lg);
+    margin-top: var(--spacing-md);
+    font-size: var(--font-size-sm);
+    color: var(--color-text-secondary);
+}
+
+/* ============================================================================
+   Reasoning Section
+   ============================================================================ */
+
+.reasoning-section {
+    margin-top: var(--spacing-lg);
+}
+
+.reasoning-toggle {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--spacing-sm);
+    padding: var(--spacing-sm) var(--spacing-md);
+    font-size: var(--font-size-sm);
+    font-weight: var(--font-weight-semibold);
+    color: var(--color-primary);
+    cursor: pointer;
+    border-radius: var(--radius-md);
+    transition: background-color var(--transition-fast);
+}
+
+.reasoning-toggle:hover {
+    background-color: rgba(0, 120, 212, 0.1);
+}
+
+.reasoning-content {
+    margin-top: var(--spacing-md);
+    padding: var(--spacing-lg);
+    background-color: var(--color-background);
+    border-radius: var(--radius-md);
+    font-family: 'Consolas', 'Monaco', monospace;
+    font-size: var(--font-size-sm);
+    line-height: var(--line-height-relaxed);
+    white-space: pre-wrap;
+    max-height: 400px;
+    overflow-y: auto;
+}
+
+/* ============================================================================
+   Column Mapping
+   ============================================================================ */
+
+.column-mapping {
+    background-color: var(--color-background);
+    border-radius: var(--radius-lg);
+    padding: var(--spacing-xl);
+    margin-bottom: var(--spacing-xl);
+}
+
+.mapping-header {
+    margin-bottom: var(--spacing-lg);
+}
+
+.mapping-header h3 {
+    font-size: var(--font-size-lg);
+    font-weight: var(--font-weight-semibold);
+    margin-bottom: var(--spacing-sm);
+}
+
+.mapping-message {
+    color: var(--color-text-secondary);
+    font-size: var(--font-size-sm);
+}
+
+.column-selectors {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    gap: var(--spacing-lg);
+    margin-bottom: var(--spacing-lg);
+}
+
+/* ============================================================================
+   Spreadsheet Grid
+   ============================================================================ */
+
+.spreadsheet-container {
+    display: flex;
+    flex-direction: column;
+    flex: 1;
+    min-height: 400px;
+}
+
+.spreadsheet-grid {
+    flex: 1;
+    min-height: 350px;
+    border: 1px solid var(--color-border);
+    border-top-left-radius: var(--radius-md);
+    border-top-right-radius: var(--radius-md);
+    border-bottom: none;
+    overflow: hidden;
+}
+
+/* Sheet Tabs (Excel-style tabs at bottom - hanging down from spreadsheet) */
+.sheet-tabs {
+    display: flex;
+    align-items: flex-start;
+    background-color: #E0E0E0;
+    border-left: 1px solid var(--color-border);
+    border-right: 1px solid var(--color-border);
+    border-bottom: 1px solid var(--color-border);
+    border-bottom-left-radius: var(--radius-md);
+    border-bottom-right-radius: var(--radius-md);
+    padding: 0 var(--spacing-sm);
+    padding-bottom: 4px;
+    gap: 2px;
+    overflow-x: auto;
+    min-height: 32px;
+}
+
+.sheet-tab {
+    display: inline-flex;
+    align-items: center;
+    padding: 6px 12px;
+    background: linear-gradient(to top, #F8F8F8 0%, #E8E8E8 100%);
+    border: 1px solid #B0B0B0;
+    border-top: none;
+    border-bottom-left-radius: 4px;
+    border-bottom-right-radius: 4px;
+    font-size: var(--font-size-sm);
+    color: var(--color-text-secondary);
+    cursor: pointer;
+    white-space: nowrap;
+    transition: all var(--transition-fast);
+    position: relative;
+    margin-top: -1px;
+}
+
+.sheet-tab:hover {
+    background: linear-gradient(to top, #FFFFFF 0%, #F0F0F0 100%);
+}
+
+.sheet-tab.active {
+    background: #FFFFFF;
+    border-color: var(--color-border);
+    color: var(--color-text-primary);
+    font-weight: var(--font-weight-semibold);
+    z-index: 1;
+}
+
+.sheet-tab.active::before {
+    content: '';
+    position: absolute;
+    top: -1px;
+    left: 0;
+    right: 0;
+    height: 2px;
+    background: #FFFFFF;
+}
+
+.sheet-tab-icon {
+    margin-right: var(--spacing-xs);
+    font-size: var(--font-size-xs);
+}
+
+/* ag-Grid theme overrides */
+.ag-theme-alpine {
+    --ag-header-background-color: var(--color-primary);
+    --ag-header-foreground-color: var(--color-text-inverse);
+    --ag-row-hover-color: var(--color-surface-hover);
+    --ag-selected-row-background-color: rgba(0, 120, 212, 0.1);
+    --ag-font-family: var(--font-family);
+    --ag-font-size: var(--font-size-md);
+}
+
+/* Row state styling */
+.ag-theme-alpine .row-processing {
+    background-color: var(--color-row-processing) !important;
+}
+
+.ag-theme-alpine .row-completed {
+    background-color: var(--color-row-completed) !important;
+}
+
+.ag-theme-alpine .row-error {
+    background-color: var(--color-row-error) !important;
+}
+
+/* Highlight download button when processing complete */
+.btn.highlight-download {
+    animation: pulse-download 2s ease-in-out 3;
+    box-shadow: 0 0 0 4px rgba(76, 175, 80, 0.3);
+}
+
+@keyframes pulse-download {
+    0%, 100% {
+        box-shadow: 0 0 0 0 rgba(76, 175, 80, 0.7);
+    }
+    50% {
+        box-shadow: 0 0 0 8px rgba(76, 175, 80, 0);
+    }
+}
+
+/* Working indicator cell */
+.working-indicator {
+    display: flex;
+    align-items: center;
+    gap: var(--spacing-sm);
+    color: var(--color-danger);
+    font-style: italic;
+}
+
+.working-indicator .mini-spinner {
+    width: 12px;
+    height: 12px;
+    border: 2px solid var(--color-border);
+    border-top-color: var(--color-danger);
+    border-radius: 50%;
+    animation: spin 0.8s linear infinite;
+}
+
+/* ============================================================================
+   Toast Notifications
+   ============================================================================ */
+
+.toast {
+    position: fixed;
+    bottom: calc(var(--status-bar-height) + var(--spacing-lg));
+    right: var(--spacing-xl);
+    padding: var(--spacing-md) var(--spacing-lg);
+    border-radius: var(--radius-md);
+    box-shadow: var(--shadow-lg);
+    display: flex;
+    align-items: center;
+    gap: var(--spacing-md);
+    z-index: 1000;
+    animation: slideIn 0.3s ease-out;
+}
+
+@keyframes slideIn {
+    from {
+        transform: translateY(100%);
+        opacity: 0;
+    }
+    to {
+        transform: translateY(0);
+        opacity: 1;
+    }
+}
+
+.error-toast {
+    background-color: var(--color-danger);
+    color: var(--color-text-inverse);
+}
+
+.success-toast {
+    background-color: var(--color-success);
+    color: var(--color-text-inverse);
+}
+
+.toast-close {
+    background: none;
+    border: none;
+    color: inherit;
+    font-size: var(--font-size-lg);
+    cursor: pointer;
+    padding: 0;
+    line-height: 1;
+}
+
+/* ============================================================================
+   Modal
+   ============================================================================ */
+
+.modal {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    z-index: 1000;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.modal-overlay {
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background-color: rgba(0, 0, 0, 0.5);
+}
+
+.modal-content {
+    position: relative;
+    background-color: var(--color-surface);
+    border-radius: var(--radius-lg);
+    box-shadow: var(--shadow-lg);
+    max-width: 700px;
+    width: 90%;
+    max-height: 80vh;
+    overflow: hidden;
+    display: flex;
+    flex-direction: column;
+}
+
+.modal-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: var(--spacing-lg) var(--spacing-xl);
+    border-bottom: 1px solid var(--color-border);
+}
+
+.modal-header h3 {
+    font-size: var(--font-size-lg);
+    font-weight: var(--font-weight-semibold);
+}
+
+.modal-close {
+    background: none;
+    border: none;
+    font-size: var(--font-size-xl);
+    color: var(--color-text-secondary);
+    cursor: pointer;
+    padding: var(--spacing-xs);
+    line-height: 1;
+}
+
+.modal-close:hover {
+    color: var(--color-text-primary);
+}
+
+.modal-body {
+    padding: var(--spacing-xl);
+    overflow-y: auto;
+}
+
+.modal-section {
+    margin-bottom: var(--spacing-xl);
+}
+
+.modal-section:last-child {
+    margin-bottom: 0;
+}
+
+.modal-section h4 {
+    font-size: var(--font-size-sm);
+    font-weight: var(--font-weight-semibold);
+    color: var(--color-text-secondary);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    margin-bottom: var(--spacing-sm);
+}
+
+/* ============================================================================
+   Utility Classes
+   ============================================================================ */
+
+.hidden {
+    display: none !important;
+}
+
+.visually-hidden {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip: rect(0, 0, 0, 0);
+    white-space: nowrap;
+    border: 0;
+}
+
+/* ============================================================================
+   Responsive Design
+   ============================================================================ */
+
+@media (max-width: 1024px) {
+    .main-content {
+        flex-direction: column;
+    }
+
+    .sidebar {
+        width: 100%;
+    }
+
+    .sidebar-content {
+        flex-direction: row;
+        flex-wrap: wrap;
+        gap: var(--spacing-lg);
+    }
+
+    .sidebar-content .form-group {
+        flex: 1;
+        min-width: 200px;
+        margin-bottom: 0;
+    }
+
+    .sidebar-content .btn-full {
+        width: auto;
+    }
+}
+
+@media (max-width: 768px) {
+    .header-content {
+        flex-direction: column;
+        gap: var(--spacing-md);
+    }
+
+    .column-selectors {
+        grid-template-columns: 1fr;
+    }
+
+    .button-group {
+        flex-direction: column;
+    }
+
+    .btn {
+        width: 100%;
+    }
+
+    .sidebar-content {
+        flex-direction: column;
+    }
+
+    .sidebar-content .form-group {
+        min-width: 100%;
+    }
+
+    .sidebar-content .btn-full {
+        width: 100%;
+    }
+}
diff --git a/tests/sample_questionnaire_simple_headers_blanks.xlsx b/tests/sample_questionnaire_simple_headers_blanks.xlsx
new file mode 100644
index 0000000000000000000000000000000000000000..f324bb9d33641c206becf54b58e100f2e71a9f07
GIT binary patch
literal 5249
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
F{U7}MEa?CM

literal 0
HcmV?d00001

diff --git a/tests/sample_questionnaire_with_headers_and_blanks.xlsx b/tests/sample_questionnaire_with_headers_and_blanks.xlsx
new file mode 100644
index 0000000000000000000000000000000000000000..cf6def2a044154afb0f5074cd1d320f600d30cfd
GIT binary patch
literal 81438
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
AC;$Ke

literal 0
HcmV?d00001

diff --git a/tests/unit/test_sample_file_headers_blanks.py b/tests/unit/test_sample_file_headers_blanks.py
new file mode 100644
index 0000000..bddf941
--- /dev/null
+++ b/tests/unit/test_sample_file_headers_blanks.py
@@ -0,0 +1,164 @@
+"""Test the sample_questionnaire_simple_headers_blanks.xlsx file handling."""
+
+import pytest
+import sys
+import os
+import openpyxl
+
+# Add src to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
+
+from excel.loader import ExcelLoader
+
+
+class TestSampleFileHeadersBlanks:
+    """Test handling of sample file with section headers and blank rows."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.loader = ExcelLoader()
+        self.test_file = os.path.join(
+            os.path.dirname(__file__),
+            '..',
+            'sample_questionnaire_simple_headers_blanks.xlsx'
+        )
+        self.output_dir = '/tmp/test_sample_headers_blanks'
+        os.makedirs(self.output_dir, exist_ok=True)
+
+    def test_load_sample_file(self):
+        """Test that sample file loads correctly with headers and blanks skipped."""
+        workbook_data = self.loader.load_workbook(self.test_file)
+
+        # Should have 1 sheet
+        assert len(workbook_data.sheets) == 1
+
+        sheet = workbook_data.sheets[0]
+
+        # Should have loaded 9 questions (skipping section headers and blanks)
+        assert len(sheet.questions) == 9
+
+        # Verify expected questions
+        expected_questions = [
+            'What is your full name?',
+            'What is your email?',
+            'Describe your experience with cloud computing',
+            'What programming languages are you familiar with?',
+            'What specific Azure services have you worked with?',
+            'Have you implemented any AI/ML solutions using Azure?',
+            'Are there any other technical skills or certifications you would like to mention?',
+            'What are your availability and preferred working hours?',
+            'Please provide any additional comments or questions'
+        ]
+        assert sheet.questions == expected_questions
+
+        # Verify row indices are correct (skipping headers and blanks)
+        expected_row_indices = [4, 5, 9, 10, 14, 15, 19, 20, 21]
+        assert sheet.row_indices == expected_row_indices
+
+    def test_save_preserves_headers_and_blanks(self):
+        """Test that saving responses doesn't overwrite section headers or blank rows."""
+        # Load file
+        workbook_data = self.loader.load_workbook(self.test_file)
+        sheet = workbook_data.sheets[0]
+
+        # Add answers to all questions
+        answers = [
+            'John Doe',
+            'john.doe@example.com',
+            '5 years of experience with Azure, AWS, and GCP',
+            'Python, JavaScript, TypeScript, Go',
+            'Azure Functions, App Service, Cosmos DB, Cognitive Services',
+            'Yes, built a chatbot using Azure OpenAI',
+            'Azure Solutions Architect Expert certified',
+            'Monday-Friday 9am-5pm EST',
+            'Looking forward to contributing!'
+        ]
+        sheet.answers = answers
+
+        # Save to output file
+        output_path = os.path.join(self.output_dir, 'output_with_answers.xlsx')
+        self.loader.save_workbook(workbook_data, output_path)
+
+        # Verify output file structure
+        wb = openpyxl.load_workbook(output_path)
+        ws = wb.active
+
+        # Row 1: Headers should be unchanged
+        assert ws.cell(row=1, column=1).value == 'Question'
+        assert ws.cell(row=1, column=2).value == 'Response'
+
+        # Row 2: Section header should be unchanged and no response written
+        assert ws.cell(row=2, column=1).value == 'Section 1: Basic Information'
+        assert ws.cell(row=2, column=2).value is None
+
+        # Row 3: Blank row should remain blank
+        assert ws.cell(row=3, column=1).value is None
+        assert ws.cell(row=3, column=2).value is None
+
+        # Row 4-5: Questions with answers
+        assert ws.cell(row=4, column=1).value == 'What is your full name?'
+        assert ws.cell(row=4, column=2).value == 'John Doe'
+        assert ws.cell(row=5, column=1).value == 'What is your email?'
+        assert ws.cell(row=5, column=2).value == 'john.doe@example.com'
+
+        # Row 6: Blank row should remain blank
+        assert ws.cell(row=6, column=1).value is None
+        assert ws.cell(row=6, column=2).value is None
+
+        # Row 7: Section header should be unchanged and no response written
+        assert ws.cell(row=7, column=1).value == 'Section 2: Technical Background and Experience'
+        assert ws.cell(row=7, column=2).value is None
+
+        # Row 8: Blank row should remain blank
+        assert ws.cell(row=8, column=1).value is None
+        assert ws.cell(row=8, column=2).value is None
+
+        # Row 9-10: Questions with answers
+        assert ws.cell(row=9, column=1).value == 'Describe your experience with cloud computing'
+        assert ws.cell(row=9, column=2).value == '5 years of experience with Azure, AWS, and GCP'
+        assert ws.cell(row=10, column=1).value == 'What programming languages are you familiar with?'
+        assert ws.cell(row=10, column=2).value == 'Python, JavaScript, TypeScript, Go'
+
+        # Row 11: Blank row should remain blank
+        assert ws.cell(row=11, column=1).value is None
+        assert ws.cell(row=11, column=2).value is None
+
+        # Row 12: Section header should be unchanged and no response written
+        assert ws.cell(row=12, column=1).value == 'Section 3: Project-Specific Questions - Azure AI'
+        assert ws.cell(row=12, column=2).value is None
+
+        # Row 13: Blank row should remain blank
+        assert ws.cell(row=13, column=1).value is None
+        assert ws.cell(row=13, column=2).value is None
+
+        # Row 14-15: Questions with answers
+        assert ws.cell(row=14, column=1).value == 'What specific Azure services have you worked with?'
+        assert ws.cell(row=14, column=2).value == 'Azure Functions, App Service, Cosmos DB, Cognitive Services'
+        assert ws.cell(row=15, column=1).value == 'Have you implemented any AI/ML solutions using Azure?'
+        assert ws.cell(row=15, column=2).value == 'Yes, built a chatbot using Azure OpenAI'
+
+        # Row 16: Blank row should remain blank
+        assert ws.cell(row=16, column=1).value is None
+        assert ws.cell(row=16, column=2).value is None
+
+        # Row 17: Section header (decorated) should be unchanged and no response written
+        assert ws.cell(row=17, column=1).value == '--- Section 4: Additional Details ---'
+        assert ws.cell(row=17, column=2).value is None
+
+        # Row 18: Blank row should remain blank
+        assert ws.cell(row=18, column=1).value is None
+        assert ws.cell(row=18, column=2).value is None
+
+        # Row 19-21: Questions with answers
+        assert ws.cell(row=19, column=1).value == 'Are there any other technical skills or certifications you would like to mention?'
+        assert ws.cell(row=19, column=2).value == 'Azure Solutions Architect Expert certified'
+        assert ws.cell(row=20, column=1).value == 'What are your availability and preferred working hours?'
+        assert ws.cell(row=20, column=2).value == 'Monday-Friday 9am-5pm EST'
+        assert ws.cell(row=21, column=1).value == 'Please provide any additional comments or questions'
+        assert ws.cell(row=21, column=2).value == 'Looking forward to contributing!'
+
+        wb.close()
+
+
+if __name__ == '__main__':
+    pytest.main([__file__, '-v'])

From 4a82217ade2e31be33163e265880270b30df8f57 Mon Sep 17 00:00:00 2001
From: Marco Casalaina <mcasalaina@microsoft.com>
Date: Thu, 22 Jan 2026 15:37:36 -0500
Subject: [PATCH 5/6] Fix project_client access error in windowed mode

Fixed AgentExecutionError: Cannot access project_client from azure_client
that occurred when running the app in windowed mode with run_app.

Changes:
- Added project_client parameter to LinkCheckerExecutor
- Updated _resolve_connection_id to use provided project_client or fetch it
- Updated AgentCoordinator to pass project_client to link checker
- Fixed UI main_window.py to get and pass project_client for both single and parallel agent initialization

The AzureAIAgentClient doesn't expose project_client as a public attribute,
so we now pass it explicitly through the initialization chain.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
---
 src/agents/link_checker.py     | 26 ++++++++++++-----------
 src/agents/workflow_manager.py |  3 ++-
 src/ui/main_window.py          | 38 ++++++++++++++++++++--------------
 3 files changed, 38 insertions(+), 29 deletions(-)

diff --git a/src/agents/link_checker.py b/src/agents/link_checker.py
index 97d002c..b574df9 100644
--- a/src/agents/link_checker.py
+++ b/src/agents/link_checker.py
@@ -23,15 +23,18 @@
 class LinkCheckerExecutor(Executor):
     """Executor for the Link Checker agent in the multi-agent workflow."""
     
-    def __init__(self, azure_client: AzureAIAgentClient, browser_automation_connection_id: str):
+    def __init__(self, azure_client: AzureAIAgentClient, browser_automation_connection_id: str,
+                 project_client: Optional[AIProjectClient] = None):
         """Initialize the Link Checker executor.
-        
+
         Args:
             azure_client: Azure AI Agent client instance.
             browser_automation_connection_id: Browser automation connection name for web verification.
+            project_client: Azure AI Project client for connection resolution (optional).
         """
         super().__init__(id="link_checker")
         self.azure_client = azure_client
+        self.project_client = project_client
         self.browser_automation_connection_name = browser_automation_connection_id
         self.browser_automation_connection_id: Optional[str] = None
         self.agent: Optional[ChatAgent] = None
@@ -53,19 +56,18 @@ async def _resolve_connection_id(self) -> str:
         
         try:
             logger.debug(f"Resolving connection ID for: {self.browser_automation_connection_name}")
-            
-            # Get the AIProjectClient from the azure_client
-            # The azure_client is an AzureAIAgentClient which contains project_client
-            if hasattr(self.azure_client, 'project_client'):
-                project_client = self.azure_client.project_client
-            else:
-                raise AgentExecutionError("Cannot access project_client from azure_client")
-            
+
+            # Use the project_client that was passed during initialization
+            if self.project_client is None:
+                # If not provided, try to import and get it from azure_auth
+                from utils.azure_auth import get_project_client
+                self.project_client = await get_project_client()
+
             # Get the connection by name to retrieve its full ID
             # Note: connections.get() is async and must be awaited
-            connection = await project_client.connections.get(self.browser_automation_connection_name)
+            connection = await self.project_client.connections.get(self.browser_automation_connection_name)
             self.browser_automation_connection_id = connection.id
-            
+
             logger.debug(f"Resolved connection ID: {self.browser_automation_connection_id}")
             return self.browser_automation_connection_id
             
diff --git a/src/agents/workflow_manager.py b/src/agents/workflow_manager.py
index 8ff526f..a4f2b74 100644
--- a/src/agents/workflow_manager.py
+++ b/src/agents/workflow_manager.py
@@ -74,7 +74,8 @@ async def create_agents(self) -> None:
             logger.info("Creating link checker executor...")
             self.link_checker = LinkCheckerExecutor(
                 azure_client=self.azure_client,
-                browser_automation_connection_id=self.browser_automation_connection_id
+                browser_automation_connection_id=self.browser_automation_connection_id,
+                project_client=self.project_client
             )
             
             logger.info("Building workflow...")
diff --git a/src/ui/main_window.py b/src/ui/main_window.py
index 29fc329..f5647ca 100644
--- a/src/ui/main_window.py
+++ b/src/ui/main_window.py
@@ -1305,41 +1305,47 @@ def _initialize_agents_async(self) -> None:
     async def _create_agent_coordinator(self):
         """Create agent coordinator with proper initialization."""
         self.update_reasoning("Initializing Azure AI agents... (this may take 30-60 seconds)")
-        
+
         # Lazy import to avoid slow startup
-        from utils.azure_auth import get_azure_client
-        
+        from utils.azure_auth import get_azure_client, get_project_client
+
         azure_client = await get_azure_client()
+        project_client = await get_project_client()
         bing_connection_id = config_manager.get_bing_connection_id()
         browser_automation_connection_id = config_manager.get_browser_automation_connection_id()
-        
+
         from agents.workflow_manager import create_agent_coordinator
-        coordinator = await create_agent_coordinator(azure_client, bing_connection_id, 
-                                                     browser_automation_connection_id)
-        
+        coordinator = await create_agent_coordinator(
+            azure_client,
+            bing_connection_id,
+            browser_automation_connection_id,
+            project_client
+        )
+
         self.update_reasoning("Azure AI agents initialized successfully")
         return coordinator
     
     async def _create_spreadsheet_agent_coordinators(self):
         """Create 3 agent coordinators for parallel spreadsheet processing."""
         self.update_reasoning("Initializing 3 agent sets for parallel spreadsheet processing... (this may take 60-90 seconds)")
-        
+
         # Lazy import to avoid slow startup
-        from utils.azure_auth import get_azure_client
-        
+        from utils.azure_auth import get_azure_client, get_project_client
+
         azure_client = await get_azure_client()
+        project_client = await get_project_client()
         bing_connection_id = config_manager.get_bing_connection_id()
         browser_automation_connection_id = config_manager.get_browser_automation_connection_id()
-        
+
         from agents.workflow_manager import create_agent_coordinator
-        
+
         # Create 3 coordinators in parallel
         coordinators = await asyncio.gather(
-            create_agent_coordinator(azure_client, bing_connection_id, browser_automation_connection_id),
-            create_agent_coordinator(azure_client, bing_connection_id, browser_automation_connection_id),
-            create_agent_coordinator(azure_client, bing_connection_id, browser_automation_connection_id)
+            create_agent_coordinator(azure_client, bing_connection_id, browser_automation_connection_id, project_client),
+            create_agent_coordinator(azure_client, bing_connection_id, browser_automation_connection_id, project_client),
+            create_agent_coordinator(azure_client, bing_connection_id, browser_automation_connection_id, project_client)
         )
-        
+
         self.update_reasoning(f"✅ All 3 agent sets initialized successfully")
         return list(coordinators)
     

From d486d832e4da7788300d33e3514a34630e998f4a Mon Sep 17 00:00:00 2001
From: Marco Casalaina <mcasalaina@microsoft.com>
Date: Fri, 27 Mar 2026 13:05:24 -0700
Subject: [PATCH 6/6] Migrate from agent-framework b260107 to rc5 with Foundry
 v2 client

- Switch AzureAIAgentClient (Foundry v1, /assistants) to AzureAIClient (Foundry v2, /agents)
- ChatAgent -> RawAgent, ChatMessage -> Message
- Role.USER enum -> "user" string literal
- WorkflowBuilder: start_executor now a constructor param
- Workflow.run_stream() -> run(stream=True)
- Agent names: spaces -> kebab-case (v2 API requirement)
- Update imports from agent_framework_azure_ai to agent_framework.azure

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 MIGRATION_NOTES.md                   | 59 +++++++++++++++++++++
 src/agents/answer_checker.py         | 20 +++----
 src/agents/link_checker.py           | 20 +++----
 src/agents/question_answerer.py      | 22 ++++----
 src/agents/workflow_manager.py       | 27 ++++------
 src/excel/column_identifier.py       | 13 +++--
 src/excel/loader.py                  | 79 +++++++++++++---------------
 src/utils/azure_auth.py              | 23 ++++----
 src/web/app.py                       | 12 ++---
 tests/unit/test_column_identifier.py |  8 +--
 10 files changed, 164 insertions(+), 119 deletions(-)
 create mode 100644 MIGRATION_NOTES.md

diff --git a/MIGRATION_NOTES.md b/MIGRATION_NOTES.md
new file mode 100644
index 0000000..326ac84
--- /dev/null
+++ b/MIGRATION_NOTES.md
@@ -0,0 +1,59 @@
+# agent-framework rc5 Migration – Complete
+
+## Root Cause
+
+Two issues combined:
+
+1. The `agent-framework-azure-ai` package was upgraded from `1.0.0b260107` → `1.0.0rc5`, requiring API migration across the codebase.
+2. The `AzureAIAgentClient` (Foundry Agent Service v1) uses the `/assistants` API endpoint, which returns empty HTTP responses for `gpt-4.1` deployments — causing `JSONDecodeError: Expecting value: line 1 column 1 (char 0)`.
+
+## Fix Applied
+
+Migrated to **Foundry Agent Service v2** (`AzureAIClient`) which uses the `/agents` API endpoint, plus all rc5 API changes.
+
+**Packages installed:**
+- `agent-framework-azure-ai == 1.0.0rc5`
+- `agent-framework-core == 1.0.0rc5`
+- `azure-ai-agents == 1.2.0b5`
+
+## API Changes Applied
+
+| Old (b260107) | New (rc5) |
+|-----|-----|
+| `from agent_framework_azure_ai import AzureAIAgentClient` | `from agent_framework.azure import AzureAIClient` |
+| `AzureAIAgentClient(project_endpoint=..., credential=...)` | `AzureAIClient(project_endpoint=..., credential=..., model_deployment_name=...)` |
+| `ChatAgent(chat_client=client, name=..., instructions=...)` | `RawAgent(client, name=..., instructions=...)` |
+| `ChatMessage(role=Role.USER, text=...)` | `Message(role="user", text=...)` |
+| `Role.USER` (enum) | `"user"` (string literal) |
+| `WorkflowBuilder().set_start_executor(x).build()` | `WorkflowBuilder(start_executor=x).build()` |
+| `workflow.run_stream(data)` | `workflow.run(data, stream=True)` |
+| Agent names with spaces: `"Question Answerer"` | Kebab-case names: `"question-answerer"` |
+
+**Note:** `Role` changed from an enum to a `NewType` — use string literals `"user"` instead.
+
+**Note:** Agent names must be alphanumeric with hyphens, max 63 chars (Foundry v2 requirement).
+
+## Files Changed
+
+- `src/utils/azure_auth.py` — `AzureAIAgentClient` → `AzureAIClient` (import, type hints, constructors)
+- `src/agents/workflow_manager.py` — `AzureAIClient` import, `WorkflowBuilder(start_executor=...)`, `run(stream=True)`
+- `src/agents/question_answerer.py` — `RawAgent`, `Message`, `"user"` role, kebab-case name
+- `src/agents/answer_checker.py` — `RawAgent`, `Message`, `"user"` role, kebab-case name
+- `src/agents/link_checker.py` — `RawAgent`, `Message`, `"user"` role, kebab-case name
+- `src/excel/loader.py` — `AzureAIClient` import, kebab-case agent names
+- `src/excel/column_identifier.py` — `"user"` role string
+- `src/web/app.py` — `RawAgent` import, kebab-case agent name
+- `tests/unit/test_column_identifier.py` — Updated mock patches for `RawAgent`/`Message`
+
+## Current Status
+
+✅ **All migration changes applied and verified.**
+
+- Live test (`tests/test_live_azure_question.py`) passes end-to-end
+- 123 unit tests pass; 21 have pre-existing failures unrelated to this migration
+
+## How to Run
+
+```bash
+source .venv312/bin/activate && python run_app.py
+```
diff --git a/src/agents/answer_checker.py b/src/agents/answer_checker.py
index ce82c06..214c6d7 100644
--- a/src/agents/answer_checker.py
+++ b/src/agents/answer_checker.py
@@ -4,8 +4,8 @@
 import time
 import asyncio
 from typing import Any, Dict, Optional
-from agent_framework import Executor, handler, WorkflowContext, ChatAgent, ChatMessage, Role
-from agent_framework_azure_ai import AzureAIAgentClient
+from agent_framework import Executor, handler, WorkflowContext, RawAgent, Message
+from agent_framework.azure import AzureAIClient
 from utils.data_types import (
     Question, AgentStep, AgentType, StepStatus, ValidationStatus
 )
@@ -19,7 +19,7 @@
 class AnswerCheckerExecutor(Executor):
     """Executor for the Answer Checker agent in the multi-agent workflow."""
     
-    def __init__(self, azure_client: AzureAIAgentClient):
+    def __init__(self, azure_client: AzureAIClient):
         """Initialize the Answer Checker executor.
         
         Args:
@@ -27,14 +27,14 @@ def __init__(self, azure_client: AzureAIAgentClient):
         """
         super().__init__(id="answer_checker")
         self.azure_client = azure_client
-        self.agent: Optional[ChatAgent] = None
+        self.agent: Optional[RawAgent] = None
     
-    async def _get_agent(self) -> ChatAgent:
+    async def _get_agent(self) -> RawAgent:
         """Get or create the answer checker agent."""
         if self.agent is None:
-            self.agent = ChatAgent(
-                chat_client=self.azure_client,
-                name="Answer Checker",
+            self.agent = RawAgent(
+                self.azure_client,
+                name="answer-checker",
                 instructions="""You are an expert Answer Checker who validates the quality, accuracy, and completeness of generated answers. You must evaluate answers against strict quality standards.
 
 VALIDATION CRITERIA:
@@ -122,7 +122,7 @@ async def handle(self, data: dict, ctx: WorkflowContext[dict]) -> None:
                 
                 # Create validation prompt
                 validation_prompt = self._build_validation_prompt(question, raw_answer)
-                messages = [ChatMessage(role=Role.USER, text=validation_prompt)]
+                messages = [Message(role="user", text=validation_prompt)]
                 logger.info(f"📝 Built validation prompt ({len(validation_prompt)} chars), sending to agent...")
                 logger.info(f"🎯 Validation criteria: accuracy, completeness, {question.char_limit} char limit, plain text format")
                 
@@ -305,7 +305,7 @@ async def cleanup(self) -> None:
             logger.info("Cleaning up Answer Checker agent...")
             try:
                 # The Microsoft Agent Framework handles agent lifecycle automatically
-                # when the underlying AzureAIAgentClient is closed
+                # when the underlying AzureAIClient is closed
                 logger.debug("Answer Checker agent cleanup completed")
             except Exception as e:
                 logger.warning(f"Error during Answer Checker cleanup: {e}")
diff --git a/src/agents/link_checker.py b/src/agents/link_checker.py
index b574df9..0dc888b 100644
--- a/src/agents/link_checker.py
+++ b/src/agents/link_checker.py
@@ -5,8 +5,8 @@
 import asyncio
 import re
 from typing import Any, Dict, Optional
-from agent_framework import Executor, handler, WorkflowContext, ChatAgent, ChatMessage, Role
-from agent_framework_azure_ai import AzureAIAgentClient
+from agent_framework import Executor, handler, WorkflowContext, RawAgent, Message
+from agent_framework.azure import AzureAIClient
 from azure.ai.agents.models import BrowserAutomationTool
 from azure.ai.projects import AIProjectClient
 from utils.data_types import (
@@ -23,7 +23,7 @@
 class LinkCheckerExecutor(Executor):
     """Executor for the Link Checker agent in the multi-agent workflow."""
     
-    def __init__(self, azure_client: AzureAIAgentClient, browser_automation_connection_id: str,
+    def __init__(self, azure_client: AzureAIClient, browser_automation_connection_id: str,
                  project_client: Optional[AIProjectClient] = None):
         """Initialize the Link Checker executor.
 
@@ -37,7 +37,7 @@ def __init__(self, azure_client: AzureAIAgentClient, browser_automation_connecti
         self.project_client = project_client
         self.browser_automation_connection_name = browser_automation_connection_id
         self.browser_automation_connection_id: Optional[str] = None
-        self.agent: Optional[ChatAgent] = None
+        self.agent: Optional[RawAgent] = None
     
     async def _resolve_connection_id(self) -> str:
         """Resolve the full connection ID from the connection name.
@@ -76,7 +76,7 @@ async def _resolve_connection_id(self) -> str:
             logger.error(error_msg, exc_info=True)
             raise AgentExecutionError(error_msg) from e
     
-    async def _get_agent(self) -> ChatAgent:
+    async def _get_agent(self) -> RawAgent:
         """Get or create the link checker agent with Browser Automation tool."""
         if self.agent is None:
             # Resolve the full connection ID from the connection name
@@ -87,10 +87,10 @@ async def _get_agent(self) -> ChatAgent:
                 connection_id=connection_id
             )
             
-            self.agent = ChatAgent(
-                chat_client=self.azure_client,
-                tools=browser_tool.definitions,  # Use .definitions property for ChatAgent
-                name="Link Checker",
+            self.agent = RawAgent(
+                self.azure_client,
+                tools=browser_tool.definitions,  # Use .definitions property for RawAgent
+                name="link-checker",
                 instructions="""You are an expert Link Checker who validates documentation URLs for accuracy and relevance.
 
 Your role is to verify that provided links are accessible and contain information that is pertinent to the response content.
@@ -211,7 +211,7 @@ async def handle(self, data: dict, ctx: WorkflowContext[dict, dict]) -> None:
                 validation_prompt = self._build_link_validation_prompt(
                     question, raw_answer, answer_sources
                 )
-                messages = [ChatMessage(role=Role.USER, text=validation_prompt)]
+                messages = [Message(role="user", text=validation_prompt)]
                 
                 # Run the agent to get link validation result using browser automation
                 response = await agent.run(messages)
diff --git a/src/agents/question_answerer.py b/src/agents/question_answerer.py
index 9971586..29be52f 100644
--- a/src/agents/question_answerer.py
+++ b/src/agents/question_answerer.py
@@ -4,8 +4,8 @@
 import time
 import asyncio
 from typing import Any, Dict, Optional
-from agent_framework import Executor, handler, WorkflowContext, ChatAgent, ChatMessage, Role
-from agent_framework_azure_ai import AzureAIAgentClient
+from agent_framework import Executor, handler, WorkflowContext, RawAgent, Message
+from agent_framework.azure import AzureAIClient
 from azure.core.exceptions import ResourceNotFoundError
 from utils.data_types import Question, AgentStep, AgentType, StepStatus
 from utils.logger import log_agent_step, create_span
@@ -18,7 +18,7 @@
 class QuestionAnswererExecutor(Executor):
     """Executor for the Question Answerer agent in the multi-agent workflow."""
     
-    def __init__(self, azure_client: AzureAIAgentClient, bing_connection_id: str):
+    def __init__(self, azure_client: AzureAIClient, bing_connection_id: str):
         """Initialize the Question Answerer executor.
         
         Args:
@@ -28,17 +28,17 @@ def __init__(self, azure_client: AzureAIAgentClient, bing_connection_id: str):
         super().__init__(id="question_answerer")
         self.azure_client = azure_client
         self.bing_connection_id = bing_connection_id
-        self.agent: Optional[ChatAgent] = None
+        self.agent: Optional[RawAgent] = None
     
-    async def _get_agent(self) -> ChatAgent:
+    async def _get_agent(self) -> RawAgent:
         """Get or create the question answerer agent."""
         if self.agent is None:
             # Create the agent and track its ID for cleanup
             try:
-                # Create ChatAgent directly with Azure client
-                self.agent = ChatAgent(
-                    chat_client=self.azure_client,
-                    name="Question Answerer",
+                # Create RawAgent directly with Azure client
+                self.agent = RawAgent(
+                    self.azure_client,
+                    name="question-answerer",
                     instructions="""You are an expert Question Answerer who provides comprehensive, accurate answers to technical questions. Use web search to find current, authoritative information.
 
 REQUIREMENTS:
@@ -113,7 +113,7 @@ async def handle(self, question: Question, ctx: WorkflowContext[dict]) -> None:
                 
                 # Create the question message with context
                 question_prompt = self._build_question_prompt(question)
-                messages = [ChatMessage(role=Role.USER, text=question_prompt)]
+                messages = [Message(role="user", text=question_prompt)]
                 logger.info(f"📝 Built question prompt ({len(question_prompt)} chars), sending to agent...")
                 logger.info(f"💬 Prompt preview: {question_prompt[:200]}...")
                 
@@ -348,7 +348,7 @@ async def cleanup(self) -> None:
             logger.info("Cleaning up Question Answerer agent...")
             try:
                 # The Microsoft Agent Framework handles agent lifecycle automatically
-                # when the underlying AzureAIAgentClient is closed
+                # when the underlying AzureAIClient is closed
                 logger.debug("Question Answerer agent cleanup completed")
             except Exception as e:
                 logger.warning(f"Error during Question Answerer cleanup: {e}")
diff --git a/src/agents/workflow_manager.py b/src/agents/workflow_manager.py
index a4f2b74..ffd193a 100644
--- a/src/agents/workflow_manager.py
+++ b/src/agents/workflow_manager.py
@@ -5,7 +5,7 @@
 import asyncio
 from typing import Any, Dict, List, Optional, Callable
 from agent_framework import WorkflowBuilder, Workflow
-from agent_framework_azure_ai import AzureAIAgentClient
+from agent_framework.azure import AzureAIClient
 from utils.data_types import (
     Question, Answer, ProcessingResult, AgentStep, 
     ValidationStatus, HealthStatus, DocumentationLink
@@ -27,7 +27,7 @@
 class AgentCoordinator:
     """Orchestrates multi-agent workflow using Microsoft Agent Framework."""
     
-    def __init__(self, azure_client: AzureAIAgentClient, bing_connection_id: str,
+    def __init__(self, azure_client: AzureAIClient, bing_connection_id: str,
                  browser_automation_connection_id: str, project_client=None):
         """Initialize the agent coordinator.
 
@@ -81,10 +81,9 @@ async def create_agents(self) -> None:
             logger.info("Building workflow...")
             # Build the sequential workflow
             self.workflow = (
-                WorkflowBuilder()
+                WorkflowBuilder(start_executor=self.question_answerer)
                 .add_edge(self.question_answerer, self.answer_checker)
                 .add_edge(self.answer_checker, self.link_checker)
-                .set_start_executor(self.question_answerer)
                 .build()
             )
             
@@ -143,24 +142,18 @@ async def process_question(
                     if reasoning_callback:
                         reasoning_callback(verbose_msg)
                     
-                    logger.info(f"🎯 Calling workflow.run_stream() with question: '{question.text}'")
-                    event_stream = self.workflow.run_stream(question)
-                    
-                    # Process streaming events to track agent execution
-                    from agent_framework import (
-                        ExecutorInvokedEvent, ExecutorCompletedEvent,
-                        AgentRunUpdateEvent, WorkflowOutputEvent
-                    )
+                    logger.info(f"🎯 Calling workflow.run() with question: '{question.text}'")
+                    event_stream = self.workflow.run(question, stream=True)
                     
                     outputs = []
                     current_agent = None
                     
                     async for event in event_stream:
                         # Debug log every event
-                        logger.debug(f"📨 Workflow event received: {type(event).__name__}")
+                        logger.debug(f"📨 Workflow event received: {event.type}")
                         
                         # Track when an executor STARTS processing
-                        if isinstance(event, ExecutorInvokedEvent):
+                        if event.type == 'executor_invoked':
                             agent_id = event.executor_id
                             logger.info(f"🎯 Executor STARTED: executor_id='{agent_id}'")
                             
@@ -176,11 +169,11 @@ async def process_question(
                                 progress_callback(agent_id, "Processing...", 0.5)
                         
                         # Track when an executor COMPLETES
-                        elif isinstance(event, ExecutorCompletedEvent):
+                        elif event.type == 'executor_completed':
                             logger.info(f"✅ Executor COMPLETED: executor_id='{event.executor_id}'")
                         
                         # Check if this is the final output event
-                        if isinstance(event, WorkflowOutputEvent):
+                        if event.type == 'output':
                             outputs.append(event.data)
                     
                     # Add verbose logging for workflow result
@@ -453,7 +446,7 @@ async def cleanup_agents(self) -> None:
             logger.warning(f"Error during agent cleanup: {e}")
 
 
-async def create_agent_coordinator(azure_client: AzureAIAgentClient, bing_connection_id: str,
+async def create_agent_coordinator(azure_client: AzureAIClient, bing_connection_id: str,
                                   browser_automation_connection_id: str, project_client=None) -> AgentCoordinator:
     """Create and initialize an agent coordinator.
 
diff --git a/src/excel/column_identifier.py b/src/excel/column_identifier.py
index 78a7ef0..e7e74c5 100644
--- a/src/excel/column_identifier.py
+++ b/src/excel/column_identifier.py
@@ -54,7 +54,7 @@ def _identify_with_ai_sync(self, headers: List[str]) -> Dict[str, Optional[int]]
         """
         # Lazy import to avoid dependency issues
         try:
-            from agent_framework import ChatAgent, ChatMessage, Role
+            from agent_framework import RawAgent, Message
         except ImportError:
             logger.warning("agent_framework not available, falling back to heuristics")
             return self._identify_with_heuristics(headers)
@@ -87,17 +87,16 @@ def _identify_with_ai_sync(self, headers: List[str]) -> Dict[str, Optional[int]]
     
     async def _identify_with_ai_async_helper(self, headers: List[str], prompt: str) -> Dict[str, Optional[int]]:
         """Async helper for AI identification."""
-        from agent_framework import ChatAgent, ChatMessage, Role
+        from agent_framework import RawAgent, Message
         
-        agent = ChatAgent(
-            chat_client=self.azure_client,
+        agent = RawAgent(
+            self.azure_client,
             instructions="""You are a column identification expert. Analyze spreadsheet headers 
             and identify which columns contain Questions, Responses, and Documentation. 
-            Always respond with valid JSON only.""",
-            model="gpt-4o-mini"
+            Always respond with valid JSON only."""
         )
         
-        messages = [ChatMessage(role=Role.USER, content=prompt)]
+        messages = [Message(role="user", text=prompt)]
         response = await agent.invoke(messages)
         
         # Parse the AI response
diff --git a/src/excel/loader.py b/src/excel/loader.py
index d53c903..e73ccc0 100644
--- a/src/excel/loader.py
+++ b/src/excel/loader.py
@@ -322,9 +322,8 @@ async def do_header_detection():
 
     async def _ask_llm_for_header_row(self, prompt: str) -> str:
         """Ask LLM to identify header row."""
-        from agent_framework import ChatAgent
-        from agent_framework_azure_ai import AzureAIAgentClient
-        from azure.ai.projects.aio import AIProjectClient
+        from agent_framework import RawAgent
+        from agent_framework.azure import AzureAIClient
         from azure.identity.aio import DefaultAzureCredential
         from utils.config import config_manager
 
@@ -333,21 +332,16 @@ async def _ask_llm_for_header_row(self, prompt: str) -> str:
         model_deployment = config_manager.get_model_deployment()
         credential = DefaultAzureCredential()
 
-        project_client = AIProjectClient(
-            endpoint=endpoint,
-            credential=credential
-        )
-
-        azure_client = AzureAIAgentClient(
-            project_client=project_client,
+        azure_client = AzureAIClient(
+            project_endpoint=endpoint,
             credential=credential,
             model_deployment_name=model_deployment
         )
 
-        # Create a ChatAgent for this task
-        agent = ChatAgent(
-            chat_client=azure_client,
-            name="Header Row Identifier",
+        # Create a RawAgent for this task
+        agent = RawAgent(
+            azure_client,
+            name="header-row-identifier",
             instructions="You are a data analysis assistant that identifies column headers in spreadsheets."
         )
 
@@ -395,25 +389,25 @@ def _filter_questions_with_llm(self, rows: List[dict], sheet_name: str) -> List[
 
 Your task: Identify which rows contain items that need to be answered in a questionnaire.
 
-EXCLUDE ONLY these types of rows:
-- Pure section titles with no content expectation (e.g., "Platform Overview", "Section 1: Background")
-- Instructional text for the entire section (e.g., "Answer all questions below", "Provide details in Column C")
-- Decorative separators (e.g., "---", "===", "***")
+CRITICAL EXCLUSION RULES - You MUST exclude these:
+1. Short section headers (1-3 words) that organize the questionnaire into categories
+   Examples to EXCLUDE: "Platform Overview", "Competitive Positioning", "Technical Capabilities"
+2. Instructional text (e.g., "Answer all questions below", "Provide details in Column C")
+3. Decorative separators (e.g., "---", "===", "***")
 
-INCLUDE these types of rows (these ALL need answers):
-- Direct questions (e.g., "What is your platform name?", "Do you support training?")
-- Imperative prompts (e.g., "Describe your capabilities", "List your differentiators", "Explain how...")
-- Feature/capability items in a checklist format (e.g., "Automated ML pipeline orchestration", "Feature store support")
-- Any statement that expects the user to provide information, even if not phrased as a question
-- Items that would have a yes/no, description, or details as an answer
+INCLUSION RULES - You MUST include these:
+1. Direct questions (e.g., "What is your platform name?", "Do you support training?")
+2. Imperative prompts (e.g., "Describe your capabilities", "List your differentiators")
+3. Feature/capability items in checklists (e.g., "Automated ML pipeline orchestration")
+4. Any row that expects information/details/yes/no as an answer
 
-IMPORTANT RULES:
-- If it's a feature, capability, or technical item that expects a response (yes/no/details), INCLUDE it
-- If it's just organizing the questionnaire into sections without expecting an answer, EXCLUDE it
-- When in doubt, INCLUDE it (be permissive, not restrictive)
+HOW TO DECIDE:
+- If the text is just 1-3 words with no verb and looks like a category label → EXCLUDE
+- If the text asks for something, describes something to do, or is a feature to check → INCLUDE
+- Section headers like "Overview", "Background", "Positioning" are NEVER questions → EXCLUDE
 
 Respond with ONLY a JSON array of the row numbers (from the original "Row X" labels) that need answers.
-Example response format: [4, 5, 9, 10, 14]
+Example response format: [7, 9, 10, 14, 16]
 
 If none of the rows need answers, respond with: []"""
 
@@ -427,6 +421,7 @@ async def do_filtering():
             # Parse JSON response
             import json
             try:
+                logger.info(f"LLM filtering response: {result.strip()[:500]}")  # Log first 500 chars
                 question_row_nums = json.loads(result.strip())
                 if not isinstance(question_row_nums, list):
                     logger.warning(f"LLM returned invalid format, using all rows")
@@ -434,7 +429,11 @@ async def do_filtering():
 
                 # Filter to only rows with matching row numbers
                 filtered = [r for r in rows if r['row_num'] in question_row_nums]
+                excluded = [r for r in rows if r['row_num'] not in question_row_nums]
                 logger.info(f"LLM filtered {len(rows)} rows down to {len(filtered)} questions in sheet '{sheet_name}'")
+                if excluded:
+                    excluded_text = ", ".join([f"Row {r['row_num']}: {r['text'][:30]}" for r in excluded[:5]])
+                    logger.info(f"Excluded rows: {excluded_text}")
                 return filtered
 
             except json.JSONDecodeError as e:
@@ -447,9 +446,8 @@ async def do_filtering():
 
     async def _ask_llm_for_filtering(self, prompt: str) -> str:
         """Ask LLM to identify which rows are actual questions."""
-        from agent_framework import ChatAgent
-        from agent_framework_azure_ai import AzureAIAgentClient
-        from azure.ai.projects.aio import AIProjectClient
+        from agent_framework import RawAgent
+        from agent_framework.azure import AzureAIClient
         from azure.identity.aio import DefaultAzureCredential
         from utils.config import config_manager
 
@@ -458,21 +456,16 @@ async def _ask_llm_for_filtering(self, prompt: str) -> str:
         model_deployment = config_manager.get_model_deployment()
         credential = DefaultAzureCredential()
 
-        project_client = AIProjectClient(
-            endpoint=endpoint,
-            credential=credential
-        )
-
-        azure_client = AzureAIAgentClient(
-            project_client=project_client,
+        azure_client = AzureAIClient(
+            project_endpoint=endpoint,
             credential=credential,
             model_deployment_name=model_deployment
         )
 
-        # Create a ChatAgent for this task
-        agent = ChatAgent(
-            chat_client=azure_client,
-            name="Question Filter",
+        # Create a RawAgent for this task
+        agent = RawAgent(
+            azure_client,
+            name="question-filter",
             instructions="You are a data analysis assistant that identifies actual questions in questionnaires, distinguishing them from section titles and labels."
         )
 
diff --git a/src/utils/azure_auth.py b/src/utils/azure_auth.py
index 84a0c84..cc13c22 100644
--- a/src/utils/azure_auth.py
+++ b/src/utils/azure_auth.py
@@ -19,13 +19,13 @@
 from .exceptions import AuthenticationError, AzureServiceError
 
 # Set AZURE_AI_PROJECT_ENDPOINT from AZURE_OPENAI_ENDPOINT if not already set
-# The agent_framework_azure_ai SDK expects this environment variable
+# The agent_framework.azure SDK expects this environment variable
 if not os.environ.get("AZURE_AI_PROJECT_ENDPOINT"):
     endpoint = config_manager.get_azure_endpoint()
     if endpoint:
         os.environ["AZURE_AI_PROJECT_ENDPOINT"] = endpoint
 
-from agent_framework_azure_ai import AzureAIAgentClient
+from agent_framework.azure import AzureAIClient
 
 
 logger = logging.getLogger(__name__)
@@ -127,9 +127,10 @@ async def _verify_credential(self, credential) -> None:
         
         # Create a temporary client to test the credential
         try:
-            test_client = AzureAIAgentClient(
+            test_client = AzureAIClient(
                 project_endpoint=config_manager.get_azure_endpoint(),
-                credential=credential
+                credential=credential,
+                model_deployment_name=config_manager.get_model_deployment()
             )
             # Test basic connectivity - this will trigger authentication
             # Note: This might fail if the endpoint is invalid, but that's a different error
@@ -139,11 +140,11 @@ async def _verify_credential(self, credential) -> None:
             logger.debug(f"Credential verification failed: {e}")
             raise ClientAuthenticationError("Failed to verify Azure credential") from e
     
-    async def get_azure_client(self) -> AzureAIAgentClient:
+    async def get_azure_client(self) -> AzureAIClient:
         """Get authenticated Azure AI Agent client.
         
         Returns:
-            Configured AzureAIAgentClient instance.
+            Configured AzureAIClient instance.
             
         Raises:
             AuthenticationError: If authentication fails.
@@ -172,8 +173,8 @@ async def get_azure_client(self) -> AzureAIAgentClient:
                 credential=credential
             )
             
-            self._client = AzureAIAgentClient(
-                project_client=self._project_client,
+            self._client = AzureAIClient(
+                project_endpoint=endpoint,
                 credential=credential,
                 model_deployment_name=model_deployment
             )
@@ -234,7 +235,7 @@ async def foundry_agent_session():
     This ensures proper resource management for Azure AI agents and threads.
     
     Yields:
-        AzureAIAgentClient: Authenticated client for agent operations.
+        AzureAIClient: Authenticated client for agent operations.
         
     Raises:
         AuthenticationError: If authentication fails.
@@ -342,13 +343,13 @@ async def verify_azure_connectivity() -> bool:
         raise AzureServiceError(f"Failed to verify Azure connectivity: {e}") from e
 
 
-async def get_azure_client() -> AzureAIAgentClient:
+async def get_azure_client() -> AzureAIClient:
     """Get authenticated Azure AI Agent client.
 
     This is a convenience function for getting the global client instance.
 
     Returns:
-        Configured AzureAIAgentClient instance.
+        Configured AzureAIClient instance.
 
     Raises:
         AuthenticationError: If authentication fails.
diff --git a/src/web/app.py b/src/web/app.py
index bd191dd..33e9545 100644
--- a/src/web/app.py
+++ b/src/web/app.py
@@ -452,7 +452,7 @@ def _get_sheet_data(file_path: str, sheet, columns: list) -> list:
 async def _identify_columns(workbook_data, columns: dict = None) -> ColumnSuggestions:
     """Identify likely question/answer columns using Azure AI LLM.
 
-    Uses ChatAgent to ask the LLM to identify which columns contain questions,
+    Uses RawAgent to ask the LLM to identify which columns contain questions,
     responses, and documentation based on the column headers.
     """
     if not workbook_data.sheets:
@@ -486,16 +486,16 @@ async def _identify_columns(workbook_data, columns: dict = None) -> ColumnSugges
     # Use Azure AI LLM for column identification
     try:
         from utils.azure_auth import get_azure_client
-        from agent_framework import ChatAgent
+        from agent_framework import RawAgent
         import json
         import re
 
         azure_client = await get_azure_client()
 
-        # Create a ChatAgent for column identification
-        agent = ChatAgent(
-            chat_client=azure_client,
-            name="Column Identifier",
+        # Create a RawAgent for column identification
+        agent = RawAgent(
+            azure_client,
+            name="column-identifier",
             instructions="""You are a column identification expert. Your job is to analyze spreadsheet column headers and identify which columns contain:
 1. Questions - the column with questions to be answered
 2. Responses/Answers - the column where answers should be written
diff --git a/tests/unit/test_column_identifier.py b/tests/unit/test_column_identifier.py
index 0df2871..84c240e 100644
--- a/tests/unit/test_column_identifier.py
+++ b/tests/unit/test_column_identifier.py
@@ -144,8 +144,8 @@ async def test_identify_with_ai_success(self):
         mock_agent.invoke = AsyncMock(return_value=mock_response)
         
         # Patch the imports where they are used (inside the method)
-        with patch('agent_framework.ChatAgent', return_value=mock_agent):
-            with patch('agent_framework.ChatMessage'):
+        with patch('agent_framework.RawAgent', return_value=mock_agent):
+            with patch('agent_framework.Message'):
                 with patch('agent_framework.Role'):
                     identifier = ColumnIdentifier(azure_client=mock_client)
                     headers = ['Status', 'Owner', 'Q#', 'Question', 'Response', 'Documentation']
@@ -167,8 +167,8 @@ async def test_identify_with_ai_invalid_json(self):
         mock_agent = Mock()
         mock_agent.invoke = AsyncMock(return_value=mock_response)
         
-        with patch('agent_framework.ChatAgent', return_value=mock_agent):
-            with patch('agent_framework.ChatMessage'):
+        with patch('agent_framework.RawAgent', return_value=mock_agent):
+            with patch('agent_framework.Message'):
                 with patch('agent_framework.Role'):
                     identifier = ColumnIdentifier(azure_client=mock_client)
                     headers = ['Status', 'Question', 'Response']