Update question_fallback_router.py

question_fallback_router.py

@@ -37,8 +37,10 @@ class QuestionFallbackRouter:
         q = (question_text or "").lower()
         t = (topic or "").strip().lower()
 
-        if t and t not in {"general", "unknown", "general_quant"}:
+        if t and t not in {"general", "unknown", "general_quant", "quant"}:
             return t
+        if t == "quant":
+            t = ""
         if "%" in q or "percent" in q:
             return "percent"
         if "ratio" in q or re.search(r"\b\d+\s*:\s*\d+\b", q):
@@ -49,7 +51,7 @@ class QuestionFallbackRouter:
             return "number_theory"
         if any(k in q for k in ["triangle", "circle", "angle", "area", "perimeter", "rectangle", "circumference"]):
             return "geometry"
-        if any(k in q for k in ["mean", "median", "average", "standard deviation", "variability"]):
+        if any(k in q for k in ["mean", "median", "average", "standard deviation", "variability", "spread"]):
             return "statistics"
         if "=" in q or re.search(r"\b[xyzabn]\b", q):
             return "algebra"
@@ -79,6 +81,43 @@ class QuestionFallbackRouter:
     def _extract_percent_values(self, question_text: str) -> List[str]:
         return re.findall(r"\d+\.?\d*\s*%", question_text or "")
 
+    def _looks_like_linear_equation(self, question_text: str) -> bool:
+        q = self._clean(question_text)
+        low = q.lower()
+        return bool(
+            "=" in q
+            and re.search(r"\bwhat is\s+[a-z]\b", low)
+            and re.search(r"\d+[a-z]\b|\b[a-z]\b", q)
+        )
+
+    def _pack_looks_generic(self, pack: Dict[str, Any], topic: str) -> bool:
+        if not pack:
+            return True
+        joined = " ".join(
+            [
+                self._clean(pack.get("first_step")),
+                self._clean(pack.get("hint_1")),
+                self._clean(pack.get("hint_2")),
+                self._clean(pack.get("hint_3")),
+                " ".join(self._listify(pack.get("walkthrough_steps"))),
+                " ".join(self._listify(pack.get("method_explanation"))),
+            ]
+        ).lower()
+        generic_signals = [
+            "write the equation clearly and identify the variable",
+            "undo operations in reverse order",
+            "keep both sides balanced",
+            "break the question into known and unknown parts",
+            "what is being asked?",
+            "what information is given?",
+            "translate words into math",
+        ]
+        if any(signal in joined for signal in generic_signals):
+            return True
+        if topic == "algebra" and "look at the structure" in joined:
+            return True
+        return False
+
     def _topic_defaults(self, topic: str, question_text: str, options_text: Optional[List[str]]) -> Dict[str, Any]:
         preview = self._preview_question(question_text)
         equation = self._extract_equation(question_text)
@@ -113,231 +152,205 @@ class QuestionFallbackRouter:
         }
 
         if topic == "algebra":
