Update formatting.py

formatting.py

@@ -14,15 +14,6 @@ def style_prefix(tone: float) -> str:
     return "You’ve got this — let’s solve it cleanly."
 
 
-def _clean_lines(core: str) -> list[str]:
-    lines = []
-    for line in (core or "").splitlines():
-        cleaned = line.strip()
-        if cleaned:
-            lines.append(cleaned)
-    return lines
-
-
 def _normalize_key(text: str) -> str:
     text = (text or "").strip().lower()
     text = text.replace("’", "'")
@@ -30,56 +21,13 @@ def _normalize_key(text: str) -> str:
     return text
 
 
-def _is_wrapper_line(line: str) -> bool:
-    key = _normalize_key(line).rstrip(":")
-    wrapper_lines = {
-        "let's work through it.",
-        "lets work through it.",
-        "let's solve it efficiently.",
-        "lets solve it efficiently.",
-        "you've got this — let's solve it cleanly.",
-        "youve got this — lets solve it cleanly.",
-        "you’ve got this — let’s solve it cleanly.",
-        "walkthrough",
-        "hint",
-        "steps",
-        "method",
-        "explanation",
-        "key idea",
-        "question breakdown",
-        "here’s what the question is really asking",
-        "here's what the question is really asking",
-        "let’s break down what the question is asking",
-        "lets break down what the question is asking",
-        "you’ve got this — here’s what the question is really asking",
-        "you've got this — here's what the question is really asking",
-        "what to identify first",
-        "what to identify",
-        "set-up path",
-        "setup path",
-        "first move",
-        "next hint",
-        "next steps",
-        "watch out for",
-        "variables to define",
-        "equations to form",
-        "key teaching points",
-        "how to build it",
-        "what the question gives you",
-        "constraints or conditions",
-        "key relationship",
-        "concepts you will probably need",
-        "best starting move",
-        "final answer",
-    }
-    return key in wrapper_lines
-
-
-def _strip_leading_wrapper_lines(lines: list[str]) -> list[str]:
-    cleaned = list(lines)
-    while cleaned and _is_wrapper_line(cleaned[0]):
-        cleaned.pop(0)
-    return cleaned
+def _clean_lines(core: str) -> list[str]:
+    lines = []
+    for line in (core or "").splitlines():
+        cleaned = line.strip()
+        if cleaned:
+            lines.append(cleaned)
+    return lines
 
 
 def _dedupe_lines(lines: list[str]) -> list[str]:
@@ -93,95 +41,6 @@ def _dedupe_lines(lines: list[str]) -> list[str]:
     return output
 
 
