Add a couple of more sql templates for natural earth & chained queries

dataset/README.md

@@ -3,8 +3,11 @@
 Generates synthetic training data for fine-tuning the geocoding model.
 Two datasets come out of one pipeline run:
 
-- **SQL generation** — `(question + candidates) → DuckDB SQL`
-- **Place extraction** — `question → place names JSON`
+- **SQL generation** — `(question + candidates) -> DuckDB SQL`
+- **Place extraction** — `question -> place names JSON`
+
+Both tasks export in **conversation format** (`messages` list of
+system/user/assistant turns), ready for chat-template fine-tuning.
 
 ---
 
@@ -106,16 +109,38 @@ After running, your training files are at:
 ```
 dataset/output/runs/{run_name}/
   sql/
-    train.jsonl    ← use this to fine-tune the SQL generation model
+    train.jsonl    <- fine-tune the SQL generation model
     val.jsonl
     test.jsonl
   places/
-    train.jsonl    ← use this to fine-tune the place extraction model
+    train.jsonl    <- fine-tune the place extraction model
     val.jsonl
     test.jsonl
-  stats.json       ← sample counts by family
+  stats.json       <- sample counts by family
+```
+
+Each JSONL row is a conversation-format dict:
+
+```json
+{
+  "messages": [
+    {"role": "system",    "content": "..."},
+    {"role": "user",      "content": "..."},
+    {"role": "assistant", "content": "..."}
+  ]
+}
 ```
 
+**SQL task**: the system prompt includes the full two-table schema inside
+`<SCHEMA>` tags. The user prompt contains only `<CANDIDATES>` CSV and
+`<USER_QUERY>`. The assistant response is pretty-printed SQL (via `sqlparse`).
+All parquet paths are symbolic (`divisions_area` / `natural_earth`), never
+runtime-specific.
+
+**Places task**: the system prompt includes output format, extraction rules,
+and the full list of Overture subtypes. The assistant response is a JSON
+object with a `places` array.
+
 ---
 
 ## When to regenerate from scratch
@@ -125,7 +150,8 @@ Change `run_name` and run without `--append` whenever you:
 - Change any SQL templates (`sql_templates.py`)
 - Add new template families
 - Change the candidate format or count
-- Change the training prompt/completion format
+- Change the system/user prompt structure or content
+- Change the export format (e.g. prompt/completion to messages)
 
 Use `--append` only when you're adding more samples of the same type
 (e.g. adding more countries to an existing run with identical templates).

dataset/config.yaml

@@ -34,7 +34,7 @@ sample_targets:
 generation:
   max_workers: 8           # Number of parallel workers
   retry_multiplier: 2      # Generate 2x samples to account for failures
-  append_mode: true        # If true, append to existing dataset instead of overwriting
+  append_mode: false       # Set false for clean regeneration after template/format changes
 
 # Auto-scaling configuration
 # Relation limits are automatically calculated: target * retry_multiplier * safety_factor
@@ -66,4 +66,4 @@ output:
 # Run name — used to version exported splits so re-runs never overwrite previous data.
 # Change this whenever you regenerate from scratch (e.g. after template changes).
 # Exported files land in: output/runs/{run_name}/
-run_name: "v3-symbolic-paths"
+run_name: "v4-conversation-format"

dataset/scripts/sql_templates.py

@@ -84,12 +84,16 @@ TEMPLATES = [
             "Show me {anchor_name}",
             "Get the boundary of {anchor_name}",
             "Find {anchor_name}",
-            "Show the geometry of {anchor_name}",
             "Where is {anchor_name}?",
             "Give me the outline of {anchor_name}",
-            "Fetch {anchor_name}",
             "Display {anchor_name} on a map",
             "What does {anchor_name} look like?",
+            "I need the shape of {anchor_name}",
+            "Pull up {anchor_name}",
+            "Can you show {anchor_name}?",
+            "Map of {anchor_name}",
+            "{anchor_name} boundary",
+            "Locate {anchor_name} for me",
         ],
     ),
 