-            first_step = (
-                f"Start with the equation: {equation}"
-                if equation
-                else "Write the equation exactly as given and identify the operation attached to the variable."
-            )
-            hint_1 = "Focus on isolating the variable."
-            hint_2 = "Undo addition or subtraction before undoing multiplication or division."
-            hint_3 = "Do the same operation to both sides each time so the equation stays balanced."
-
-            generic.update(
-                {
-                    "first_step": first_step,
-                    "hint_1": hint_1,
-                    "hint_2": hint_2,
-                    "hint_3": hint_3,
-                    "hint_ladder": [hint_1, hint_2, hint_3],
-                    "walkthrough_steps": [
-                        first_step,
-                        "Use inverse operations to undo what is attached to the variable.",
-                        "Do the same thing to both sides each time.",
-                        "Once the variable is isolated, compare with the answer choices if there are any.",
-                    ],
-                    "method_steps": [
-                        "Algebra questions are about preserving balance while isolating the unknown.",
-                        "Treat each operation in reverse order to peel the equation back.",
-                    ],
-                    "answer_path": [
-                        first_step,
-                        "Reverse the operations in a sensible order.",
-                        "Simplify only after keeping both sides balanced.",
-                    ],
-                    "common_trap": "Changing only one side of the equation or reversing the order of operations badly.",
-                }
-            )
+            if self._looks_like_linear_equation(question_text):
+                generic.update(
+                    {
+                        "first_step": "Look at the variable side and identify the outermost operation attached to the variable.",
+                        "hint_1": "Undo the outside addition or subtraction on both sides before touching the coefficient.",
+                        "hint_2": "Once only the variable term remains, undo the multiplication or division.",
+                        "hint_3": "After isolating the variable, compare carefully with what the question actually asks for.",
+                        "hint_ladder": [
+                            "Look at the variable side and identify the outermost operation attached to the variable.",
+                            "Undo the outside addition or subtraction on both sides before touching the coefficient.",
+                            "Once only the variable term remains, undo the multiplication or division.",
+                        ],
+                        "walkthrough_steps": [
+                            "Write the equation cleanly and focus on the side containing the variable.",
+                            "Undo the constant attached to that side using the opposite operation on both sides.",
+                            "Then undo the coefficient attached to the variable.",
+                            "Only then compare the isolated value with the answer choices or requested expression.",
+                        ],
+                        "method_steps": [
+                            "Linear equations are solved by reversing operations in the opposite order from how they were built.",
+                            "Keep the equation balanced by doing the same thing to both sides each time.",
+                        ],
+                        "answer_path": [
+                            "Undo the constant on the variable side first.",
+                            "Then undo the coefficient attached to the variable.",
+                            "Check whether the question asks for the variable itself or for an expression built from it.",
+                        ],
+                        "common_trap": "Dividing by the coefficient too early before removing the constant term.",
+                    }
+                )
+            elif equation:
+                generic.update(
+                    {
+                        "first_step": f"Start from the equation {equation} and decide which operation should be reversed first.",
+                        "hint_1": "Preserve balance by doing the same operation to both sides.",
+                        "hint_2": "Reverse the operations in a sensible order instead of trying to simplify everything at once.",
+                        "hint_3": "Only evaluate the target expression after the variables are in a usable form.",
+                    }
+                )
 
         elif topic == "percent":
             first_step = "Identify the base quantity before doing any percent calculation."
             if percent_values:
                 first_step = f"Track the percentage relationship carefully here: {' then '.join(percent_values[:2]) if len(percent_values) > 1 else percent_values[0]}"
