Update conversation_logic.py

conversation_logic.py

@@ -4,15 +4,15 @@ import re
 from typing import Any, Dict, List, Optional, Tuple
 
 from context_parser import detect_intent, intent_to_help_mode
-from formatting import format_reply, format_explainer_response
+from formatting import format_explainer_response, format_reply
 from generator_engine import GeneratorEngine
 from models import RetrievedChunk, SolverResult
 from quant_solver import is_quant_question
-from solver_router import route_solver
-from explainers.explainer_router import route_explainer
 from question_classifier import classify_question, normalize_category
+from question_fallback_router import question_fallback_router
 from retrieval_engine import RetrievalEngine
-
+from solver_router import route_solver
+from explainers.explainer_router import route_explainer
 
 DIRECT_SOLVE_PATTERNS = [
     r"\bsolve\b",
@@ -54,83 +54,29 @@ def _clean_text(text: Optional[str]) -> str:
 
 
 def _safe_get_state(session_state: Optional[Dict[str, Any]]) -> Dict[str, Any]:
-    if isinstance(session_state, dict):
-        return dict(session_state)
-    return {}
-
-
-def _extract_text_from_history_item(item: Dict[str, Any]) -> str:
-    if not isinstance(item, dict):
-        return ""
-
-    direct_keys = ("content", "text", "message", "question_text", "raw_user_text")
-    for key in direct_keys:
-        value = item.get(key)
-        if isinstance(value, str) and value.strip():
-            return value.strip()
-
-    meta = item.get("meta")
-    if isinstance(meta, dict):
-        for key in ("question_text", "recovered_question_text"):
-            value = meta.get(key)
-            if isinstance(value, str) and value.strip():
-                return value.strip()
-
-        nested_state = meta.get("session_state")
-        if isinstance(nested_state, dict):
-            value = nested_state.get("question_text")
-            if isinstance(value, str) and value.strip():
-                return value.strip()
-
-    nested_state = item.get("session_state")
-    if isinstance(nested_state, dict):
-        value = nested_state.get("question_text")
-        if isinstance(value, str) and value.strip():
-            return value.strip()
-
-    return ""
+    return dict(session_state) if isinstance(session_state, dict) else {}
 
 
 def _extract_question_candidates_from_history_item(item: Dict[str, Any]) -> List[str]:
     if not isinstance(item, dict):
         return []
-
     candidates: List[str] = []
-
-    direct_keys = ("question_text", "raw_user_text", "content", "text", "message")
-    for key in direct_keys:
+    for key in ("question_text", "raw_user_text", "content", "text", "message"):
         value = item.get(key)
         if isinstance(value, str) and value.strip():
             candidates.append(value.strip())
-
     meta = item.get("meta")
     if isinstance(meta, dict):
         for key in ("question_text", "recovered_question_text"):
             value = meta.get(key)
             if isinstance(value, str) and value.strip():
                 candidates.append(value.strip())
-
         nested_state = meta.get("session_state")
         if isinstance(nested_state, dict):
             value = nested_state.get("question_text")
             if isinstance(value, str) and value.strip():
                 candidates.append(value.strip())
-
-    nested_state = item.get("session_state")
-    if isinstance(nested_state, dict):
-        value = nested_state.get("question_text")
-        if isinstance(value, str) and value.strip():
-            candidates.append(value.strip())
-
-    deduped: List[str] = []
-    seen = set()
-    for candidate in candidates:
-        key = candidate.strip().lower()
-        if key and key not in seen:
-            seen.add(key)
-            deduped.append(candidate.strip())
-
-    return deduped
+    return candidates
 
 
 def _is_followup_hint_only(text: str) -> bool:
@@ -160,13 +106,11 @@ def _strip_control_prefix(text: str) -> str:
     cleaned = (text or "").strip()
     if not cleaned:
         return ""
-
     previous = None
     while previous != cleaned:
         previous = cleaned
         for pattern in CONTROL_PREFIX_PATTERNS:
             cleaned = re.sub(pattern, "", cleaned, flags=re.I).strip()
-
     return cleaned
 
 
@@ -174,131 +118,48 @@ def _sanitize_question_text(text: str) -> str:
     raw = (text or "").strip()
     if not raw:
         return ""
-
     lines = [line.strip() for line in raw.splitlines() if line.strip()]
-
-    if len(lines) >= 9 and re.fullmatch(r"-?\d+", lines[2]) and lines[4].lower() in {"true", "false"}:
-        return _strip_control_prefix(lines[1])
-
-    if len(lines) >= 2 and lines[0].lower() in {
-        "hint", "next hint", "another hint", "continue", "go on",
-        "walkthrough", "step by step", "solve", "explain", "method"
-    }:
-        return _strip_control_prefix(lines[1])
-
     for line in lines:
         candidate = _strip_control_prefix(line)
-        if not candidate:
-            continue
-        if (
-            "=" in candidate
-            or "%" in candidate
-            or re.search(r"\b(probability|ratio|percent|integer|triangle|circle|mean|median)\b", candidate.lower())
-            or re.search(r"[a-zA-Z]\s*[\+\-\*/=]", candidate)
-            or re.search(r"[\+\-\*/=]\s*[a-zA-Z0-9]", candidate)
-        ):
+        if candidate and not _is_followup_hint_only(candidate):
             return candidate
-
-    return _strip_control_prefix(lines[0] if lines else raw)
-
-
-def _extract_question_text(raw_user_text: str) -> str:
-    text = _clean_text(raw_user_text)
-    return _strip_control_prefix(text)
+    return _strip_control_prefix(raw)
 
 
 def _looks_like_question_text(text: str) -> bool:
     t = (text or "").strip()
     if not t:
         return False
-
     low = t.lower()
-
-    if "=" in t:
-        return True
-    if "%" in t:
-        return True
-    if re.search(r"\b\d+\s*:\s*\d+\b", t):
-        return True
-    if re.search(r"[a-zA-Z]\s*[\+\-\*/=]", t):
-        return True
-    if re.search(r"[\+\-\*/=]\s*[a-zA-Z0-9]", t):
-        return True
-    if any(k in low for k in [
-        "what is", "find", "if ", "how many", "probability", "ratio",
-        "percent", "equation", "integer", "triangle", "circle",
-        "mean", "median", "average", "remainder", "prime", "factor",
-    ]):
-        return True
-
-    return False
+    return any(
+        [
+            "=" in t,
+            "%" in t,
+            bool(re.search(r"\b\d+\s*:\s*\d+\b", t)),
+            bool(re.search(r"[a-zA-Z]\s*[\+\-\*/=]", t)),
+            any(k in low for k in [
+                "what is", "find", "if ", "how many", "probability", "ratio",
+                "percent", "equation", "integer", "triangle", "circle",
+                "mean", "median", "average", "remainder", "prime", "factor",
+            ]),
+        ]
+    )
 
 
 def _classify_input_type(raw_user_text: str) -> str:
-    text = _clean_text(raw_user_text)
+    text = _clean_text(raw_user_text).lower()
     if not text:
         return "empty"
-
-    lines = [line.strip() for line in text.splitlines() if line.strip()]
-    first = lines[0].lower() if lines else text.lower().strip()
-    t = text.lower().strip()
-
-    structured_map = {
-        "solve": "solve",
-        "hint": "hint",
-        "next hint": "next_hint",
-        "another hint": "next_hint",
-        "walkthrough": "confusion",
-        "step by step": "confusion",
-        "continue": "next_hint",
-        "go on": "next_hint",
-    }
-    if first in structured_map:
-        return structured_map[first]
-
-    if t.startswith("hint:"):
+    if text in {"hint", "a hint", "give me a hint", "can i have a hint"} or text.startswith("hint:"):
         return "hint"
-    if t.startswith("next hint:") or t.startswith("another hint:"):
+    if text in {"next hint", "another hint", "more hint", "more hints", "next step", "continue", "go on"} or text.startswith("next hint:"):
         return "next_hint"
-    if t.startswith("walkthrough:") or t.startswith("step by step:"):
+    if any(x in text for x in ["walkthrough", "step by step", "i'm confused", "im confused", "confused", "explain more", "help me understand"]):
         return "confusion"
-    if t.startswith("solve:") or t.startswith("solve "):
+    if text.startswith("solve:") or text.startswith("solve "):
         return "solve"
-
-    if t in {"hint", "a hint", "give me a hint", "can i have a hint"}:
-        return "hint"
-
-    if t in {"next hint", "another hint", "more hint", "more hints", "next step", "continue", "go on"}:
-        return "next_hint"
-
-    if any(x in t for x in [
-        "i don't get it",
-        "i dont get it",
-        "i do not get it",
-        "i'm confused",
-        "im confused",
-        "confused",
-        "explain more",
-        "more explanation",
-        "can you explain that",
-        "help me understand",
-        "walk me through it",
-        "walkthrough",
-        "step by step",
-    ]):
-        return "confusion"
-
-    stripped = _strip_control_prefix(text)
-
-    if "=" in stripped and re.search(r"[A-Za-z]", stripped):
+    if _looks_like_question_text(_strip_control_prefix(raw_user_text)):
         return "question"
-
-    if any(k in stripped.lower() for k in [
-        "what is", "find", "if ", "how many", "probability", "ratio",
-        "percent", "equation", "integer"
-    ]):
-        return "question"
-
     return "other"
 
 
@@ -307,135 +168,74 @@ def _is_followup_input(input_type: str) -> bool:
 
 
 def _history_hint_stage(chat_history: Optional[List[Dict[str, Any]]]) -> int:
-    if not chat_history:
-        return 0
-
     best = 0
-    for item in chat_history:
+    for item in chat_history or []:
         if not isinstance(item, dict):
             continue
-
-        if "hint_stage" in item:
-            try:
-                best = max(best, int(item["hint_stage"]))
-            except Exception:
-                pass
-
+        try:
+            best = max(best, int(item.get("hint_stage", 0) or 0))
+        except Exception:
+            pass
         meta = item.get("meta")
-        if isinstance(meta, dict) and "hint_stage" in meta:
+        if isinstance(meta, dict):
             try:
-                best = max(best, int(meta["hint_stage"]))
+                best = max(best, int(meta.get("hint_stage", 0) or 0))
             except Exception:
                 pass
-
-        if isinstance(meta, dict):
             nested_state = meta.get("session_state")
-            if isinstance(nested_state, dict) and "hint_stage" in nested_state:
+            if isinstance(nested_state, dict):
                 try:
-                    best = max(best, int(nested_state["hint_stage"]))
+                    best = max(best, int(nested_state.get("hint_stage", 0) or 0))
                 except Exception:
                     pass
-
     return min(best, 3)
 
 
-def _recover_question_text(
-    raw_user_text: str,
-    question_text: Optional[str],
-    chat_history: Optional[List[Dict[str, Any]]],
-    input_type: str,
-) -> str:
+def _recover_question_text(raw_user_text: str, question_text: Optional[str], chat_history: Optional[List[Dict[str, Any]]], input_type: str) -> str:
     explicit = _sanitize_question_text(question_text or "")
     if explicit:
         return explicit
-
-    direct_candidate = _sanitize_question_text(_extract_question_text(raw_user_text))
+    direct_candidate = _sanitize_question_text(raw_user_text)
     if direct_candidate and _looks_like_question_text(direct_candidate):
         return direct_candidate
-
     if not _is_followup_input(input_type):
         return direct_candidate
-
-    if not chat_history:
-        return ""
-
-    for item in reversed(chat_history):
-        candidates = _extract_question_candidates_from_history_item(item)
-        for candidate in candidates:
+    for item in reversed(chat_history or []):
+        for candidate in _extract_question_candidates_from_history_item(item):
             recovered = _sanitize_question_text(candidate)
-            if not recovered:
-                continue
-            if _is_followup_hint_only(recovered):
-                continue
-            if _looks_like_question_text(recovered):
+            if recovered and not _is_followup_hint_only(recovered) and _looks_like_question_text(recovered):
                 return recovered
-
-            extracted = _sanitize_question_text(_extract_question_text(recovered))
-            if extracted and not _is_followup_hint_only(extracted) and _looks_like_question_text(extracted):
-                return extracted
-
     return ""
 
 
-def _choose_effective_question_text(
-    raw_user_text: str,
-    question_text: Optional[str],
-    input_type: str,
-    state: Dict[str, Any],
-    chat_history: Optional[List[Dict[str, Any]]],
-) -> Tuple[str, bool]:
+def _choose_effective_question_text(raw_user_text: str, question_text: Optional[str], input_type: str, state: Dict[str, Any], chat_history: Optional[List[Dict[str, Any]]]) -> Tuple[str, bool]:
     explicit_question = _sanitize_question_text(question_text or "")
     stored_question = _sanitize_question_text(state.get("question_text", ""))
-
     if _is_followup_input(input_type):
         if explicit_question and _looks_like_question_text(explicit_question):
             return explicit_question, False
-
-        direct_candidate = _sanitize_question_text(_extract_question_text(raw_user_text))
+        direct_candidate = _sanitize_question_text(raw_user_text)
         if direct_candidate and _looks_like_question_text(direct_candidate):
             return direct_candidate, False
-
         if stored_question and _looks_like_question_text(stored_question):
             return stored_question, True
-
-        recovered = _recover_question_text(
-            raw_user_text=raw_user_text,
-            question_text=question_text,
-            chat_history=chat_history,
-            input_type=input_type,
-        )
-        if recovered:
-            return recovered, True
-
-        return "", True
-
+        recovered = _recover_question_text(raw_user_text, question_text, chat_history, input_type)
+        return recovered, True
     if explicit_question:
         return explicit_question, False
+    return _sanitize_question_text(raw_user_text), False
 
-    return _sanitize_question_text(_extract_question_text(raw_user_text)), False
-
-
-def _compute_hint_stage(
-    input_type: str,
-    prior_hint_stage: int,
-    fallback_history_stage: int = 0,
-) -> int:
-    prior = int(prior_hint_stage or 0)
-    history = int(fallback_history_stage or 0)
-    base = max(prior, history)
 
+def _compute_hint_stage(input_type: str, prior_hint_stage: int, fallback_history_stage: int = 0) -> int:
+    base = max(int(prior_hint_stage or 0), int(fallback_history_stage or 0))
     if input_type in {"solve", "question"}:
         return 0
-
     if input_type == "hint":
         return min(max(1, base if base > 0 else 1), 3)
-
     if input_type == "next_hint":
         return min((base if base > 0 else 1) + 1, 3)
-
     if input_type == "confusion":
         return 3
-
     return min(base, 3)
 
 
@@ -443,6 +243,7 @@ def _update_session_state(
     state: Dict[str, Any],
     *,
     question_text: str,
+    question_id: Optional[str],
     hint_stage: int,
     user_last_input_type: str,
     built_on_previous_turn: bool,
@@ -453,6 +254,8 @@ def _update_session_state(
 ) -> Dict[str, Any]:
     if question_text:
         state["question_text"] = question_text
+    if question_id:
+        state["question_id"] = question_id
     state["hint_stage"] = int(hint_stage or 0)
     state["user_last_input_type"] = user_last_input_type
     state["built_on_previous_turn"] = bool(built_on_previous_turn)
@@ -467,7 +270,6 @@ def _normalize_classified_topic(topic: Optional[str], category: Optional[str], q
     t = (topic or "").strip().lower()
     q = (question_text or "").lower()
     c = normalize_category(category)
-
     has_ratio_form = bool(re.search(r"\b\d+\s*:\s*\d+\b", q))
     has_algebra_form = (
         "=" in q
@@ -475,38 +277,28 @@ def _normalize_classified_topic(topic: Optional[str], category: Optional[str], q
         or bool(re.search(r"\d+[a-z]\b", q))
         or bool(re.search(r"\b[a-z]\s*[\+\-\*/=]", q))
     )
-
     if has_algebra_form:
         return "algebra"
-
-    if t == "ratio" and not has_ratio_form and has_algebra_form:
-        t = "algebra"
-
     if t not in {"general_quant", "general", "unknown", ""}:
         return t
-
     if "%" in q or "percent" in q:
         return "percent"
     if "ratio" in q or has_ratio_form:
         return "ratio"
-    if "probability" in q or "chosen at random" in q or "odds" in q or "chance" in q:
+    if any(k in q for k in ["probability", "chosen at random", "odds", "chance"]):
         return "probability"
-    if "divisible" in q or "remainder" in q or "prime" in q or "factor" in q:
+    if any(k in q for k in ["divisible", "remainder", "prime", "factor"]):
         return "number_theory"
     if any(k in q for k in ["circle", "triangle", "perimeter", "area", "circumference"]):
         return "geometry"
-    if any(k in q for k in ["mean", "median", "average", "sales", "revenue"]):
+    if any(k in q for k in ["mean", "median", "average"]):
         return "statistics" if c == "Quantitative" else "data"
-    if has_algebra_form or "what is x" in q or "what is y" in q or "integer" in q:
-        return "algebra"
-
     if c == "DataInsight":
         return "data"
     if c == "Verbal":
         return "verbal"
     if c == "Quantitative":
         return "quant"
-
     return "general"
 
 
@@ -515,7 +307,6 @@ def _strip_bullet_prefix(text: str) -> str:
 
 
 def _safe_steps(steps: List[str]) -> List[str]:
-    cleaned: List[str] = []
     banned_patterns = [
         r"\bthe answer is\b",
         r"\banswer:\b",
@@ -530,7 +321,7 @@ def _safe_steps(steps: List[str]) -> List[str]:
         r"\bresult is\b",
         r"\bfinal answer\b",
     ]
-
+    cleaned: List[str] = []
     for step in steps:
         s = _strip_bullet_prefix(step)
         lowered = s.lower()
@@ -538,15 +329,13 @@ def _safe_steps(steps: List[str]) -> List[str]:
             continue
         if s:
             cleaned.append(s)
-
     deduped: List[str] = []
     seen = set()
     for step in cleaned:
-        key = step.strip().lower()
+        key = step.lower().strip()
         if key and key not in seen:
             seen.add(key)
-            deduped.append(step.strip())
-
+            deduped.append(step)
     return deduped
 
 
@@ -572,10 +361,8 @@ def _safe_meta_text(value: Any) -> Optional[str]:
 
 def _extract_explainer_scaffold(explainer_result: Any) -> Dict[str, Any]:
     scaffold = getattr(explainer_result, "scaffold", None)
-
     if scaffold is None:
         return {}
-
     return {
         "concept": _safe_meta_text(getattr(scaffold, "concept", None)),
         "ask": _safe_meta_text(getattr(scaffold, "ask", None)),
@@ -599,199 +386,69 @@ def _get_result_steps(result: SolverResult) -> List[str]:
     display_steps = getattr(result, "display_steps", None)
     if isinstance(display_steps, list) and display_steps:
         return _safe_steps(display_steps)
-
     result_steps = getattr(result, "steps", None)
     if isinstance(result_steps, list) and result_steps:
         return _safe_steps(result_steps)
-
     meta = getattr(result, "meta", {}) or {}
     meta_display_steps = meta.get("display_steps")
     if isinstance(meta_display_steps, list) and meta_display_steps:
         return _safe_steps(meta_display_steps)
-
     meta_steps = meta.get("steps")
     if isinstance(meta_steps, list) and meta_steps:
         return _safe_steps(meta_steps)
-
     return []
 
 
 def _apply_safe_step_sanitization(result: SolverResult) -> None:
     safe_steps = _get_result_steps(result)
-
     result.steps = list(safe_steps)
     setattr(result, "display_steps", list(safe_steps))
-
     result.meta = result.meta or {}
     result.meta["steps"] = list(safe_steps)
     result.meta["display_steps"] = list(safe_steps)
 
 
 def _solver_has_useful_steps(result: Optional[SolverResult]) -> bool:
-    if result is None:
-        return False
-    return len(_get_result_steps(result)) > 0
-
-
-def _build_hint_from_steps(
-    steps: List[str],
-    hint_stage: int,
-    fallback: Optional[List[str]] = None,
-) -> str:
-    safe_steps = _safe_steps(steps)
-    stage = max(1, min(int(hint_stage or 1), 3))
-
-    if safe_steps:
-        index = min(stage - 1, len(safe_steps) - 1)
-        return f"- {safe_steps[index]}"
-
-    fallback = _safe_steps(fallback or [])
-    if fallback:
-        index = min(stage - 1, len(fallback) - 1)
-        return f"- {fallback[index]}"
-
-    return "- Start by identifying the main relationship in the problem."
-
-
-def _walkthrough_from_steps(steps: List[str], verbosity: float) -> str:
-    safe_steps = _safe_steps(steps)
-    if not safe_steps:
-        return ""
-
-    shown_steps = (
-        safe_steps[:2] if verbosity < 0.25 else
-        safe_steps[:3] if verbosity < 0.6 else
-        safe_steps[:4] if verbosity < 0.85 else
-        safe_steps
-    )
-    return "\n".join(f"- {step}" for step in shown_steps)
+    return bool(result is not None and _get_result_steps(result))
 
 
 def _answer_path_from_steps(steps: List[str], verbosity: float) -> str:
     safe_steps = _safe_steps(steps)
     if not safe_steps:
         return ""
-
-    shown_steps = (
-        safe_steps[:2] if verbosity < 0.35 else
-        safe_steps[:3] if verbosity < 0.8 else
-        safe_steps
-    )
+    shown_steps = safe_steps[:2] if verbosity < 0.35 else safe_steps[:3] if verbosity < 0.8 else safe_steps
     return "\n".join(f"- {step}" for step in shown_steps)
 
 
-def _compose_reply(
-    result: SolverResult,
-    intent: str,
+def _build_fallback_reply(
+    *,
+    question_id: Optional[str],
+    question_text: str,
+    options_text: Optional[List[str]],
+    topic: Optional[str],
+    category: Optional[str],
+    help_mode: str,
+    hint_stage: int,
     verbosity: float,
-    category: Optional[str] = None,
-    hint_stage: int = 0,
-    explainer_scaffold: Optional[Dict[str, Any]] = None,
-) -> str:
-    steps = _get_result_steps(result)
-    topic = (result.topic or "").lower()
-    scaffold = explainer_scaffold or {}
-    scaffold_hint_ladder = _safe_meta_list(scaffold.get("hint_ladder", []))
-
-    if intent == "hint":
-        return _build_hint_from_steps(steps, hint_stage=hint_stage, fallback=scaffold_hint_ladder)
-
-    if intent == "instruction":
-        if steps:
-            return f"- {steps[0]}"
-        return "- First, identify the key relationship or comparison in the question."
-
-    if intent == "definition":
-        if steps:
-            return f"- {steps[0]}"
-        return "- This is asking for the meaning of the term or idea in the question."
-
-    if intent in {"walkthrough", "step_by_step"}:
-        step_reply = _walkthrough_from_steps(steps, verbosity=verbosity)
-        if step_reply:
-            return step_reply
-
-        if topic == "algebra":
-            return "\n".join([
-                "- Start with the equation exactly as written.",
-                "- Identify the operation attached to the variable.",
-                "- Apply the inverse operation to both sides.",
-                "- Continue until the variable is isolated.",
-            ])
-
-        if topic == "percent":
-            return "\n".join([
-                "- Identify the base quantity and the percent relationship.",
-                "- Rewrite the percent as a fraction or decimal.",
-                "- Set up the equation before simplifying.",
-                "- Isolate the requested quantity carefully.",
-            ])
-
-        if topic == "ratio":
-            return "\n".join([
-                "- Keep the ratio order consistent.",
-                "- Write each part using the same multiplier.",
-                "- Use the total or known part to solve for that multiplier.",
-                "- Substitute back to get the requested quantity.",
-            ])
-
-        if topic == "probability":
-            return "\n".join([
-                "- Count the successful outcomes.",
-                "- Count all possible outcomes.",
-                "- Write probability as successful over total.",
-                "- Simplify only at the end if needed.",
-            ])
-
-        return "\n".join([
-            "- Start with the structure of the problem.",
-            "- Identify the relationship being tested.",
-            "- Set up the needed equation or comparison.",
-            "- Work forward one step at a time.",
-        ])
-
-    if intent in {"explain", "method", "concept", "answer"}:
-        step_reply = _answer_path_from_steps(steps, verbosity=verbosity)
-        if step_reply:
-            return step_reply
-
-        if topic == "algebra":
-            return "\n".join([
-                "- Identify the operation attached to the variable.",
-                "- Use the inverse operation on both sides.",
-            ])
-
-        if topic == "percent":
-            return "\n".join([
-                "- Identify the base quantity.",
-                "- Set up the percent relationship before calculating.",
-            ])
-
-        if topic == "ratio":
-            return "\n".join([
-                "- Keep the ratio order consistent.",
-                "- Express each part using the same multiplier.",
-            ])
-
-        if topic == "probability":
-            return "\n".join([
-                "- Count the successful outcomes.",
-                "- Count all possible outcomes.",
-            ])
-
-    if normalize_category(category) == "Verbal":
-        return "I can help analyse the wording or logic, but I need the full question text to guide you properly."
-
-    if normalize_category(category) == "DataInsight":
-        return "I can help reason through the data, but I need the full question or chart details to guide you properly."
-
-    return "Start by identifying the main relationship in the problem."
+) -> Tuple[str, Dict[str, Any]]:
+    payload = question_fallback_router.build_response(
+        question_id=question_id,
+        question_text=question_text,
+        options_text=options_text,
+        topic=topic,
+        category=category,
+        help_mode=help_mode,
+        hint_stage=hint_stage,
+        verbosity=verbosity,
+    )
+    lines = payload.get("lines") or ["Start by identifying the main relationship in the problem."]
+    pack = payload.get("pack") or {}
+    return "\n".join(f"- {line}" for line in lines if str(line).strip()), pack
 
 
 def _is_direct_solve_request(text: str, intent: str) -> bool:
     if intent == "answer":
         return True
-
     t = re.sub(r"\s+", " ", (text or "").strip().lower())
     if any(re.search(p, t) for p in DIRECT_SOLVE_PATTERNS):
         if not any(word in t for word in ["how", "explain", "why", "method", "hint", "define", "definition", "step"]):
@@ -800,12 +457,7 @@ def _is_direct_solve_request(text: str, intent: str) -> bool:
 
 
 class ConversationEngine:
-    def __init__(
-        self,
-        retriever: Optional[RetrievalEngine] = None,
-        generator: Optional[GeneratorEngine] = None,
-        **kwargs,
-    ) -> None:
+    def __init__(self, retriever: Optional[RetrievalEngine] = None, generator: Optional[GeneratorEngine] = None, **kwargs) -> None:
         self.retriever = retriever
         self.generator = generator
 
@@ -821,13 +473,12 @@ class ConversationEngine:
         chat_history: Optional[List[Dict[str, Any]]] = None,
         question_text: Optional[str] = None,
         options_text: Optional[List[str]] = None,
+        question_id: Optional[str] = None,
         session_state: Optional[Dict[str, Any]] = None,
         **kwargs,
     ) -> SolverResult:
-        
         user_text = _clean_text(raw_user_text)
         state = _safe_get_state(session_state)
-
         input_type = _classify_input_type(user_text)
 
         effective_question_text, built_on_previous_turn = _choose_effective_question_text(
@@ -837,24 +488,18 @@ class ConversationEngine:
             state=state,
             chat_history=chat_history,
         )
-        
         if _is_followup_input(input_type):
             built_on_previous_turn = True
-        
+
         solver_input = _sanitize_question_text(effective_question_text)
+        question_id = question_id or state.get("question_id")
 
         category = normalize_category(kwargs.get("category"))
         classification = classify_question(question_text=solver_input, category=category)
         inferred_category = normalize_category(classification.get("category") or category)
-
-        question_topic = _normalize_classified_topic(
-            classification.get("topic"),
-            inferred_category,
-            solver_input,
-        )
+        question_topic = _normalize_classified_topic(classification.get("topic"), inferred_category, solver_input)
 
         resolved_intent = intent or detect_intent(user_text, help_mode)
-
         if input_type in {"hint", "next_hint"}:
             resolved_intent = "hint"
         elif input_type == "confusion":
@@ -862,11 +507,7 @@ class ConversationEngine:
         elif input_type in {"solve", "question"} and resolved_intent in {"hint", "walkthrough", "step_by_step"}:
             resolved_intent = "answer"
 
-        if help_mode:
-            resolved_help_mode = help_mode
-        else:
-            resolved_help_mode = intent_to_help_mode(resolved_intent)
-
+        resolved_help_mode = help_mode or intent_to_help_mode(resolved_intent)
         if input_type in {"hint", "next_hint"}:
             resolved_help_mode = "hint"
         elif input_type == "confusion":
@@ -874,27 +515,17 @@ class ConversationEngine:
 
         prior_hint_stage = int(state.get("hint_stage", 0) or 0)
         history_hint_stage = _history_hint_stage(chat_history)
-        
-        hint_stage = _compute_hint_stage(
-            input_type=input_type,
-            prior_hint_stage=prior_hint_stage,
-            fallback_history_stage=history_hint_stage,
-        )
+        hint_stage = _compute_hint_stage(input_type, prior_hint_stage, history_hint_stage)
 
-        is_quant = bool(solver_input) and (
-            inferred_category == "Quantitative" or is_quant_question(solver_input)
-        )
+        is_quant = bool(solver_input) and (inferred_category == "Quantitative" or is_quant_question(solver_input))
 
         result = SolverResult(
             domain="quant" if is_quant else "general",
             solved=False,
             help_mode=resolved_help_mode,
-            answer_letter=None,
-            answer_value=None,
             topic=question_topic if is_quant else "general",
             used_retrieval=False,
             used_generator=False,
-            internal_answer=None,
             steps=[],
             teaching_chunks=[],
             meta={},
@@ -902,48 +533,53 @@ class ConversationEngine:
 
         solver_result: Optional[SolverResult] = None
         if is_quant and resolved_help_mode in {"answer", "walkthrough", "instruction", "hint"}:
-            solver_result = route_solver(solver_input)
+            try:
+                solver_result = route_solver(solver_input)
+            except Exception:
+                solver_result = None
             if solver_result is not None:
-                original_meta = result.meta or {}
                 result = solver_result
                 result.domain = "quant"
                 result.meta = result.meta or {}
-                result.meta.update(original_meta)
-
                 if not result.topic or result.topic in {"general_quant", "general", "unknown"}:
                     result.topic = question_topic
 
         _apply_safe_step_sanitization(result)
+        solver_steps = _get_result_steps(result)
 
-        explainer_result = route_explainer(solver_input) if solver_input else None
-        explainer_understood = bool(
-            explainer_result is not None and getattr(explainer_result, "understood", False)
-        )
-        explainer_meta = (getattr(explainer_result, "meta", {}) or {}) if explainer_understood else {}
-        explainer_scaffold = _extract_explainer_scaffold(explainer_result) if explainer_understood else {}
-        explainer_summary = getattr(explainer_result, "summary", None) if explainer_understood else None
-        explainer_teaching_points = (
-            _safe_meta_list(getattr(explainer_result, "teaching_points", []))
-            if explainer_understood else []
-        )
+        explainer_result = None
+        explainer_understood = False
+        explainer_scaffold: Dict[str, Any] = {}
+        if solver_input:
+            try:
+                explainer_result = route_explainer(solver_input)
+            except Exception:
+                explainer_result = None
+        if explainer_result is not None and getattr(explainer_result, "understood", False):
+            explainer_understood = True
+            explainer_scaffold = _extract_explainer_scaffold(explainer_result)
 
         result.help_mode = resolved_help_mode
-
         result.meta = result.meta or {}
         result.meta["hint_stage"] = hint_stage
         result.meta["max_stage"] = 3
         result.meta["recovered_question_text"] = solver_input
-
-        if explainer_understood:
-            result.meta["explainer_used"] = False
-            result.meta["bridge_ready"] = bool(explainer_meta.get("bridge_ready", False))
-            result.meta["hint_style"] = explainer_meta.get("hint_style")
-            result.meta["explainer_summary"] = explainer_summary
-            result.meta["explainer_teaching_points"] = explainer_teaching_points
-            result.meta["scaffold"] = explainer_scaffold
-
-        use_solver_steps = _solver_has_useful_steps(result)
-        use_solver_steps_for_hint = resolved_help_mode == "hint" and use_solver_steps
+        result.meta["question_id"] = question_id
+
+        use_solver_steps_for_reply = bool(solver_steps)
+        fallback_reply_core = ""
+        fallback_pack: Dict[str, Any] = {}
+        if solver_input:
+            fallback_reply_core, fallback_pack = _build_fallback_reply(
+                question_id=question_id,
+                question_text=solver_input,
+                options_text=options_text,
+                topic=result.topic or question_topic,
+                category=inferred_category,
+                help_mode=resolved_help_mode,
+                hint_stage=hint_stage,
+                verbosity=verbosity,
+            )
 
         if resolved_help_mode == "explain" and explainer_understood:
             reply = format_explainer_response(
@@ -955,8 +591,7 @@ class ConversationEngine:
                 hint_stage=hint_stage,
             )
             result.meta["explainer_used"] = True
-        
-        elif resolved_help_mode == "hint" and explainer_understood and not use_solver_steps_for_hint:
+        elif resolved_help_mode == "hint" and explainer_understood and not use_solver_steps_for_reply and not fallback_pack.get("support_source") == "question_bank":
             reply = format_explainer_response(
                 result=explainer_result,
                 tone=tone,
@@ -966,17 +601,25 @@ class ConversationEngine:
                 hint_stage=hint_stage,
             )
             result.meta["explainer_used"] = True
-        
         else:
-            reply_core = _compose_reply(
-                result=result,
-                intent=resolved_intent,
-                verbosity=verbosity,
-                category=inferred_category,
-                hint_stage=hint_stage,
-                explainer_scaffold=explainer_scaffold,
-            )
-            
+            if use_solver_steps_for_reply:
+                reply_core = _answer_path_from_steps(solver_steps, verbosity=verbosity)
+                result.meta["question_support_used"] = False
+            elif fallback_reply_core:
+                reply_core = fallback_reply_core
+                result.meta["question_support_used"] = True
+                result.meta["question_support_source"] = fallback_pack.get("support_source")
+                result.meta["question_support_topic"] = fallback_pack.get("topic")
+            elif inferred_category == "Verbal":
+                reply_core = "I can help analyse the wording or logic, but I need the full question text to guide you properly."
+                result.meta["question_support_used"] = False
+            elif inferred_category == "DataInsight":
+                reply_core = "I can help reason through the data, but I need the full question or chart details to guide you properly."
+                result.meta["question_support_used"] = False
+            else:
+                reply_core = "- Start by identifying the main relationship in the problem."
+                result.meta["question_support_used"] = False
+
             reply = format_reply(
                 reply_core,
                 tone=tone,
@@ -986,8 +629,7 @@ class ConversationEngine:
                 hint_stage=hint_stage,
                 topic=result.topic,
             )
-            
-        # Force non-answer modes to stay unsolved
+
         if resolved_help_mode in {"hint", "walkthrough", "explain", "instruction"}:
             result.solved = False
             result.answer_letter = None
@@ -996,20 +638,18 @@ class ConversationEngine:
             result.meta["internal_answer"] = None
 
         result.meta["can_reveal_answer"] = bool(
-            result.solved
-            and _is_direct_solve_request(user_text or solver_input, resolved_intent)
-            and hint_stage >= 3
+            result.solved and _is_direct_solve_request(user_text or solver_input, resolved_intent) and hint_stage >= 3
         )
-        
         if not result.meta.get("can_reveal_answer", False):
             result.answer_letter = None
             result.answer_value = None
             result.internal_answer = None
             result.meta["internal_answer"] = None
-        
+
         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,
@@ -1018,7 +658,7 @@ class ConversationEngine:
             topic=result.topic,
             category=inferred_category,
         )
-        
+
         result.reply = reply
         result.help_mode = resolved_help_mode
         result.meta["help_mode"] = resolved_help_mode
@@ -1030,5 +670,4 @@ class ConversationEngine:
         result.meta["user_last_input_type"] = input_type
         result.meta["built_on_previous_turn"] = built_on_previous_turn
         result.meta["session_state"] = state
-        
-        return result
+        return result