@@ -112,8 +116,12 @@ TEMPLATES = [
             "Where is the {anchor_name}?",
             "Show the extent of the {anchor_name}",
             "Give me the geometry of the {anchor_name}",
-            "Fetch the {anchor_name}",
             "Display the {anchor_name}",
+            "Pull up the {anchor_name}",
+            "I want to see the {anchor_name}",
+            "Map the {anchor_name}",
+            "How big is the {anchor_name}?",
+            "Outline of the {anchor_name}",
         ],
     ),
 
@@ -142,7 +150,9 @@ TEMPLATES = [
             "What shares a border with {anchor_name}?",
             "Neighbours of {anchor_name}",
             "What is adjacent to {anchor_name}?",
-            "All places that share a boundary with {anchor_name}",
+            "What surrounds {anchor_name}?",
+            "Places next to {anchor_name}",
+            "Everything bordering {anchor_name}",
         ],
     ),
 
@@ -170,8 +180,8 @@ TEMPLATES = [
             "{target_subtype}s that touch {anchor_name}",
             "Neighbouring {target_subtype}s of {anchor_name}",
             "Which {target_subtype}s are adjacent to {anchor_name}?",
-            "States bordering {anchor_name}",
-            "Countries that share a boundary with {anchor_name}",
+            "{target_subtype}s along the {anchor_name} border",
+            "Find {target_subtype}s next to {anchor_name}",
         ],
     ),
 
@@ -200,6 +210,8 @@ TEMPLATES = [
             "Which oceans touch {anchor_name}?",
             "What coastline does {anchor_name} have?",
             "Which water bodies does {anchor_name} border?",
+            "Does {anchor_name} have access to the sea?",
+            "What ocean is {anchor_name} on?",
         ],
     ),
 
@@ -229,8 +241,8 @@ TEMPLATES = [
             "Which regions border both {anchor_1_name} and {anchor_2_name}?",
             "What places touch both {anchor_1_name} and {anchor_2_name}?",
             "Regions adjacent to both {anchor_1_name} and {anchor_2_name}",
-            "Which states share a border with both {anchor_1_name} and {anchor_2_name}?",
-            "Countries that are neighbours of both {anchor_1_name} and {anchor_2_name}",
+            "What lies between {anchor_1_name} and {anchor_2_name}?",
+            "Common neighbours of {anchor_1_name} and {anchor_2_name}",
         ],
     ),
 
@@ -260,8 +272,8 @@ TEMPLATES = [
             "List all {target_subtype}s inside {anchor_name}",
             "{target_subtype}s contained by {anchor_name}",
             "All {target_subtype}s within the boundaries of {anchor_name}",
-            "Cities in {anchor_name}",
-            "Towns inside {anchor_name}",
+            "{target_subtype}s of {anchor_name}",
+            "Show every {target_subtype} in {anchor_name}",
         ],
     ),
 
@@ -288,6 +300,9 @@ TEMPLATES = [
             "Which country is {anchor_name} in?",
             "What country does {anchor_name} belong to?",
             "Which nation contains {anchor_name}?",
+            "{anchor_name} is part of which country?",
+            "Where does {anchor_name} fall geographically?",
+            "What country is {anchor_name} located in?",
         ],
     ),
 
@@ -314,6 +329,8 @@ TEMPLATES = [
             "{target_subtype}s inside the {anchor_name}",
             "Administrative {target_subtype}s within the {anchor_name}",
             "All regions contained by the {anchor_name}",
+            "What {target_subtype}s does the {anchor_name} contain?",
+            "{target_subtype}s covered by the {anchor_name}",
         ],
     ),
 
@@ -342,6 +359,8 @@ TEMPLATES = [
             "What {target_subtype}s overlap with {anchor_name}?",
             "{target_subtype}s that cross into {anchor_name}",
             "Which {target_subtype}s overlap {anchor_name}?",
+            "{target_subtype}s partially inside {anchor_name}",
+            "What {target_subtype}s extend into {anchor_name}?",
         ],
     ),
 
@@ -368,10 +387,10 @@ TEMPLATES = [
             "Countries that overlap with the {anchor_name}",
             "Which countries touch the {anchor_name}?",
             "Nations intersected by the {anchor_name}",
-            "Countries the {anchor_name} flows through",
             "Which nations does the {anchor_name} cross?",
             "Countries along the {anchor_name}",
-            "States the {anchor_name} runs through",
+            "What countries does the {anchor_name} cover?",
+            "Countries that the {anchor_name} spans across",
         ],
     ),
 