-
-            hint_1 = "Decide what quantity the percent is of."
-            hint_2 = "Rewrite the percent as a decimal or fraction if that makes the relationship clearer."
-            hint_3 = "Set up part = percent × base, or reverse that relationship if the base is unknown."
-
-            generic.update(
-                {
-                    "first_step": first_step,
-                    "hint_1": hint_1,
-                    "hint_2": hint_2,
-                    "hint_3": hint_3,
-                    "hint_ladder": [hint_1, hint_2, hint_3],
-                    "walkthrough_steps": [
-                        first_step,
-                        "Find the base quantity the percent refers to.",
-                        "Translate the wording into a percent relationship.",
-                        "Solve for the missing quantity.",
-                        "Check whether the question asks for the part, the whole, or a percent change.",
-                    ],
-                    "method_steps": [
-                        "Percent questions become easier once you identify the correct base.",
-                        "Do not apply the percent to the wrong quantity.",
-                    ],
-                    "answer_path": [
-                        first_step,
-                        "Turn the wording into a percent equation.",
-                        "Then solve for the missing part of the relationship.",
-                    ],
-                    "common_trap": "Using the wrong base quantity.",
-                }
-            )
+            if "increased by" in question_text.lower() and "decreased by" in question_text.lower():
+                generic.update(
+                    {
+                        "first_step": "Turn each percentage change into its own multiplier before combining anything.",
+                        "hint_1": "An increase and a decrease of the same percent do not cancel because they apply to different bases.",
+                        "hint_2": "Apply the first multiplier, then apply the second multiplier to the updated amount.",
+                        "hint_3": "Compare the final amount with the original amount only at the end.",
+                        "hint_ladder": [
+                            "Turn each percentage change into its own multiplier before combining anything.",
+                            "Apply the first multiplier, then apply the second multiplier to the updated amount.",
+                            "Compare the final amount with the original amount only at the end.",
+                        ],
+                    }
+                )
+            else:
+                generic.update(
+                    {
+                        "first_step": first_step,
+                        "hint_1": "Ask 'percent of what?' so you choose the correct base quantity.",
+                        "hint_2": "Rewrite the percent as a decimal or fraction if that makes the relationship clearer.",
+                        "hint_3": "Set up part = percent × base, or reverse that relationship if the base is unknown.",
+                        "hint_ladder": [
+                            "Ask 'percent of what?' so you choose the correct base quantity.",
+                            "Rewrite the percent as a decimal or fraction if that makes the relationship clearer.",
+                            "Set up part = percent × base, or reverse that relationship if the base is unknown.",
+                        ],
+                    }
+                )
 
         elif topic == "ratio":
             first_step = "Keep the ratio order consistent and assign one shared multiplier."
             if ratio_text:
                 first_step = f"Use the ratio {ratio_text} as parts of one whole."
-
-            hint_1 = "Write each part of the ratio using the same multiplier."
-            hint_2 = "Use the total or known part to solve for that shared multiplier."
-            hint_3 = "Substitute back into the specific part you actually need."
-
             generic.update(
                 {
                     "first_step": first_step,
-                    "hint_1": hint_1,
-                    "hint_2": hint_2,
-                    "hint_3": hint_3,
-                    "hint_ladder": [hint_1, hint_2, hint_3],
+                    "hint_1": "Write each part of the ratio using the same multiplier.",
+                    "hint_2": "Use the total or known part to solve for that shared multiplier.",
+                    "hint_3": "Substitute back into the exact quantity the question asks for.",
+                    "hint_ladder": [
+                        "Write each part of the ratio using the same multiplier.",
+                        "Use the total or known part to solve for that shared multiplier.",
+                        "Substitute back into the exact quantity the question asks for.",
+                    ],
                     "walkthrough_steps": [
                         first_step,
-                        "Translate the ratio into algebraic parts with one common scale factor.",
-                        "Use the total or given piece to solve for the factor.",
-                        "Find the required part and check the order of the ratio.",
+                        "Represent each ratio part in terms of one common variable such as k.",
+                        "Use the given total or condition to find k.",
+                        "Build the requested expression from those ratio parts.",
                     ],
                     "method_steps": [
-                        "Ratio questions are controlled by one shared multiplier.",
-                        "Preserve the ratio order all the way through.",
-                    ],
-                    "answer_path": [
-                        first_step,
-                        "Convert the ratio into parts of a total.",
-                        "Solve for the shared scale factor before finding the requested part.",
+                        "Ratio problems usually become easier once you turn the ratio into matching parts.",
+                        "Avoid treating ratio numbers as the actual values unless the problem tells you they are.",
                     ],
-                    "common_trap": "Reversing the ratio order or using different multipliers for different parts.",
+                    "common_trap": "Using the raw ratio numbers as real values before solving for the common multiplier.",
                 }
             )
 
         elif topic == "probability":
