Update conversation_logic.py

conversation_logic.py

@@ -172,6 +172,80 @@ def _looks_like_question_text(text: str) -> bool:
     )
 
 
+def _is_topic_query(text: str) -> bool:
+    low = _clean_text(text).lower()
+    if not low:
+        return False
+    return any(
+        phrase in low
+        for phrase in [
+            "what topic is this question",
+            "what topic is this",
+            "what is the topic of this question",
+            "what type of question is this",
+            "what kind of question is this",
+            "what area is this",
+            "what concept is this",
+            "what concept is this testing",
+            "what skill is this testing",
+            "identify the topic",
+            "identify the concept",
+        ]
+    )
+
+
+def _specific_topic_from_question(question_text: str, fallback_topic: str, classified_topic: str) -> str:
+    q = _clean_text(question_text).lower()
+    topic = (fallback_topic or classified_topic or "general").lower()
+
+    if any(k in q for k in ["variability", "spread", "standard deviation"]):
+        return "variability"
+    if any(k in q for k in ["mean", "average"]):
+        return "mean"
+    if "median" in q:
+        return "median"
+    if "range" in q:
+        return "range"
+    if topic == "data" and any(k in q for k in ["dataset", "table", "chart", "graph"]):
+        return "statistics"
+    return topic
+
+
+def _build_topic_query_reply(question_text: str, fallback_topic: str, classified_topic: str, category: str) -> str:
+    specific = _specific_topic_from_question(question_text, fallback_topic, classified_topic)
+    cat = (category or "").strip()
+
+    if specific == "variability":
+        return (
+            "- This is a statistics / data insight question about variability (spread).\n"
+            "- The key idea is to compare how spread out each dataset is, not which one has the biggest average.\n"
+            "- A good first move is to compare how far the outer values sit from the middle value in each set."
+        )
+    if specific == "statistics":
+        return (
+            "- This is a statistics / data insight question.\n"
+            "- The key skill is spotting which statistical idea matters most, then comparing the answer choices using that idea."
+        )
+    if specific == "algebra":
+        return (
+            "- This is an algebra question.\n"
+            "- The key skill is rewriting the relationship cleanly, then simplifying the expression the question actually asks for."
+        )
+    if specific == "ratio":
+        return (
+            "- This is a ratio question.\n"
+            "- The key skill is turning the ratio into consistent parts and then building the requested expression from those parts."
+        )
+    if specific == "percent":
+        return (
+            "- This is a percent question.\n"
+            "- The key skill is identifying the correct base quantity before applying the percent relationship."
+        )
+
+    label = specific if specific != "general" else (cat.lower() if cat else "quantitative reasoning")
+    return f"- This looks like a {label} question."
+
+
 def _classify_input_type(raw_user_text: str) -> str:
     text = _clean_text(raw_user_text).lower()
     if not text:
@@ -704,6 +778,76 @@ class ConversationEngine:
         result.meta["explainer_understood"] = explainer_understood
         result.meta["explainer_scaffold"] = explainer_scaffold
 
+        if input_type == "topic_query":
+            support_topic = fallback_pack.get("topic") if fallback_pack else ""
+            topic_reply_core = _build_topic_query_reply(
+                question_text=solver_input,
+                fallback_topic=support_topic,
+                classified_topic=question_topic if question_topic else "general",
+                category=inferred_category if inferred_category else "General",
+            )
+            reply = format_reply(
+                topic_reply_core,
+                tone=tone,
+                verbosity=verbosity,
+                transparency=transparency,
+                help_mode="answer",
+                hint_stage=hint_stage,
+                topic=support_topic or question_topic or result.topic,
+            )
+            result.topic = support_topic or question_topic or result.topic
+            result.reply = reply
+            result.help_mode = "answer"
+            result.meta["response_source"] = "topic_classifier"
+            result.meta["question_support_used"] = bool(fallback_pack)
+            result.meta["question_support_source"] = fallback_pack.get("support_source") if fallback_pack else None
+            result.meta["question_support_topic"] = support_topic or None
+            result.meta["help_mode"] = "answer"
+            result.meta["intent"] = "topic_query"
+            result.meta["question_text"] = solver_input or ""
+            result.meta["options_count"] = len(options_text or [])
+            result.meta["category"] = inferred_category if inferred_category else "General"
+            result.meta["user_last_input_type"] = input_type
+            result.meta["built_on_previous_turn"] = built_on_previous_turn
+            state = _update_session_state(
+                state,
+                question_text=solver_input,
+                question_id=question_id,
+                hint_stage=hint_stage,
+                user_last_input_type=input_type,
+                built_on_previous_turn=built_on_previous_turn,
+                help_mode="answer",
+                intent="topic_query",
+                topic=result.topic,
+                category=inferred_category,
+            )
+            result.meta["session_state"] = state
+            result.meta["used_retrieval"] = False
+            result.meta["used_generator"] = False
+            result.meta["can_reveal_answer"] = False
+            result.answer_letter = None
+            result.answer_value = None
+            result.internal_answer = None
+            result.meta["internal_answer"] = None
+            return result
+
+        if fallback_pack and fallback_pack.get("topic") == "statistics":
+            qlow = (solver_input or "").lower()
+            wants_topic = input_type == "topic_query"
+            if any(k in qlow for k in ["variability", "spread", "standard deviation"]):
+                if wants_topic:
+                    fallback_reply_core = (
+                        "- This is a statistics / data insight question about variability (spread).\n"
+                        "- Focus on how spread out each dataset is rather than the average.\n"
+                        "- Compare how far the outer values sit from the middle value in each set."
+                    )
+                elif resolved_help_mode == "answer":
+                    fallback_reply_core = (
+                        "- Notice this is asking about variability, which means spread, not the mean.\n"
+                        "- Compare how far the smallest and largest values sit from the middle value in each dataset.\n"
+                        "- The set with the widest spread has the greatest variability."
+                    )
+
         # Source selection priority:
         # 1) question-specific fallback for help modes
         # 2) explainer for explain when specific support is unavailable
@@ -755,6 +899,7 @@ class ConversationEngine:
             resolved_help_mode == "answer"
             and solver_has_steps
             and result.meta.get("solver_topic_rejected") is None
+            and direct_solve_request
         ):
             reply_core = _answer_path_from_steps(solver_steps, verbosity=verbosity)
             result.meta["response_source"] = "solver_steps"
@@ -859,4 +1004,4 @@ class ConversationEngine:
         result.meta["session_state"] = state
         result.meta["used_retrieval"] = False
         result.meta["used_generator"] = False
-        return result
+        return result