@@ -523,9 +542,9 @@ TEMPLATES = [
             "{target_subtype}s in {anchor_name} with sea access",
             "Which {target_subtype}s in {anchor_name} are on the coast?",
             "Seaside {target_subtype}s within {anchor_name}",
-            "Coastal towns of {anchor_name}",
-            "Which towns in {anchor_name} touch the ocean?",
             "{target_subtype}s in {anchor_name} bordering the sea",
+            "Oceanfront {target_subtype}s in {anchor_name}",
+            "Which {target_subtype}s in {anchor_name} have a coastline?",
         ],
     ),
 
@@ -555,9 +574,9 @@ TEMPLATES = [
             "Landlocked {target_subtype}s in {anchor_name}",
             "Which {target_subtype}s in {anchor_name} have no sea access?",
             "{target_subtype}s in {anchor_name} that are landlocked",
-            "Countries in {anchor_name} with no coastline",
-            "Which countries near {anchor_name} are landlocked?",
-            "Landlocked nations in the region of {anchor_name}",
+            "{target_subtype}s in {anchor_name} with no coastline",
+            "Which {target_subtype}s within {anchor_name} are landlocked?",
+            "Interior {target_subtype}s of {anchor_name} with no ocean border",
         ],
     ),
 
@@ -584,10 +603,10 @@ TEMPLATES = [
             "   )"
         ),
         question_hints=[
-            "{target_subtype}s in {anchor_name} in a terrain or island area",
-            "Hill or mountain {target_subtype}s within {anchor_name}",
-            "{target_subtype}s of {anchor_name} on terrain features",
-            "Island or highland {target_subtype}s of {anchor_name}",
+            "{target_subtype}s in {anchor_name} on a terrain feature or island",
+            "{target_subtype}s of {anchor_name} on a peninsula or island group",
+            "{target_subtype}s within {anchor_name} on notable landforms",
+            "Island and peninsula {target_subtype}s of {anchor_name}",
         ],
     ),
 
@@ -618,6 +637,8 @@ TEMPLATES = [
             "{anchor_1_name} without the {anchor_2_name} area",
             "Remove {anchor_2_name} from {anchor_1_name}",
             "{anchor_1_name} with {anchor_2_name} cut out",
+            "Subtract {anchor_2_name} from {anchor_1_name}",
+            "What is left of {anchor_1_name} after removing {anchor_2_name}?",
         ],
     ),
 
@@ -643,6 +664,8 @@ TEMPLATES = [
             "{anchor_name} excluding the {clip_feature_name}",
             "{anchor_name} minus the {clip_feature_name}",
             "The land area of {anchor_name} not covered by the {clip_feature_name}",
+            "{anchor_name} with the {clip_feature_name} removed",
+            "What remains of {anchor_name} after removing the {clip_feature_name}?",
         ],
     ),
 
@@ -678,6 +701,7 @@ TEMPLATES = [
             "Area within {buffer_km} km of the {anchor_1_name}-{anchor_2_name} border",
             "The region straddling the border of {anchor_1_name} and {anchor_2_name} within {buffer_km} km",
             "{buffer_km} km on either side of the {anchor_1_name} and {anchor_2_name} border",
+            "Buffer the {anchor_1_name}-{anchor_2_name} boundary by {buffer_km} km",
         ],
     ),
 
@@ -1198,6 +1222,394 @@ TEMPLATES = [
         ],
     ),
 