-def _limit_lines_for_verbosity(lines: list[str], verbosity: float, help_mode: str) -> list[str]:
-    if not lines:
-        return lines
-
-    if help_mode == "hint":
-        return lines[:1]
-
-    if help_mode == "answer":
-        if verbosity < 0.2:
-            return lines[:2]
-        if verbosity < 0.45:
-            return lines[:3]
-        if verbosity < 0.75:
-            return lines[:4]
-        return lines[:5]
-
-    if verbosity < 0.2:
-        return lines[:1]
-    if verbosity < 0.45:
-        return lines[:2]
-    if verbosity < 0.75:
-        return lines[:3]
-    return lines
-
-
-def _extract_topic_from_lines(lines: list[str]) -> str:
-    joined = " ".join(lines).lower()
-
-    if any(word in joined for word in ["equation", "variable", "isolate", "algebra"]):
-        return "algebra"
-    if any(word in joined for word in ["percent", "percentage"]):
-        return "percent"
-    if any(word in joined for word in ["ratio", "proportion"]):
-        return "ratio"
-    if any(word in joined for word in ["probability", "outcome"]):
-        return "probability"
-    if any(word in joined for word in ["mean", "median", "average"]):
-        return "statistics"
-    if any(word in joined for word in ["triangle", "circle", "angle", "area", "perimeter"]):
-        return "geometry"
-    if any(word in joined for word in ["integer", "factor", "multiple", "prime", "remainder"]):
-        return "number_theory"
-
-    return "general"
-
-
-def _why_line(topic: str, lines: list[str]) -> str:
-    joined = " ".join(lines).lower()
-
-    if topic == "algebra":
-        if "equation" in joined or "isolate" in joined or "variable" in joined:
-            return "Why: this works because inverse operations undo what is attached to the variable while keeping the equation balanced."
-        return "Why: the goal is to isolate the variable without changing the balance of the relationship."
-
-    if topic == "percent":
-        return "Why: percent relationships depend on identifying the correct base value before calculating the change or part."
-
-    if topic == "ratio":
-        return "Why: ratios compare parts consistently, so the relationship must stay proportional."
-
-    if topic == "probability":
-        return "Why: probability compares favorable outcomes to the total number of possible outcomes."
-
-    if topic == "statistics":
-        return "Why: statistical measures describe the distribution, so the method depends on what feature the question asks for."
-
-    if topic == "geometry":
-        return "Why: geometry problems depend on the properties of the figure and the relationships between its parts."
-
-    if topic == "number_theory":
-        return "Why: number properties such as divisibility, factors, and remainders follow fixed rules that guide the method."
-
-    return "Why: focus on the structure of the problem before doing any calculations."
-
-
-def _tone_adjust_line(line: str, tone: float) -> str:
-    line = (line or "").strip()
-    if not line:
-        return line
-
-    if tone < 0.25:
-        line = re.sub(r"^let’s\s+", "", line, flags=re.IGNORECASE)
-        line = re.sub(r"^let's\s+", "", line, flags=re.IGNORECASE)
-        line = re.sub(r"^here is the idea in context:\s*", "", line, flags=re.IGNORECASE)
-        return line.strip()
-
-    return line
-
-
 def _coerce_string(value: Any) -> str:
     return (value or "").strip() if isinstance(value, str) else ""
 
@@ -199,85 +58,59 @@ def _coerce_list(value: Any) -> List[str]:
     return []
 
 
-def _clean_section_items(items: List[str]) -> List[str]:
-    cleaned = []
-    seen = set()
-
-    for item in items or []:
-        text = (item or "").strip()
-        if not text:
-            continue
-        if _is_wrapper_line(text):
-            continue
-        key = _normalize_key(text)
-        if key in seen:
-            continue
-        seen.add(key)
-        cleaned.append(text)
-
-    return cleaned
-
-
-def _append_section(lines: List[str], title: str, items: List[str], limit: int) -> None:
-    cleaned = _clean_section_items(items)
-    if not cleaned:
-        return
-
-    lines.append("")
-    lines.append(title)
-    for item in cleaned[:limit]:
-        lines.append(f"- {item}")
-
-
-def _get_scaffold(result: Any):
-    return getattr(result, "scaffold", None)
+def _limit_steps(steps: List[str], verbosity: float, minimum: int = 1) -> List[str]:
+    if not steps:
+        return []
+    if verbosity < 0.25:
+        limit = minimum
+    elif verbosity < 0.5:
+        limit = max(minimum, 2)
+    elif verbosity < 0.75:
+        limit = max(minimum, 3)
+    else:
+        limit = max(minimum, 5)
+    return steps[:limit]
 
 
-def _explainer_topic(result: Any) -> str:
-    topic = _coerce_string(getattr(result, "topic", ""))
-    if topic:
-        return topic
+def _why_line(topic: str) -> str:
+    topic = (topic or "").lower()
 