-            hint_1 = "Decide exactly what counts as a successful outcome."
-            hint_2 = "Count all possible outcomes under the same rules."
-            hint_3 = "Write probability as successful over total, then simplify if needed."
-
             generic.update(
                 {
-                    "first_step": "Count successful outcomes and total outcomes separately.",
-                    "hint_1": hint_1,
-                    "hint_2": hint_2,
-                    "hint_3": hint_3,
-                    "hint_ladder": [hint_1, hint_2, hint_3],
+                    "first_step": "Decide what counts as a successful outcome before you count anything.",
+                    "hint_1": "Count the favorable outcomes that satisfy the condition.",
+                    "hint_2": "Count the total possible outcomes in the sample space.",
+                    "hint_3": "Build the probability as favorable over total, then simplify if needed.",
+                    "hint_ladder": [
+                        "Decide what counts as a successful outcome before you count anything.",
+                        "Count the favorable outcomes that satisfy the condition.",
+                        "Count the total possible outcomes in the sample space.",
+                    ],
                     "walkthrough_steps": [
-                        "Identify the event the question cares about.",
-                        "Count the successful outcomes.",
-                        "Count the full sample space.",
-                        "Form the probability and simplify carefully.",
+                        "Define the event the question cares about.",
+                        "Count or construct the favorable cases.",
+                        "Count the total cases in the sample space.",
+                        "Write the probability as favorable over total.",
                     ],
                     "method_steps": [
-                        "Probability is a comparison of favorable outcomes to all valid outcomes.",
-                        "Make sure the numerator and denominator come from the same setup.",
-                    ],
-                    "answer_path": [
-                        "Define the event clearly.",
-                        "Count favorable outcomes and total outcomes from the same sample space.",
-                        "Then simplify the fraction if possible.",
-                    ],
-                    "common_trap": "Counting the right numerator with the wrong denominator.",
-                }
-            )
-
-        elif topic == "number_theory":
-            generic.update(
-                {
-                    "first_step": "Identify which number property matters most: factors, multiples, divisibility, or remainders.",
-                    "hint_1": "Look for the number property the question is testing.",
-                    "hint_2": "Use that rule directly instead of trying random arithmetic.",
-                    "hint_3": "Check the candidate values against the exact condition in the question.",
-                    "hint_ladder": [
-                        "Look for the number property the question is testing.",
-                        "Use that rule directly instead of trying random arithmetic.",
-                        "Check the candidate values against the exact condition in the question.",
-                    ],
-                    "common_trap": "Using arithmetic intuition instead of the actual number-property rule being tested.",
-                }
-            )
-
-        elif topic == "geometry":
-            generic.update(
-                {
-                    "first_step": "Identify the shape and the formula or relationship that belongs to it.",
-                    "hint_1": "Work out which measurement is given and which one you need.",
-                    "hint_2": "Choose the correct geometry formula before substituting numbers.",
-                    "hint_3": "Substitute carefully and keep track of what the question asks for.",
-                    "hint_ladder": [
-                        "Work out which measurement is given and which one you need.",
-                        "Choose the correct geometry formula before substituting numbers.",
-                        "Substitute carefully and keep track of what the question asks for.",
+                        "Probability questions become clearer once the event and the sample space are both explicit.",
+                        "Many errors come from counting the wrong denominator, not the numerator.",
                     ],
-                    "common_trap": "Using the wrong formula or solving for the wrong geometric quantity.",
+                    "common_trap": "Changing the denominator incorrectly or forgetting which cases are actually favorable.",
                 }
             )
+            if "at least" in question_text.lower():
+                generic["hint_2"] = "Check whether the complement is easier to count than the requested event."
+                generic["hint_ladder"] = [
+                    generic["hint_1"],
+                    "Check whether the complement is easier to count than the requested event.",
+                    generic["hint_3"],
+                ]
 
         elif topic == "statistics":