+    # ── NATURAL EARTH ADJACENCY ─────────────────────────────────────────────
+    # Division anchor, natural_earth targets. Handler formats anchor_id and
+    # target_subtype but the SQL hardcodes NE subtypes (like adj_03).
+
+    SQLTemplate(
+        template_id="adj_04",
+        family="adjacency",
+        sql_difficulty="medium",
+        anchor_source="divisions_area",
+        num_anchors=1,
+        target_subtype="river",
+        sql_template=(
+            "WITH a AS ("
+            "  SELECT geometry FROM read_parquet('divisions_area') WHERE id = '{anchor_id}'"
+            ")"
+            " SELECT n.id, n.names.\"primary\" AS name, n.subtype,"
+            "        ST_AsGeoJSON(n.geometry) AS geometry"
+            " FROM read_parquet('natural_earth') AS n, a"
+            " WHERE n.subtype IN ('River', 'Lake', 'Basin')"
+            "   AND ST_Intersects(a.geometry, n.geometry)"
+        ),
+        question_hints=[
+            "What rivers or lakes are in {anchor_name}?",
+            "Natural water features of {anchor_name}",
+            "Which rivers flow through {anchor_name}?",
+            "Lakes and rivers within {anchor_name}",
+            "Water features inside {anchor_name}",
+            "What bodies of water cross {anchor_name}?",
+            "Rivers of {anchor_name}",
+            "Show me the lakes in {anchor_name}",
+        ],
+    ),
+
+    SQLTemplate(
+        template_id="adj_05",
+        family="adjacency",
+        sql_difficulty="medium",
+        anchor_source="divisions_area",
+        num_anchors=1,
+        target_subtype="range",
+        sql_template=(
+            "WITH a AS ("
+            "  SELECT geometry FROM read_parquet('divisions_area') WHERE id = '{anchor_id}'"
+            ")"
+            " SELECT n.id, n.names.\"primary\" AS name, n.subtype,"
+            "        ST_AsGeoJSON(n.geometry) AS geometry"
+            " FROM read_parquet('natural_earth') AS n, a"
+            " WHERE n.subtype IN ('Range/Mts', 'Terrain area', 'Peninsula', 'Depression')"
+            "   AND ST_Intersects(a.geometry, n.geometry)"
+        ),
+        question_hints=[
+            "What mountain ranges are in {anchor_name}?",
+            "Terrain features of {anchor_name}",
+            "Which mountain ranges cross {anchor_name}?",
+            "Landforms inside {anchor_name}",
+            "Peninsulas and ranges in {anchor_name}",
+            "Geographic features within {anchor_name}",
+            "Mountains of {anchor_name}",
+            "What terrain does {anchor_name} contain?",
+        ],
+    ),
+
+    # ── NATURAL EARTH INTERSECTION ──────────────────────────────────────────
+    # intersect_03: NE anchor, finding overlapping regions (vs countries in
+    # intersect_02). Uses cross_source_relations handler.
+    # intersect_04: division anchor, finding NE features that overlap it.
+    # Uses intersection_pairs handler (extra NE subtypes ignored in SQL).
+
+    SQLTemplate(
+        template_id="intersect_03",
+        family="intersection",
+        sql_difficulty="medium-hard",
+        anchor_source="natural_earth",
+        num_anchors=1,
+        target_subtype="region",
+        sql_template=(
+            "WITH a AS ("
+            "  SELECT geometry FROM read_parquet('natural_earth') WHERE id = '{anchor_id}'"
+            ")"
+            " SELECT b.id, b.names.\"primary\" AS name, b.subtype, b.country,"
+            "        ST_AsGeoJSON(b.geometry) AS geometry"
+            " FROM read_parquet('divisions_area') AS b, a"
+            " WHERE b.subtype = '{target_subtype}'"
+            "   AND ST_Intersects(b.geometry, a.geometry)"
+        ),
+        question_hints=[
+            "Which regions does the {anchor_name} pass through?",
+            "What administrative regions overlap with the {anchor_name}?",
+            "Regions that the {anchor_name} crosses",
+            "Administrative areas intersected by the {anchor_name}",
+            "What provinces does the {anchor_name} span?",
+            "Regions along the {anchor_name}",
+            "Which provinces overlap the {anchor_name}?",
+        ],
+    ),
+
+    SQLTemplate(
+        template_id="intersect_04",
+        family="intersection",
+        sql_difficulty="medium-hard",
+        anchor_source="divisions_area",
+        num_anchors=1,
+        target_subtype="region",
+        sql_template=(
+            "WITH a AS ("
+            "  SELECT geometry FROM read_parquet('divisions_area') WHERE id = '{anchor_id}'"
+            ")"
+            " SELECT n.id, n.names.\"primary\" AS name, n.subtype,"
+            "        ST_AsGeoJSON(n.geometry) AS geometry"
+            " FROM read_parquet('natural_earth') AS n, a"
+            " WHERE ST_Intersects(n.geometry, a.geometry)"
+        ),
+        question_hints=[
+            "What natural features intersect {anchor_name}?",
+            "Natural earth features that overlap {anchor_name}",
+            "Which geographic features cross {anchor_name}?",
+            "Everything from natural earth that touches {anchor_name}",
+            "What geographic features does {anchor_name} contain?",
+            "Natural features within or crossing {anchor_name}",
+        ],
+    ),
+
+    # ── NATURAL EARTH CHAINED ───────────────────────────────────────────────
+    # chained_04: localities in a region that intersect a river or lake.
+    # chained_05: localities in a region that lie on a mountain range.
+
+    SQLTemplate(
+        template_id="chained_04",
+        family="chained",
+        sql_difficulty="hard",
+        anchor_source="divisions_area",
+        num_anchors=1,
+        target_subtype="locality",
+        sql_template=(
+            "WITH region AS ("
+            "  SELECT geometry FROM read_parquet('divisions_area') WHERE id = '{anchor_id}'"
+            ")"
+            " SELECT b.id, b.names.\"primary\" AS name, b.subtype, b.country,"
+            "        ST_AsGeoJSON(b.geometry) AS geometry"
+            " FROM read_parquet('divisions_area') AS b, region"
+            " WHERE b.subtype = '{target_subtype}'"
+            "   AND ST_Within(b.geometry, region.geometry)"
+            "   AND EXISTS ("
+            "     SELECT 1 FROM read_parquet('natural_earth') AS n"
+            "     WHERE n.subtype IN ('River', 'Lake', 'Basin')"
+            "       AND ST_Intersects(b.geometry, n.geometry)"
+            "   )"
+        ),
+        question_hints=[
+            "Riverside {target_subtype}s in {anchor_name}",
+            "{target_subtype}s in {anchor_name} near a river or lake",
+            "Which {target_subtype}s in {anchor_name} are on a waterway?",
+            "Lakeside or riverside {target_subtype}s within {anchor_name}",
+            "{target_subtype}s in {anchor_name} that touch a river",
+            "Which {target_subtype}s in {anchor_name} are on a lake?",
+            "Waterfront {target_subtype}s of {anchor_name}",
+        ],
+    ),
+
+    SQLTemplate(
+        template_id="chained_05",
+        family="chained",
+        sql_difficulty="hard",
+        anchor_source="divisions_area",
+        num_anchors=1,
+        target_subtype="locality",
+        sql_template=(
+            "WITH region AS ("
+            "  SELECT geometry FROM read_parquet('divisions_area') WHERE id = '{anchor_id}'"
+            ")"
+            " SELECT b.id, b.names.\"primary\" AS name, b.subtype, b.country,"
+            "        ST_AsGeoJSON(b.geometry) AS geometry"
+            " FROM read_parquet('divisions_area') AS b, region"
+            " WHERE b.subtype = '{target_subtype}'"
+            "   AND ST_Within(b.geometry, region.geometry)"
+            "   AND EXISTS ("
+            "     SELECT 1 FROM read_parquet('natural_earth') AS n"
+            "     WHERE n.subtype IN ('Range/Mts', 'Depression')"
+            "       AND ST_Intersects(b.geometry, n.geometry)"
+            "   )"
+        ),
+        question_hints=[
+            "Mountain {target_subtype}s in {anchor_name}",
+            "{target_subtype}s in {anchor_name} on a mountain range",
+            "Which {target_subtype}s in {anchor_name} are in the mountains?",
+            "Highland {target_subtype}s within {anchor_name}",
+            "{target_subtype}s of {anchor_name} in mountainous terrain",
+            "{target_subtype}s in {anchor_name} near a mountain range",
+        ],
+    ),
+
+    # ── CHAINED (county-level) ──────────────────────────────────────────────
+    # Same spatial patterns as chained_01..05 but targeting counties/districts
+    # so the model learns "coastal districts of X", "riverside counties", etc.
+
+    SQLTemplate(
+        template_id="chained_06",
+        family="chained",
+        sql_difficulty="hard",
+        anchor_source="divisions_area",
+        num_anchors=1,
+        target_subtype="county",
+        sql_template=(
+            "WITH region AS ("
+            "  SELECT geometry FROM read_parquet('divisions_area') WHERE id = '{anchor_id}'"
+            ")"
+            " SELECT b.id, b.names.\"primary\" AS name, b.subtype, b.country,"
+            "        ST_AsGeoJSON(b.geometry) AS geometry"
+            " FROM read_parquet('divisions_area') AS b, region"
+            " WHERE b.subtype = '{target_subtype}'"
+            "   AND ST_Within(b.geometry, region.geometry)"
+            "   AND EXISTS ("
+            "     SELECT 1 FROM read_parquet('natural_earth') AS n"
+            "     WHERE n.subtype IN ('ocean', 'sea')"
+            "       AND ST_Intersects(b.geometry, n.geometry)"
+            "   )"
+        ),
+        question_hints=[
+            "Coastal {target_subtype}s of {anchor_name}",
+            "Which districts of {anchor_name} are on the coast?",
+            "{target_subtype}s in {anchor_name} that border the sea",
+            "Seaside {target_subtype}s within {anchor_name}",
+            "{target_subtype}s of {anchor_name} with ocean access",
+            "Which {target_subtype}s in {anchor_name} touch the sea?",
+            "Maritime {target_subtype}s of {anchor_name}",
+        ],
+    ),
+
+    SQLTemplate(
+        template_id="chained_07",
+        family="chained",
+        sql_difficulty="hard",
+        anchor_source="divisions_area",
+        num_anchors=1,
+        target_subtype="county",
+        sql_template=(
+            "WITH region AS ("
+            "  SELECT geometry FROM read_parquet('divisions_area') WHERE id = '{anchor_id}'"
+            ")"
+            " SELECT b.id, b.names.\"primary\" AS name, b.subtype, b.country,"
+            "        ST_AsGeoJSON(b.geometry) AS geometry"
+            " FROM read_parquet('divisions_area') AS b, region"
+            " WHERE b.subtype = '{target_subtype}'"
+            "   AND ST_Within(b.geometry, region.geometry)"
+            "   AND NOT EXISTS ("
+            "     SELECT 1 FROM read_parquet('natural_earth') AS n"
+            "     WHERE n.subtype IN ('ocean', 'sea')"
+            "       AND ST_Intersects(b.geometry, n.geometry)"
+            "   )"
+        ),
+        question_hints=[
+            "Landlocked {target_subtype}s of {anchor_name}",
+            "Which districts of {anchor_name} have no coastline?",
+            "Interior {target_subtype}s within {anchor_name}",
+            "{target_subtype}s in {anchor_name} with no sea access",
+            "Non-coastal {target_subtype}s of {anchor_name}",
+            "Inland {target_subtype}s of {anchor_name}",
+        ],
+    ),
+
+    SQLTemplate(
+        template_id="chained_08",
+        family="chained",
+        sql_difficulty="hard",
+        anchor_source="divisions_area",
+        num_anchors=1,
+        target_subtype="county",
+        sql_template=(
+            "WITH region AS ("
+            "  SELECT geometry FROM read_parquet('divisions_area') WHERE id = '{anchor_id}'"
+            ")"
+            " SELECT b.id, b.names.\"primary\" AS name, b.subtype, b.country,"
+            "        ST_AsGeoJSON(b.geometry) AS geometry"
+            " FROM read_parquet('divisions_area') AS b, region"
+            " WHERE b.subtype = '{target_subtype}'"
+            "   AND ST_Within(b.geometry, region.geometry)"
+            "   AND EXISTS ("
+            "     SELECT 1 FROM read_parquet('natural_earth') AS n"
+            "     WHERE n.subtype IN ('River', 'Lake', 'Basin')"
+            "       AND ST_Intersects(b.geometry, n.geometry)"
+            "   )"
+        ),
+        question_hints=[
+            "Riverside {target_subtype}s of {anchor_name}",
+            "Which districts of {anchor_name} have a river or lake?",
+            "{target_subtype}s in {anchor_name} on a waterway",
+            "Lakeside {target_subtype}s within {anchor_name}",
+            "{target_subtype}s of {anchor_name} along a river",
+            "Which {target_subtype}s in {anchor_name} border a lake?",
+        ],
+    ),
+
+    SQLTemplate(
+        template_id="chained_09",
+        family="chained",
+        sql_difficulty="hard",
+        anchor_source="divisions_area",
+        num_anchors=1,
+        target_subtype="county",
+        sql_template=(
+            "WITH region AS ("
+            "  SELECT geometry FROM read_parquet('divisions_area') WHERE id = '{anchor_id}'"
+            ")"
+            " SELECT b.id, b.names.\"primary\" AS name, b.subtype, b.country,"
+            "        ST_AsGeoJSON(b.geometry) AS geometry"
+            " FROM read_parquet('divisions_area') AS b, region"
+            " WHERE b.subtype = '{target_subtype}'"
+            "   AND ST_Within(b.geometry, region.geometry)"
+            "   AND EXISTS ("
+            "     SELECT 1 FROM read_parquet('natural_earth') AS n"
+            "     WHERE n.subtype IN ('Range/Mts', 'Depression')"
+            "       AND ST_Intersects(b.geometry, n.geometry)"
+            "   )"
+        ),
+        question_hints=[
+            "Mountain {target_subtype}s of {anchor_name}",
+            "Which districts of {anchor_name} are in the mountains?",
+            "{target_subtype}s in {anchor_name} on a mountain range",
+            "Highland {target_subtype}s within {anchor_name}",
+            "{target_subtype}s of {anchor_name} in mountainous terrain",
+            "Which {target_subtype}s in {anchor_name} have mountain ranges?",
+        ],
+    ),
+
+    # ── NATURAL EARTH CONTAINMENT ───────────────────────────────────────────
+    # contain_04: NE anchor (sea/gulf/bay), find countries that touch it.
+    # Uses containment handler via containment_pairs.
+
+    SQLTemplate(
+        template_id="contain_04",
+        family="containment",
+        sql_difficulty="medium",
+        anchor_source="natural_earth",
+        num_anchors=1,
+        target_subtype="country",
+        sql_template=(
+            "WITH a AS ("
+            "  SELECT geometry FROM read_parquet('natural_earth') WHERE id = '{anchor_id}'"
+            ")"
+            " SELECT b.id, b.names.\"primary\" AS name, b.subtype,"
+            "        ST_AsGeoJSON(b.geometry) AS geometry"
+            " FROM read_parquet('divisions_area') AS b, a"
+            " WHERE b.subtype = '{target_subtype}'"
+            "   AND ST_Intersects(b.geometry, a.geometry)"
+        ),
+        question_hints=[
+            "Which countries border the {anchor_name}?",
+            "What countries are along the {anchor_name}?",
+            "Countries surrounding the {anchor_name}",
+            "Nations on the {anchor_name}",
+            "Which countries touch the {anchor_name}?",
+            "Countries with coastline on the {anchor_name}",
+            "What nations lie on the {anchor_name}?",
+        ],
+    ),
+
+    # ── NATURAL EARTH BUFFER ────────────────────────────────────────────────
+    # buffer_05: NE anchor, find other NE features within a buffer distance.
+    # Uses buffer handler for natural_earth.
+
+    SQLTemplate(
+        template_id="buffer_05",
+        family="buffer",
+        sql_difficulty="hard",
+        anchor_source="natural_earth",
+        num_anchors=1,
+        requires_buffer=True,
+        sql_template=(
+            "WITH a AS ("
+            "  SELECT ST_Buffer(geometry, {buffer_km} * 1000.0 / 111320.0) AS geom"
+            "  FROM read_parquet('natural_earth')"
+            "  WHERE id = '{anchor_id}'"
+            ")"
+            " SELECT n.id, n.names.\"primary\" AS name, n.subtype,"
+            "        ST_AsGeoJSON(n.geometry) AS geometry"
+            " FROM read_parquet('natural_earth') AS n, a"
+            " WHERE ST_Intersects(n.geometry, a.geom)"
+        ),
+        question_hints=[
+            "Natural features within {buffer_km} km of the {anchor_name}",
+            "What is within {buffer_km} km of the {anchor_name}?",
+            "Geographic features near the {anchor_name} within {buffer_km} km",
+            "Everything within {buffer_km} km of the {anchor_name}",
+            "What natural features are close to the {anchor_name}?",
+            "{buffer_km} km radius around the {anchor_name}",
+        ],
+    ),
+
 ]