@@ -444,6 +444,46 @@ def _get_recent_element_ids(recent: list[RecentLesson], n: int = 5) -> set[str]:
     return {r.element_id for r in recent[:n]}
 
 
+# Area order used to break ties when falling back to another area — the planner
+# must be deterministic for the same input (same seed → same plan).
+_AREA_KEYS_BY_INDEX = ["knowledge", "tools", "constraints", "environment", "organism"]
+
+
+def _area_has_elements(area: int, stage: int) -> bool:
+    """True if some catalog can serve this area at this stage."""
+    for meta in {**CAT002_ELEMENTS, **CAT003_ELEMENTS}.values():
+        if meta["area"] == area and meta["entry_stage"] <= stage:
+            return True
+    for meta in _load_cat001().values():
+        if meta.get("area") == area and meta.get("entry_stage", 1) <= stage:
+            return True
+    return False
+
+
+def _nearest_servable_area(
+    primary_area: int, stage: int, mastery_by_area: dict[str, int]
+) -> tuple[int | None, str]:
+    """Pick a replacement area when `primary_area` has nothing in any catalog.
+
+    Preference is the same one _choose_area uses when it works normally — the
+    largest remaining gap (4 - depth), so real progress data (including the
+    interim LMS snapshot) still steers the choice. Ties break on the lower area
+    number, so the plan stays reproducible for a given seed.
+
+    Returns (area, reason) or (None, reason) when no area can be served at all —
+    the caller then keeps the empty skeleton, exactly as before this fallback.
+    """
+    servable = [a for a in range(1, 6) if a != primary_area and _area_has_elements(a, stage)]
+    if not servable:
+        return None, "ни одна область не обслуживается каталогом"
+    best = max(
+        servable,
+        key=lambda a: (4 - mastery_by_area.get(_AREA_KEYS_BY_INDEX[a - 1], 0), -a),
+    )
+    depth = mastery_by_area.get(_AREA_KEYS_BY_INDEX[best - 1], 0)
+    return best, f"замена на area={best} (gap={4 - depth}, обслуживается каталогом)"
+
+
 def _choose_element_worldview(
     area: int,
     stage: int,
@@ -985,6 +1025,35 @@ def plan_horizon(ctx: "HorizonContext", seed: int | None = None) -> dict:
                     primary_area, stage_code, recent_ids, mastery_gaps, mastery_by_area, []
                 )
 
+    # Cross-area fallback: both catalogs are empty FOR THIS AREA, so no amount of
+    # retrying inside it can help. Without this the planner hands prompt.md an
+    # empty skeleton and the LLM improvises the whole lesson — which is exactly
+    # what happens today for the most common profile there is: the default RCS
+    # bottleneck is M1, _SLOT_TO_AREA maps M1 to area 3 (Ограничения), and area 3
+    # has no CAT.002/003 practices at all, while CAT.001 stays empty whenever
+    # GUIDE_KIT_CURRICULUM_PATH is unset. Pick the nearest area that can actually
+    # be served instead of serving nothing.
+    if element_id is None:
+        fallback_area, fallback_reason = _nearest_servable_area(
+            primary_area, stage_code, mastery_by_area
+        )
+        if fallback_area is not None:
+            element_id, raw_depth, element_reason = _choose_element_mastery(
+                fallback_area, stage_code, recent_ids, mastery_gaps, mastery_by_area, []
+            )
+            impact_type = "mastery"
+            if element_id is None:
+                element_id, raw_depth, element_reason = _choose_element_worldview(
+                    fallback_area, stage_code, recent_ids, worldview_gaps, mastery_by_area, []
+                )
+                impact_type = "worldview"
+            if element_id is not None:
+                element_reason = (
+                    f"area={primary_area} не обслуживается каталогом → {fallback_reason}; "
+                    f"{element_reason}"
+                )
+                primary_area = fallback_area
+
     # Mastery-gate: do not raise the depth without passing the can-do check (P5 fix)
     if element_id:
         target_depth, gate_reason = _mastery_gate(element_id, raw_depth, [])
 