-            qlow = (question_text or "").lower()
-            
+            qlow = question_text.lower()
             if any(k in qlow for k in ["variability", "spread", "standard deviation"]):
                 generic.update(
                     {
-                        "first_step": "This is about spread, so compare how far the values sit from the center.",
-                        "hint_1": "Check which dataset has values furthest from its middle value.",
-                        "hint_2": "Since each set has three numbers, compare how spread out the smallest and largest values are.",
-                        "hint_3": "The set with the biggest overall spread has the greatest variability here.",
+                        "first_step": "Notice that this is about spread, not average.",
+                        "hint_1": "Use the middle value as a centre and compare how far the outer values sit from it.",
+                        "hint_2": "A set with values clustered tightly has lower variability than a set spread farther apart.",
+                        "hint_3": "Choose the set with the widest spread, not the largest mean.",
                         "hint_ladder": [
-                            "Check which dataset has values furthest from its middle value.",
-                            "Compare the distance from the middle to the outer numbers in each set.",
-                            "The set with the largest spread has the greatest variability.",
-                        ],
-                        "walkthrough_steps": [
-                            "Notice that the question is about variability, not the average.",
-                            "For each dataset, identify the middle value.",
-                            "Compare how far the outer values sit from that middle value.",
-                            "The dataset with the widest spread is the most variable.",
-                        ],
-                        "method_steps": [
-                            "For short answer choices like these, you can often compare spread visually instead of computing a full standard deviation.",
-                            "Look at how tightly clustered or widely spaced the numbers are.",
-                        ],
-                        "answer_path": [
-                            "Identify that the question is testing spread rather than center.",
-                            "Compare how far the values extend away from the middle in each dataset.",
-                            "Choose the dataset with the widest spread.",
+                            "Notice that this is about spread, not average.",
+                            "Use the middle value as a centre and compare how far the outer values sit from it.",
+                            "Choose the set with the widest spread, not the largest mean.",
                         ],
-                        "common_trap": "Comparing means instead of comparing spread.",
                     }
                 )
             else:
                 generic.update(
                     {
-                        "first_step": "Identify which measure the question wants before calculating anything.",
-                        "hint_1": "Check whether this is asking for mean, median, range, or another measure.",
-                        "hint_2": "Set up the data in a clean order if needed.",
-                        "hint_3": "Use the correct formula or definition for that exact measure.",
-                        "hint_ladder": [
-                            "Check whether this is asking for mean, median, range, or another measure.",
-                            "Set up the data in a clean order if needed.",
-                            "Use the correct formula or definition for that exact measure.",
-                        ],
-                        "common_trap": "Using the wrong statistical measure because the wording was skimmed too quickly.",
+                        "first_step": "Identify which statistical measure the question wants before calculating anything.",
+                        "hint_1": "Check whether the task is asking for mean, median, range, or another measure.",
+                        "hint_2": "Organise the data in a clean order if that helps reveal the measure.",
+                        "hint_3": "Use the exact definition of the requested measure rather than a nearby one.",
                     }
                 )
 
         if has_options:
             generic["answer_path"] = list(generic.get("answer_path", [])) + [
-                "Use the choices to check which one matches your setup instead of guessing."
+                "Use the answer choices to check which setup fits the question instead of guessing."
             ]
 
         return generic
 
+    def _merge_support_pack(self, generated: Dict[str, Any], stored: Optional[Dict[str, Any]], topic: str) -> Dict[str, Any]:
+        if not stored:
+            merged = dict(generated)
+            merged["support_source"] = "generated_question_specific"
+            return merged
+
+        merged = dict(generated)
+        merged.update(dict(stored))
+
+        if self._pack_looks_generic(stored, topic):
+            for key in [
+                "first_step",
+                "hint_1",
+                "hint_2",
+                "hint_3",
+                "hint_ladder",
+                "walkthrough_steps",
+                "method_steps",
+                "answer_path",
+                "common_trap",
+            ]:
+                if key in generated:
+                    merged[key] = generated[key]
+            merged["support_source"] = "question_bank_refined"
+        else:
+            merged.setdefault("support_source", "question_bank")
+
+        merged.setdefault("method_steps", generated.get("method_steps", []))
+        merged.setdefault("answer_path", generated.get("answer_path", []))
+        return merged
+
     def get_support_pack(
         self,
         *,
@@ -347,43 +360,35 @@ class QuestionFallbackRouter:
         topic: Optional[str],
         category: Optional[str],
     ) -> Dict[str, Any]:
