Add robust comparison whiteboard template

board_model_prompt.py

@@ -28,7 +28,7 @@ Ops:
 {"op":"highlight","at":[x,y],"w":W}
 Colors: ink, blue, red, green, orange, purple, gray. Use ^ for exponents in text.
 
-Draw the step's REAL content (actual names, values, shapes) with 2-5 compact ops, unless it is only a check-in. The board should teach visually about as much as the voice does: if the narration names a part, value, result, or relationship, add a mark for it. Use compact boxes/ellipses, usually under 18 wide and 10 high; main diagrams should leave room for notes, formulas, and callouts. Use callout to circle important labels like c and explain them with a short leader line. Keep related items adjacent instead of drawing long arrows. Every unlabeled arrow must connect two visible items; do not point into empty space. Build on what is already on the board — never redraw it, never collide with it."""
+Draw the step's REAL content (actual names, values, shapes) with 2-5 compact ops, unless it is only a check-in. The board should teach visually about as much as the voice does: if the narration names a part, value, result, or relationship, add a mark for it. For "X vs Y", "compare X and Y", or "difference between X and Y", use a two-column comparison layout with one side for each named thing; never stack the two options vertically with unrelated arrows. Use compact boxes/ellipses, usually under 18 wide and 10 high; main diagrams should leave room for notes, formulas, and callouts. Use callout to circle important labels like c and explain them with a short leader line. Keep related items adjacent instead of drawing long arrows. Every unlabeled arrow must connect two visible items; do not point into empty space. Build on what is already on the board — never redraw it, never collide with it."""
 
 
 def board_context(prior_ops):

board_quality.py

@@ -17,6 +17,8 @@ def _blob(*parts):
 
 def diagram_family(question, say=""):
     text = _blob(question, say)
+    if _comparison_terms(question, say):
+        return "comparison"
     if ("rocket" in text or "spacecraft" in text or "launch" in text) and (
         "orbit" in text or "gravity turn" in text or "orbital" in text
     ):
@@ -64,14 +66,15 @@ def improve_step_board(question, step_index, say, board):
     board = [dict(op) for op in (board or []) if isinstance(op, dict)]
     family = diagram_family(question, say)
     if family:
-        templated = _template(family, step_index, question)
+        templated = _template(family, step_index, question, say)
         if templated is not None:
             return templated
     return _repair_generic(question, step_index, say, board)
 
 
-def _template(family, step_index, question=""):
+def _template(family, step_index, question="", say=""):
     templates = {
+        "comparison": _comparison,
         "rocket_orbit": _rocket_orbit,
         "model_access_directive": _model_access_directive,
         "no_code_platform": _no_code_platform,
@@ -87,9 +90,98 @@ def _template(family, step_index, question=""):
     }
     if family == "no_code_platform":
         return templates[family](step_index, question)
+    if family == "comparison":
+        return templates[family](step_index, question, say)
     return templates[family](step_index)
 
 
+def _clean_term(text):
+    text = re.sub(r"[?!.\"]", "", str(text or "")).strip(" :,-")
+    text = re.sub(
+        r"^(explain|teach me|show me|tell me about|what is|what's|whats|how is|how are|compare)\s+",
+        "", text, flags=re.I,
+    )
+    text = re.split(
+        r"\s+(?:for|if|when|because|in order to|so that)\s+",
+        text, maxsplit=1, flags=re.I,
+    )[0]
+    words = text.split()[:4]
+    text = " ".join(words).strip(" :,-")
+    known = {"linkedin": "LinkedIn", "linkme": "Linkme"}
+    return known.get(text.lower(), text[:24] or "Option")
+
+
+def _comparison_terms(question, say=""):
+    src = str(question or "") or str(say or "")
+    patterns = [
+        r"(.+?)\s+(?:vs\.?|versus)\s+(.+?)(?:[?.,]|$)",
+        r"(?:difference between|compare)\s+(.+?)\s+(?:and|with|to)\s+(.+?)(?:[?.,]|$)",
+    ]
+    for pat in patterns:
+        m = re.search(pat, src, flags=re.I)
+        if not m:
+            continue
+        left, right = _clean_term(m.group(1)), _clean_term(m.group(2))
+        if left and right and left.lower() != right.lower():
+            return left, right
+    return None
+
+
+def _comparison_lines(name, question, say):
+    low = name.lower()
+    if low == "linkme":
+        return ["one shareable URL", "bio / portfolio links", "send people outward"]
+    if low == "linkedin":
+        return ["career profile", "jobs + recruiters", "professional network"]
+
+    text = str(say or question or "")
+    for sent in re.split(r"[.;]\s*", text):
+        if low not in sent.lower():
+            continue
+        lines = _note_lines(sent)
+        if lines:
+            return lines[:3]
+    return ["main purpose", "best-fit use", "when to choose it"]
+
+
+def _comparison(i, question="", say=""):
+    left, right = _comparison_terms(question, say) or ("Option A", "Option B")
+    left_lines = _comparison_lines(left, question, say)
+    right_lines = _comparison_lines(right, question, say)
+    if {left.lower(), right.lower()} == {"linkme", "linkedin"}:
+        linkme = left if left.lower() == "linkme" else right
+        linkedin = left if left.lower() == "linkedin" else right
+        decision = f"{linkme}: links; {linkedin}: jobs"
+    else:
+        decision = "Choose by goal, not name"
+    steps = [
+        [
+            {"op": "title", "text": f"{left} vs {right}"},
+            {"op": "box", "at": [8, 25], "w": 30, "h": 10,
+             "label": left, "color": "blue"},
+            {"op": "box", "at": [62, 25], "w": 30, "h": 10,
+             "label": right, "color": "purple"},
+            {"op": "line", "from": [50, 22], "to": [50, 68],
+             "color": "gray", "dash": True},
+        ],
+        [
+            {"op": "notes", "title": f"{left} fits",
+             "lines": left_lines, "at": [8, 42], "color": "blue",
+             "compact": True},
+        ],
+        [
+            {"op": "notes", "title": f"{right} fits",
+             "lines": right_lines, "at": [62, 42], "color": "purple",
+             "compact": True},
+        ],
+        [
+            {"op": "text", "text": decision, "at": [35, 19],
+             "size": "s", "color": "green", "fit_w": 42},
+        ],
+    ]
+    return steps[i] if i < len(steps) else None
+
+
 def _topic_title(question, fallback="How It Works"):
     text = re.sub(r"[?!.\"]", "", str(question or "")).strip()
     text = re.sub(r"^(explain|teach me|show me|tell me about)\s+", "", text, flags=re.I)