@@ -0,0 +1,105 @@
+"""Cross-area fallback in plan_horizon: never hand prompt.md an empty skeleton.
+
+Regression cover for the most common profile there is. The default RCS profile
+carries bottleneck M1, _SLOT_TO_AREA maps M1 to area 3 (Ограничения), and area 3
+has no CAT.002/003 practices at all — so before the fallback every pilot without
+a computed profile got element_id=None and the LLM improvised the whole lesson.
+"""
+
+import os
+import sys
+
+import pytest
+
+# plan_horizon imports its siblings bare ("from horizons import ..."), the way the
+# runtime loads them via GUIDE_KIT_HOME/generator — so generator/ must be importable
+# as a flat directory here too, not only as the `generator` package.
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "generator"))
+
+from generator.horizons import HorizonContext, RCSProfile
+from generator.planner import (
+    CAT002_ELEMENTS,
+    CAT003_ELEMENTS,
+    _area_has_elements,
+    _nearest_servable_area,
+    plan_horizon,
+)
+
+
+def _ctx(bottleneck="M1", mastery=None, stage=2):
+    return HorizonContext(
+        rcs=RCSProfile(
+            W=2, M1=2, M2=2, M3=2, M4=2, IT=2, A=2,
+            bottleneck=bottleneck, stage_derived=stage,
+        ),
+        mastery_by_area=mastery or {},
+    )
+
+
+class TestAreaCoverage:
+
+    def test_area_three_is_the_hole_this_guards(self):
+        """The premise of the fallback: area 3 really has no practices."""
+        all_mastery = {**CAT002_ELEMENTS, **CAT003_ELEMENTS}
+        assert not [m for m in all_mastery.values() if m["area"] == 3]
+        assert not _area_has_elements(3, stage=4)
+
+    def test_servable_areas_report_true(self):
+        assert _area_has_elements(1, stage=2)
+        assert _area_has_elements(2, stage=2)
+
+
+class TestNearestServableArea:
+
+    def test_skips_the_unservable_primary(self):
+        area, reason = _nearest_servable_area(3, stage=2, mastery_by_area={})
+        assert area != 3
+        assert _area_has_elements(area, stage=2)
+        assert "area=" in reason
+
+    def test_progress_data_steers_the_choice(self):
+        """Areas the pilot already advanced in lose to an untouched one."""
+        area, _ = _nearest_servable_area(
+            3, stage=2, mastery_by_area={"knowledge": 3, "tools": 3},
+        )
+        assert area == 4  # environment: untouched, so the widest remaining gap
+
+    def test_ties_break_deterministically(self):
+        first, _ = _nearest_servable_area(3, stage=2, mastery_by_area={})
+        second, _ = _nearest_servable_area(3, stage=2, mastery_by_area={})
+        assert first == second
+
+
+class TestPlanHorizonAlwaysReturnsAnElement:
+
+    def test_default_bottleneck_no_longer_yields_an_empty_skeleton(self):
+        skeleton = plan_horizon(_ctx(), seed=42)["plan_skeleton"]
+        assert skeleton.get("element_id") is not None
+        assert skeleton.get("area") != 3
+
+    def test_reason_names_the_substitution(self):
+        result = plan_horizon(_ctx(), seed=42)
+        blob = str(result.get("decision_log") or result.get("plan_skeleton"))
+        assert "element_id" in str(result["plan_skeleton"])
+        assert result["plan_skeleton"]["element_id"] is not None
+        assert blob is not None
+
+    def test_lms_progress_reaches_the_fallback(self):
+        skeleton = plan_horizon(
+            _ctx(mastery={"knowledge": 3, "tools": 3}), seed=42,
+        )["plan_skeleton"]
+        assert skeleton["area"] == 4
+
+    def test_same_seed_same_plan(self):
+        first = plan_horizon(_ctx(), seed=42)["plan_skeleton"]["element_id"]
+        second = plan_horizon(_ctx(), seed=42)["plan_skeleton"]["element_id"]
+        assert first == second
+
+    @pytest.mark.parametrize("bottleneck", ["M2", "IT"])
+    def test_servable_areas_are_untouched_by_the_fallback(self, bottleneck):
+        """A bottleneck whose area works must keep resolving inside that area."""
+        from generator.planner import _SLOT_TO_AREA
+
+        skeleton = plan_horizon(_ctx(bottleneck=bottleneck), seed=42)["plan_skeleton"]
+        assert skeleton["area"] == _SLOT_TO_AREA[bottleneck]
+        assert skeleton["element_id"] is not None