-        stored = question_support_bank.get(question_id=question_id, question_text=question_text)
         resolved_topic = self._normalize_topic(topic, question_text)
-
-        if stored:
-            pack = dict(stored)
-            pack.setdefault("question_id", question_id)
-            pack.setdefault("question_text", question_text)
-            pack.setdefault("options_text", list(options_text or []))
-            pack.setdefault("topic", resolved_topic)
-            pack.setdefault("category", category or "General")
-            pack.setdefault("support_source", "question_bank")
-            return pack
-
         generated = self._topic_defaults(resolved_topic, question_text, options_text)
-        generated.update(
-            {
-                "question_id": question_id,
-                "question_text": question_text,
-                "options_text": list(options_text or []),
-                "topic": resolved_topic,
-                "category": category or "General",
-                "support_source": "generated_question_specific",
-            }
+        stored = question_support_bank.get(
+            question_id=question_id,
+            question_text=question_text,
+            options_text=options_text,
         )
-        return generated
+
+        pack = self._merge_support_pack(generated, stored, resolved_topic)
+        pack.setdefault("question_id", question_id)
+        pack.setdefault("question_text", question_text)
+        pack.setdefault("stem", question_text)
+        pack.setdefault("options_text", list(options_text or []))
+        pack.setdefault("choices", list(options_text or []))
+        pack.setdefault("topic", resolved_topic)
+        pack.setdefault("category", category or "General")
+        return pack
 
     def _hint_ladder_from_pack(self, pack: Dict[str, Any]) -> List[str]:
         hints: List[str] = []
-
+        first_step = self._clean(pack.get("first_step"))
+        if first_step:
+            hints.append(first_step)
         for key in ("hint_1", "hint_2", "hint_3"):
             value = self._clean(pack.get(key))
             if value:
                 hints.append(value)
-
         hints.extend(self._listify(pack.get("hint_ladder")))
         hints.extend(self._listify(pack.get("hints")))
-
         return self._dedupe(hints)
 
     def _walkthrough_from_pack(self, pack: Dict[str, Any]) -> List[str]:
@@ -396,11 +401,13 @@ class QuestionFallbackRouter:
 
     def _method_from_pack(self, pack: Dict[str, Any]) -> List[str]:
         lines: List[str] = []
-        lines.extend(self._listify(pack.get("method_steps")))
-        lines.extend(self._listify(pack.get("method_explanation")))
         concept = self._clean(pack.get("concept"))
         if concept:
-            lines.insert(0, concept)
+            lines.append(concept)
+        lines.extend(self._listify(pack.get("method_steps")))
+        lines.extend(self._listify(pack.get("method_explanation")))
+        if not lines:
+            lines.extend(self._walkthrough_from_pack(pack)[:3])
         return self._dedupe(lines)
 
     def _answer_path_from_pack(self, pack: Dict[str, Any]) -> List[str]:
@@ -439,7 +446,7 @@ class QuestionFallbackRouter:
         )
 
         mode = (help_mode or "answer").lower()
-        stage = max(1, min(int(hint_stage or 1), 3))
+        stage = max(1, min(int(hint_stage or 1), 4))
 
         first_step = self._clean(pack.get("first_step"))
         hint_ladder = self._hint_ladder_from_pack(pack)
@@ -451,84 +458,38 @@ class QuestionFallbackRouter:
         lines: List[str] = []
 
         if mode == "hint":