-    joined = " ".join(
-        _coerce_list(getattr(result, "teaching_points", []))
-        + _coerce_list(getattr(result, "givens", []))
-        + _coerce_list(getattr(result, "relationships", []))
-    )
-    return _extract_topic_from_lines([joined]) if joined else "general"
+    if topic == "algebra":
+        return "Why: algebra works by keeping the relationship balanced while undoing the operations attached to the variable."
+    if topic == "percent":
+        return "Why: percent questions depend on choosing the correct base before doing any calculation."
+    if topic == "ratio":
+        return "Why: ratio questions depend on preserving the comparison and using one shared scale factor."
+    if topic == "probability":
+        return "Why: probability compares successful outcomes to all possible outcomes."
+    if topic == "statistics":
+        return "Why: the right method depends on which summary measure the question actually asks for."
+    if topic == "geometry":
+        return "Why: geometry depends on the relationships between the parts of the figure."
+    if topic == "number_theory":
+        return "Why: number properties follow fixed rules about divisibility, factors, and remainders."
+    return "Why: start with the structure of the problem before calculating."
 
 
-def _safe_solver_steps(steps: Optional[List[str]]) -> List[str]:
-    if not steps:
-        return []
-    banned = [
-        r"\bthe answer is\b",
-        r"\banswer:\b",
-        r"\bfinal answer\b",
-        r"\bx\s*=",
-        r"\by\s*=",
-        r"\bresult is\b",
-        r"\btherefore\b",
-    ]
-    cleaned: List[str] = []
-    for step in steps:
-        s = str(step or "").strip()
-        if not s:
-            continue
-        low = s.lower()
-        if any(re.search(p, low) for p in banned):
-            continue
-        cleaned.append(s)
-    return _dedupe_lines(cleaned)
-
-
-def _explainer_header(tone: float) -> str:
-    if tone < 0.2:
-        return "Question breakdown:"
-    if tone < 0.45:
-        return "Here’s what the question is really asking:"
-    if tone < 0.75:
-        return "Let’s break down what the question is asking:"
-    return "You’ve got this — here’s what the question is really asking:"
+def _extract_topic_from_text(text: str, fallback: Optional[str] = None) -> str:
+    low = (text or "").lower()
+    if fallback:
+        return fallback
+    if any(word in low for word in ["equation", "variable", "isolate", "algebra"]):
+        return "algebra"
+    if any(word in low for word in ["percent", "percentage", "%"]):
+        return "percent"
+    if any(word in low for word in ["ratio", "proportion"]):
+        return "ratio"
+    if any(word in low for word in ["probability", "outcome", "chance", "odds"]):
+        return "probability"
+    if any(word in low for word in ["mean", "median", "average"]):
+        return "statistics"
+    if any(word in low for word in ["triangle", "circle", "angle", "area", "perimeter"]):
+        return "geometry"
+    if any(word in low for word in ["integer", "factor", "multiple", "prime", "remainder"]):
+        return "number_theory"
+    return "general"
 
 
 def _format_answer_mode(
@@ -288,18 +121,14 @@ def _format_answer_mode(
     transparency: float,
 ) -> str:
     output: List[str] = []
-
     prefix = style_prefix(tone)
     if prefix:
         output.append(prefix)
         output.append("")
 
-    output.append("Let’s work through it.")
-    output.append("")
-
-    limited = _limit_lines_for_verbosity(lines, verbosity, "answer")
-
+    limited = _limit_steps(lines, verbosity, minimum=2)
     if limited:
+        output.append("Answer path:")
         if len(limited) >= 1:
             output.append(f"- What to identify: {limited[0]}")
         if len(limited) >= 2:
@@ -311,37 +140,37 @@ def _format_answer_mode(
 
     if transparency >= 0.8:
         output.append("")
-        output.append(_why_line(topic, limited or lines))
+        output.append(_why_line(topic))
 
     return "\n".join(output).strip()
 
 
-def format_reply(core: str, tone: float, verbosity: float, transparency: float, help_mode: str) -> str:
+def format_reply(
+    core: str,
+    tone: float,
+    verbosity: float,
+    transparency: float,
+    help_mode: str,
+    hint_stage: int = 0,
+    topic: Optional[str] = None,
+) -> str:
     prefix = style_prefix(tone)
     core = (core or "").strip()
 
     if not core:
         return prefix or "Start with the structure of the problem."
 
-    lines = _clean_lines(core)
-    lines = _strip_leading_wrapper_lines(lines)
-    lines = [_tone_adjust_line(line, tone) for line in lines]
-    lines = [line for line in lines if line]
-    lines = _dedupe_lines(lines)
-
+    lines = _dedupe_lines(_clean_lines(core))
     if not lines:
         return prefix or "Start with the structure of the problem."
 
-    topic = _extract_topic_from_lines(lines)
+    resolved_topic = _extract_topic_from_text(core, topic)
 
     if help_mode == "answer":
-        return _format_answer_mode(lines, topic, tone, verbosity, transparency)
+        return _format_answer_mode(lines, resolved_topic, tone, verbosity, transparency)
 
-    lines = _limit_lines_for_verbosity(lines, verbosity, help_mode)
-    if not lines:
-        return prefix or "Start with the structure of the problem."
-
-    output: list[str] = []
+    shown = _limit_steps(lines, verbosity, minimum=1)
+    output: List[str] = []
 
     if prefix:
         output.append(prefix)
@@ -349,228 +178,171 @@ def format_reply(core: str, tone: float, verbosity: float, transparency: float,
 
     if help_mode == "hint":
         output.append("Hint:")
-        output.extend(lines[:1])
-
+        output.append(f"- {shown[0]}")
         if transparency >= 0.8:
             output.append("")
-            output.append(_why_line(topic, lines[:1]))
-
+            output.append(_why_line(resolved_topic))
         return "\n".join(output).strip()
 
-    if help_mode == "walkthrough":
-        output.append("Walkthrough:")
-        output.extend(lines)
-
+    if help_mode in {"instruction", "step_by_step", "walkthrough"}:
+        label = "First step:" if help_mode == "instruction" else "Walkthrough:"
+        output.append(label)
+        for line in shown:
+            output.append(f"- {line}")
         if transparency >= 0.8:
             output.append("")
-            output.append(_why_line(topic, lines))
-
+            output.append(_why_line(resolved_topic))
         return "\n".join(output).strip()
 
-    if help_mode in {"step_by_step", "method", "explain", "concept", "definition"}:
+    if help_mode in {"method", "explain", "concept", "definition"}:
         label = {
-            "step_by_step": "Steps:",
             "method": "Method:",
             "explain": "Explanation:",
             "concept": "Key idea:",
             "definition": "Key idea:",
-        }.get(help_mode, "Explanation:")
+        }[help_mode]
         output.append(label)
-        output.extend(lines)
-
+        for line in shown:
+            output.append(f"- {line}")
         if transparency >= 0.75:
             output.append("")
-            output.append(_why_line(topic, lines))
-
+            output.append(_why_line(resolved_topic))
         return "\n".join(output).strip()
 
-    output.extend(lines)
+    for line in shown:
+        output.append(f"- {line}")
 
-    if transparency >= 0.85 and help_mode != "answer":
+    if transparency >= 0.85:
         output.append("")
-        output.append(_why_line(topic, lines))
+        output.append(_why_line(resolved_topic))
 
     return "\n".join(output).strip()
 
 
-def _build_progression_sections(
+def _get_scaffold(result: Any):
+    return getattr(result, "scaffold", None)
+
+
+def _staged_scaffold_lines(
     result: Any,
-    help_mode: str,
     hint_stage: int,
     verbosity: float,
     transparency: float,
-    solver_steps: Optional[List[str]] = None,
-    can_reveal_answer: bool = False,
-    final_answer: Optional[str] = None,
 ) -> List[str]:
     output: List[str] = []
     scaffold = _get_scaffold(result)
     if scaffold is None:
         return output
 
-    ask = _coerce_string(getattr(scaffold, "ask", ""))
+    stage = max(0, min(int(hint_stage), 3))
+
     concept = _coerce_string(getattr(scaffold, "concept", ""))
-    target = _coerce_string(getattr(scaffold, "target", ""))
-    setup_actions = _coerce_list(getattr(scaffold, "setup_actions", []))
-    intermediate_steps = _coerce_list(getattr(scaffold, "intermediate_steps", []))
+    ask = _coerce_string(getattr(scaffold, "ask", ""))
     first_move = _coerce_string(getattr(scaffold, "first_move", ""))
     next_hint = _coerce_string(getattr(scaffold, "next_hint", ""))
+    setup_actions = _coerce_list(getattr(scaffold, "setup_actions", []))
+    intermediate_steps = _coerce_list(getattr(scaffold, "intermediate_steps", []))
     variables_to_define = _coerce_list(getattr(scaffold, "variables_to_define", []))
     equations_to_form = _coerce_list(getattr(scaffold, "equations_to_form", []))
     common_traps = _coerce_list(getattr(scaffold, "common_traps", []))
     hint_ladder = _coerce_list(getattr(scaffold, "hint_ladder", []))
     key_operations = _coerce_list(getattr(scaffold, "key_operations", []))
 
-    safe_steps = _safe_solver_steps(solver_steps)
+    if concept and stage == 0 and transparency >= 0.75:
+        output.append("Core idea:")
+        output.append(f"- {concept}")
+        output.append("")
 
-    if help_mode == "definition":
-        stage = 0
-    elif help_mode in {"walkthrough", "step_by_step"}:
-        stage = 3
-    elif help_mode == "answer" and can_reveal_answer:
-        stage = 3
-    elif help_mode == "answer":
-        stage = max(2, hint_stage)
-    else:
-        stage = min(max(hint_stage, 0), 3)
+    if ask:
+        output.append("What to identify first:")
+        output.append(f"- {ask}")
 
     if stage == 0:
-        if concept:
-            output.append(concept)
-        if ask:
-            output.append("")
-            output.append("What to identify:")
-            output.append(f"- {ask}")
         if first_move:
             output.append("")
             output.append("First move:")
             output.append(f"- {first_move}")
-        elif safe_steps:
+        elif hint_ladder:
             output.append("")
             output.append("First move:")
-            output.append(f"- {safe_steps[0]}")
+            output.append(f"- {hint_ladder[0]}")
         return output
 
+    if setup_actions:
+        output.append("")
+        output.append("Set-up path:")
+        for item in _limit_steps(setup_actions, verbosity, minimum=2 if stage >= 1 else 1):
+            output.append(f"- {item}")
+
+    if first_move:
+        output.append("")
+        output.append("First move:")
+        output.append(f"- {first_move}")
+
     if stage == 1:
-        if ask:
-            output.append("What to identify:")
-            output.append(f"- {ask}")
-        if setup_actions:
-            output.append("")
-            output.append("Set-up path:")
-            for item in setup_actions[:2]:
-                output.append(f"- {item}")
-        if first_move:
-            output.append("")
-            output.append("First move:")
-            output.append(f"- {first_move}")
         if next_hint:
             output.append("")
             output.append("Next hint:")
             output.append(f"- {next_hint}")
-        elif safe_steps:
+        elif len(hint_ladder) >= 2:
             output.append("")
             output.append("Next hint:")
-            output.append(f"- {safe_steps[0]}")
+            output.append(f"- {hint_ladder[1]}")
         return output
 
+    if intermediate_steps:
+        output.append("")
+        output.append("How to build it:")
+        for item in _limit_steps(intermediate_steps, verbosity, minimum=2):
+            output.append(f"- {item}")
+
+    if next_hint:
+        output.append("")
+        output.append("Next hint:")
+        output.append(f"- {next_hint}")
+
     if stage == 2:
-        if ask:
-            output.append("What to identify:")
-            output.append(f"- {ask}")
-        if target:
-            output.append("")
-            output.append(f"Target: {target}")
-        if setup_actions:
-            output.append("")
-            output.append("Set-up path:")
-            for item in setup_actions[: min(3, len(setup_actions))]:
-                output.append(f"- {item}")
-        progression_steps = intermediate_steps[:2] or safe_steps[:2]
-        if progression_steps:
-            output.append("")
-            output.append("Next steps:")
-            for item in progression_steps:
-                output.append(f"- {item}")
-        if next_hint:
-            output.append("")
-            output.append("Next hint:")
-            output.append(f"- {next_hint}")
-        if variables_to_define and transparency >= 0.45:
+        if variables_to_define:
             output.append("")
             output.append("Variables to define:")
             for item in variables_to_define[:2]:
                 output.append(f"- {item}")
-        if equations_to_form and transparency >= 0.5:
+        if equations_to_form:
             output.append("")
             output.append("Equations to form:")
             for item in equations_to_form[:2]:
                 output.append(f"- {item}")
+        if key_operations:
+            output.append("")
+            output.append("Key operations:")
+            for item in key_operations[:3]:
+                output.append(f"- {item}")
         return output
 
-    if ask:
-        output.append("What to identify first:")
-        output.append(f"- {ask}")
-
-    if setup_actions:
-        output.append("")
-        output.append("Set-up path:")
-        limit = 2 if verbosity < 0.4 else 3 if verbosity < 0.75 else 5
-        for item in setup_actions[:limit]:
-            output.append(f"- {item}")
-
-    deep_steps = intermediate_steps or safe_steps
-    if deep_steps:
-        output.append("")
-        output.append("How to build it:")
-        limit = 2 if verbosity < 0.75 else 4
-        for item in deep_steps[:limit]:
-            output.append(f"- {item}")
-
-    if first_move:
-        output.append("")
-        output.append("First move:")
-        output.append(f"- {first_move}")
-
-    if next_hint and (transparency >= 0.35 or verbosity >= 0.45):
-        output.append("")
-        output.append("Next hint:")
-        output.append(f"- {next_hint}")
-
-    if hint_ladder and verbosity >= 0.65:
-        output.append("")
-        output.append("Hint ladder:")
-        for item in hint_ladder[:3]:
-            output.append(f"- {item}")
-
-    if variables_to_define and verbosity >= 0.65:
+    if variables_to_define:
         output.append("")
         output.append("Variables to define:")
         for item in variables_to_define[:3]:
             output.append(f"- {item}")
 
-    if equations_to_form and transparency >= 0.55:
+    if equations_to_form:
         output.append("")
         output.append("Equations to form:")
         for item in equations_to_form[:3]:
             output.append(f"- {item}")
 
-    if key_operations and transparency >= 0.55:
+    if key_operations:
         output.append("")
         output.append("Key operations:")
         for item in key_operations[:3]:
             output.append(f"- {item}")
 
-    if (transparency >= 0.6 or verbosity >= 0.75) and common_traps:
+    if common_traps:
         output.append("")
         output.append("Watch out for:")
         for item in common_traps[:4]:
             output.append(f"- {item}")
 
-    if help_mode == "answer" and can_reveal_answer and final_answer:
-        output.append("")
-        output.append(f"Final answer: {final_answer}")
-
     return output
 
 
@@ -579,140 +351,49 @@ def format_explainer_response(
     tone: float,
     verbosity: float,
     transparency: float,
-    help_mode: str = "explain",
     hint_stage: int = 0,
-    solver_steps: Optional[List[str]] = None,
-    can_reveal_answer: bool = False,
-    final_answer: Optional[str] = None,
 ) -> str:
     if not result or not getattr(result, "understood", False):
         return "I can help explain what the question is asking, but I need the full wording of the question."
 
     output: List[str] = []
-
-    header = _explainer_header(tone)
-    if header:
-        output.append(header)
+    prefix = style_prefix(tone)
+    if prefix:
+        output.append(prefix)
         output.append("")
 
-    summary = _coerce_string(getattr(result, "summary", ""))
-    teaching_points = _coerce_list(getattr(result, "teaching_points", []))
+    output.append("Question breakdown:")
+    output.append("")
 
-    if summary and not _is_wrapper_line(summary):
+    summary = _coerce_string(getattr(result, "summary", ""))
+    if summary:
         output.append(summary)
 
-    scaffold_sections = _build_progression_sections(
+    scaffold_lines = _staged_scaffold_lines(
         result=result,
-        help_mode=help_mode,
         hint_stage=hint_stage,
         verbosity=verbosity,
         transparency=transparency,
-        solver_steps=solver_steps,
-        can_reveal_answer=can_reveal_answer,
-        final_answer=final_answer,
     )
-    if scaffold_sections:
-        output.extend(scaffold_sections)
+    if scaffold_lines:
+        if summary:
+            output.append("")
+        output.extend(scaffold_lines)
 
-    if teaching_points and verbosity >= 0.55 and hint_stage >= 2:
+    teaching_points = _coerce_list(getattr(result, "teaching_points", []))
+    if teaching_points and (verbosity >= 0.55 or hint_stage >= 2):
         output.append("")
         output.append("Key teaching points:")
-        limit = 2 if verbosity < 0.75 else 4
-        for item in teaching_points[:limit]:
+        for item in _limit_steps(teaching_points, verbosity, minimum=2):
             output.append(f"- {item}")
 
-    plain = _coerce_string(getattr(result, "plain_english", ""))
-    if plain and not summary and not _is_wrapper_line(plain):
-        output.append(plain)
-
-    asks_for = _coerce_string(getattr(result, "asks_for", ""))
-    if asks_for and transparency >= 0.35 and hint_stage >= 2:
-        output.append("")
-        output.append(f"The question is asking for: {asks_for}")
-
-    if verbosity >= 0.45 and hint_stage >= 2:
-        _append_section(
-            output,
-            "What the question gives you:",
-            getattr(result, "givens", []) or [],
-            5 if verbosity >= 0.7 else 3,
-        )
-
-    if verbosity >= 0.7 and hint_stage >= 3:
-        _append_section(
-            output,
-            "Constraints or conditions:",
-            getattr(result, "constraints", []) or [],
-            5,
-        )
-
-    if transparency >= 0.5 and hint_stage >= 2:
-        _append_section(
-            output,
-            "Key relationship:",
-            getattr(result, "relationships", []) or [],
-            4,
-        )
-
-    if transparency >= 0.55 and hint_stage >= 2:
-        _append_section(
-            output,
-            "Concepts you will probably need:",
-            getattr(result, "needed_concepts", []) or [],
-            4,
-        )
-
-    if (transparency >= 0.6 or verbosity >= 0.75) and hint_stage >= 3:
-        _append_section(
-            output,
-            "Watch out for:",
-            getattr(result, "trap_notes", []) or [],
-            4,
-        )
-
-    strategy_hint = _coerce_string(getattr(result, "strategy_hint", ""))
-    if strategy_hint and verbosity >= 0.35 and not _is_wrapper_line(strategy_hint) and hint_stage >= 1:
-        output.append("")
-        output.append(f"Best starting move: {strategy_hint}")
+    topic = _extract_topic_from_text(
+        f"{summary} {' '.join(teaching_points)}",
+        getattr(result, "topic", None),
+    )
 
     if transparency >= 0.8:
-        topic = _explainer_topic(result)
-        why_seed_lines: List[str] = []
-
-        if summary:
-            why_seed_lines.append(summary)
-
-        scaffold = _get_scaffold(result)
-        if scaffold is not None:
-            ask = _coerce_string(getattr(scaffold, "ask", ""))
-            first_move = _coerce_string(getattr(scaffold, "first_move", ""))
-            if ask:
-                why_seed_lines.append(ask)
-            if first_move:
-                why_seed_lines.append(first_move)
-
-        if not why_seed_lines:
-            why_seed_lines.extend(teaching_points[:2])
-
-        if why_seed_lines:
-            output.append("")
-            output.append(_why_line(topic, why_seed_lines))
-
-    final_lines = []
-    previous_key = None
-    for line in output:
-        if line is None:
-            continue
-        text = str(line).rstrip()
-        key = _normalize_key(text)
-        if key == previous_key and key:
-            continue
-        final_lines.append(text)
-        previous_key = key
-
-    text = "\n".join(final_lines).strip()
-
-    if not text:
-        return "I can help explain what the question is asking, but I need the full wording of the question."
+        output.append("")
+        output.append(_why_line(topic))
 
-    return text
+    return "\n".join(_dedupe_lines(output)).strip()