Fix Population Analysis bugs: question persistence and position detection

- Fix example questions clearing when clicking Run button
- Store question in persistent session state (current_question)
- Update state on every text area change to prevent clearing

- Improve position detection accuracy in analyzer
- Weight first/last sentences more heavily (positions typically stated there)
- Add strong phrase matching ("i support", "i oppose", "i don't support")
- Handle negations properly (don't count "don't support" as "support")
- Use scoring system: strong phrases weight=3, regular keywords weight=1
- Reduces mislabeling of sample support/oppose responses

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

pages/2_📊_Population_Analysis.py

@@ -149,27 +149,28 @@ st.sidebar.info(f"""
 **Population:** {population_size} variants
 """)
 
+# Initialize question in session state if not exists
+if "current_question" not in st.session_state:
+    st.session_state.current_question = ""
+
 # Main content
 col1, col2 = st.columns([2, 1])
 
 with col1:
     st.markdown("### 💭 Question")
 
-    # Use example question if set
-    if "example_question" in st.session_state:
-        default_question = st.session_state.example_question
-        del st.session_state.example_question
-    else:
-        default_question = ""
-
     question = st.text_area(
         "Ask your question to the population:",
-        value=default_question,
+        value=st.session_state.current_question,
         placeholder="e.g., Should we build the 500-unit luxury condo tower downtown?",
         height=100,
-        label_visibility="collapsed"
+        label_visibility="collapsed",
+        key="question_input"
     )
 
+    # Update session state when question changes
+    st.session_state.current_question = question
+
     run_analysis = st.button(
         "🚀 Query Population",
         type="primary",
@@ -179,13 +180,13 @@ with col1:
 with col2:
     st.markdown("### 📝 Quick Examples")
     if st.button("Luxury condos?", use_container_width=True):
-        st.session_state.example_question = "Should we build a 500-unit luxury condo tower downtown?"
+        st.session_state.current_question = "Should we build a 500-unit luxury condo tower downtown?"
         st.rerun()
     if st.button("Bike lanes?", use_container_width=True):
-        st.session_state.example_question = "Should we add protected bike lanes on Main Street?"
+        st.session_state.current_question = "Should we add protected bike lanes on Main Street?"
         st.rerun()
     if st.button("Food trucks?", use_container_width=True):
-        st.session_state.example_question = "Should we allow food trucks in the downtown plaza?"
+        st.session_state.current_question = "Should we allow food trucks in the downtown plaza?"
         st.rerun()
 
 st.markdown("---")

src/population/analyzer.py

@@ -213,11 +213,43 @@ class ResponseAnalyzer:
         )
 
     def _detect_position(self, text: str) -> Tuple[Position, float]:
-        """Detect position from text with confidence score"""
-        # Count keyword matches
+        """Detect position from text with confidence score - improved accuracy"""
+
+        # Strong indicators - look at first and last sentences (where positions are usually stated)
+        sentences = text.split('.')
+        first_sentence = sentences[0].lower() if sentences else ""
+        last_sentence = sentences[-1].lower() if len(sentences) > 1 else ""
+
+        # Check for clear positive statements in key positions
+        strong_support_phrases = [
+            "i support", "i agree", "i approve", "i favor", "i endorse",
+            "strongly support", "strongly agree", "in favor of",
+            "this is a good", "this is beneficial", "i'm excited"
+        ]
+        strong_oppose_phrases = [
+            "i oppose", "i disagree", "i reject", "i'm against",
+            "strongly oppose", "strongly disagree", "i cannot support",
+            "i don't support", "i can't support", "this is a bad",
+            "i'm concerned", "i'm worried", "i must oppose"
+        ]
+
+        # Check first and last sentences for strong indicators (weighted heavily)
+        first_last_text = first_sentence + " " + last_sentence
+        support_score = 0
+        oppose_score = 0
+
+        for phrase in strong_support_phrases:
+            if phrase in first_last_text:
+                support_score += 3  # Strong weight for clear statements
+
+        for phrase in strong_oppose_phrases:
+            if phrase in first_last_text:
+                oppose_score += 3  # Strong weight for clear statements
+
+        # Count keyword matches in full text (lower weight)
         support_count = sum(
             1 for keyword in self.SUPPORT_KEYWORDS
-            if keyword in text
+            if keyword in text and not any(neg in text for neg in ["don't " + keyword, "can't " + keyword, "won't " + keyword])
         )
         oppose_count = sum(
             1 for keyword in self.OPPOSE_KEYWORDS
@@ -228,26 +260,30 @@ class ResponseAnalyzer:
             if keyword in text
         )
 
-        total_matches = support_count + oppose_count + neutral_count
+        # Combine scores
+        support_score += support_count
+        oppose_score += oppose_count
+
+        total_score = support_score + oppose_score + neutral_count
 
-        if total_matches == 0:
+        if total_score == 0:
             return Position.UNCLEAR, 0.0
 
         # Determine dominant position
-        if support_count > oppose_count and support_count > neutral_count:
-            confidence = support_count / max(total_matches, 1)
-            if support_count >= 3:
+        if support_score > oppose_score and support_score > neutral_count:
+            confidence = support_score / max(total_score, 1)
+            if support_score >= 5:
                 return Position.STRONGLY_SUPPORT, min(confidence, 1.0)
             return Position.SUPPORT, min(confidence, 1.0)
 
-        elif oppose_count > support_count and oppose_count > neutral_count:
-            confidence = oppose_count / max(total_matches, 1)
-            if oppose_count >= 3:
+        elif oppose_score > support_score and oppose_score > neutral_count:
+            confidence = oppose_score / max(total_score, 1)
+            if oppose_score >= 5:
                 return Position.STRONGLY_OPPOSE, min(confidence, 1.0)
             return Position.OPPOSE, min(confidence, 1.0)
 
         elif neutral_count > 0:
-            confidence = neutral_count / max(total_matches, 1)
+            confidence = neutral_count / max(total_score, 1)
             return Position.NEUTRAL, min(confidence, 1.0)
 
         return Position.UNCLEAR, 0.3