-            selected: List[str] = []
-
-            if stage == 1:
-                if first_step:
-                    selected.append(first_step)
-                if hint_ladder:
-                    selected.append(hint_ladder[0])
-
-                if verbosity >= 0.65 and len(hint_ladder) >= 2:
-                    selected.append(hint_ladder[1])
-
-            elif stage == 2:
-                if len(hint_ladder) >= 2:
-                    selected.append(hint_ladder[1])
-                elif hint_ladder:
-                    selected.append(hint_ladder[0])
-
-                if verbosity >= 0.45 and first_step:
-                    selected.insert(0, first_step)
-
-                if verbosity >= 0.65 and len(hint_ladder) >= 3:
-                    selected.append(hint_ladder[2])
-
+            if hint_ladder:
+                idx = min(stage - 1, len(hint_ladder) - 1)
+                selected = [hint_ladder[idx]]
+                if verbosity >= 0.7 and idx + 1 < len(hint_ladder):
+                    selected.append(hint_ladder[idx + 1])
             else:
-                if len(hint_ladder) >= 3:
-                    selected.append(hint_ladder[2])
-                elif hint_ladder:
-                    selected.append(hint_ladder[-1])
-
-                if verbosity >= 0.45 and first_step:
-                    selected.insert(0, first_step)
-
-                if verbosity >= 0.7 and common_trap:
-                    selected.append(f"Watch out for this trap: {common_trap}")
-
-            lines = self._dedupe(selected) or [first_step or "Start by identifying the structure of the question."]
+                selected = [first_step or "Start by identifying the structure of the question."]
+            if verbosity >= 0.75 and stage >= 3 and common_trap:
+                selected.append(f"Watch out for this trap: {common_trap}")
+            lines = self._dedupe(selected)
 
         elif mode in {"walkthrough", "step_by_step", "instruction"}:
-            if walkthrough_steps:
-                limit = self._verbosity_limit(verbosity, low=2, mid=4, high=6)
-                lines = walkthrough_steps[:limit]
-            elif answer_path:
-                limit = self._verbosity_limit(verbosity, low=2, mid=3, high=5)
-                lines = answer_path[:limit]
-            elif hint_ladder:
-                limit = self._verbosity_limit(verbosity, low=1, mid=2, high=3)
-                lines = hint_ladder[:limit]
-            else:
-                lines = [first_step or "Start by setting up the problem."]
-
+            source = walkthrough_steps or answer_path or hint_ladder
+            limit = self._verbosity_limit(verbosity, low=2, mid=4, high=6)
+            lines = source[:limit] if source else [first_step or "Start by setting up the problem."]
             if verbosity >= 0.7 and common_trap:
                 lines = list(lines) + [f"Watch out for this trap: {common_trap}"]
 
         elif mode in {"method", "explain", "concept", "definition"}:
             source = method_steps or walkthrough_steps or answer_path or hint_ladder
-            if source:
-                limit = self._verbosity_limit(verbosity, low=1, mid=2, high=4)
-                lines = source[:limit]
-            else:
-                lines = [first_step or "Start from the problem structure."]
-
+            limit = self._verbosity_limit(verbosity, low=1, mid=2, high=4)
+            lines = source[:limit] if source else [first_step or "Start from the problem structure."]
             if verbosity >= 0.65 and common_trap:
                 lines = list(lines) + [f"Common trap: {common_trap}"]
 
         else:
             source = answer_path or walkthrough_steps or hint_ladder
-            if source:
-                limit = self._verbosity_limit(verbosity, low=2, mid=3, high=5)
-                lines = source[:limit]
-            else:
-                lines = [first_step or "Start by identifying the relationship in the question."]
+            limit = self._verbosity_limit(verbosity, low=2, mid=3, high=5)
+            lines = source[:limit] if source else [first_step or "Start by identifying the relationship in the question."]
 
         lines = self._dedupe(lines)
-
-        return {
-            "lines": lines,
-            "pack": pack,
-        }
+        return {"lines": lines, "pack": pack}
 
 
 question_fallback_router = QuestionFallbackRouter()