engine.py

@@ -233,6 +233,10 @@ Rules for "steps":
 - For "how X works" lessons, do not stop at two boxes. Draw the working system:
   3 to 5 topic-specific parts, causal arrows with short labels, and one compact
   note block that explains what the diagram means.
+- For comparison lessons ("X vs Y", "compare X and Y", "difference between X and Y"),
+  use a two-column comparison board with one side for each named thing, short feature
+  notes under each side, and a compact takeaway. Do not stack the two options
+  vertically or connect them with arrows unless there is a real causal relationship.
 - Values like "a = 3" are lines inside the notes block, NEVER standalone text ops.
 - Each step draws ONLY NEW marks. Never redraw the title, the diagram, or anything
   already on the board — duplicates are discarded.

mock_engine.py

@@ -44,14 +44,23 @@ def _step(say, board):
 
 
 def _templated_lesson(topic):
-    if diagram_family(topic) != "pythagorean":
+    family = diagram_family(topic)
+    if family not in {"pythagorean", "comparison"}:
         return None
-    says = [
-        "Let's identify the right triangle first: the two legs make the L shape, and c is the hypotenuse across from it.",
-        "The theorem says the square on c equals the two leg squares added together.",
-        "For a concrete example, set a to three and b to four, then substitute those values into the formula.",
-        "That gives twenty five, so c is five. Notice five is the longest side, which matches the drawing.",
-    ]
+    if family == "pythagorean":
+        says = [
+            "Let's identify the right triangle first: the two legs make the L shape, and c is the hypotenuse across from it.",
+            "The theorem says the square on c equals the two leg squares added together.",
+            "For a concrete example, set a to three and b to four, then substitute those values into the formula.",
+            "That gives twenty five, so c is five. Notice five is the longest side, which matches the drawing.",
+        ]
+    else:
+        says = [
+            f"Let's compare {topic} by purpose instead of drawing a generic flowchart.",
+            "The left side is for the first option's best-fit job and the context where it makes sense.",
+            "The right side is for the second option's job, so the differences stay parallel and easy to scan.",
+            "The takeaway is to choose based on what you are trying to accomplish, not which name sounds broader.",
+        ]
     out = []
     for i, say in enumerate(says):
         board = improve_step_board(topic, i, say, [])

test_board_quality.py

@@ -80,6 +80,27 @@ class BoardQualityTests(unittest.TestCase):
         xs = [p[0] for p in tri["points"]]
         self.assertLessEqual(max(xs) - min(xs), 40)
 
+    def test_unique_comparisons_get_structured_two_column_board(self):
+        self.assertEqual(diagram_family("Linkme vs LinkedIn"), "comparison")
+        ns = load_engine_ns()
+        question = "Linkme vs LinkedIn"
+        violations, ops = simulate_lesson(ns, _template_steps(question))
+        self.assertEqual(violations, [])
+        parts = []
+        for op in ops:
+            parts.extend(str(op.get(k, "")) for k in ("text", "label", "title"))
+            parts.extend(str(line) for line in op.get("lines", []) or [])
+        text = " ".join(parts)
+        self.assertIn("Linkme", text)
+        self.assertIn("LinkedIn", text)
+        self.assertIn("one shareable URL", text)
+        self.assertIn("jobs + recruiters", text)
+        boxes = [op for op in ops if op.get("op") == "box"]
+        self.assertEqual(len(boxes), 2)
+        self.assertLess(boxes[0]["at"][0], 40)
+        self.assertGreater(boxes[1]["at"][0], 55)
+        self.assertFalse(any(op.get("op") == "arrow" for op in ops))
+
     def test_fable_mythos_access_template_matches_directive(self):
         self.assertEqual(
             diagram_family("Anthropic Fable 5 Mythos 5 government ban access"),
@@ -104,6 +125,7 @@ class BoardQualityTests(unittest.TestCase):
         self.assertEqual(diagram_family("How do neural networks learn?"), "neural_network")
         self.assertEqual(diagram_family("Explain supply and demand"), "supply_demand")
         self.assertEqual(diagram_family("How does Unqork work?"), "no_code_platform")
+        self.assertEqual(diagram_family("Compare Notion and Airtable"), "comparison")
         self.assertEqual(diagram_family("What happened in space exploration this month?"), None)
 
     def test_checkin_steps_stay_empty_when_model_drew_nothing(self):
@@ -124,6 +146,8 @@ class BoardQualityTests(unittest.TestCase):
             "How does photosynthesis work?",
             "How do rainbows form?",
             "Explain the water cycle",
+            "Linkme vs LinkedIn",
+            "Compare Notion and Airtable",
         ]
         for question in cases:
             with self.subTest(question=question):