Lowercase subtype names, fix question type hints

IMPROVEMENTS.md

@@ -0,0 +1,79 @@
+# Gazet Improvement Notes
+
+Issues identified during testing. Each item is a candidate for the next training/template pass.
+
+---
+
+## 1. Missing "buffer-only" template
+
+**Query**: "10 km buffer around Odisha"
+**Expected**: Return the buffered geometry polygon itself.
+**Actual**: Model picks `buffer_01`, which finds all features intersecting the buffer (200 rows).
+
+**Root cause**: All buffer templates (`buffer_01` through `buffer_05`) perform an intersection join to find neighboring features. No template simply returns `ST_AsGeoJSON(ST_Buffer(...))`.
+
+**Fix**: Add a `buffer_06` template that returns the buffer polygon directly:
+
+```sql
+SELECT ST_AsGeoJSON(ST_Buffer(geometry, {buffer_km} * 1000.0 / 111320.0)) AS geometry
+FROM read_parquet('divisions_area')
+WHERE id = '{anchor_id}'
+```
+
+With hints like "10 km buffer around {anchor_name}", "draw a {buffer_km} km buffer around {anchor_name}". Consider a NE variant too.
+
+---
+
+## 2. Place extractor misses NE physical features (mixed-source queries)
+
+**Query**: "The part of Ecuador that is in the Amazon Basin"
+**Expected**: Place extractor returns both "Ecuador" and "Amazon Basin"; candidate search finds correct IDs for both.
+**Actual**: Only "Ecuador" extracted. SQL model uses memorized wrong NE ID (`ne_1159120655` = Cuando River) instead of the correct one (`ne_1159104325` = AMAZON BASIN).
+
+**Root cause**: The GGUF place extraction model was not trained to extract physical features. The runtime prompt (`_PLACES_SYSTEM_PROMPT`) has been updated but the finetuned model may ignore prompt changes. A re-finetune with NE feature examples is the definitive fix.
+
+**Affected templates**: `partial_05`, `diff_02` (mixed-source), and all NE-anchored templates (`intersect_03`, `contain_03/04`, `buffer_03/04/05`, `lookup_02`).
+
+---
+
+## 3. Missing NE-anchor to county intersection template
+
+**Query**: "Indravati River flows through which districts"
+**Expected**: `ST_Intersects` with `target_subtype='county'`
+**Actual**: Model sometimes uses `ST_Within` (wrong predicate) because `intersect_03` only targets `region`, not `county`.
+
+**Fix**: Add `intersect_05` (NE anchor -> county, `ST_Intersects`) with district-oriented question hints.
+
+---
+
+## 4. Model hallucinates NE subtype values
+
+**Query**: "which mountain ranges cross Odisha"
+**Expected**: `n.subtype IN ('range/mtn', 'peninsula', 'depression')` (from `adj_05`)
+**Actual**: Model generates `'Terrain area'` which does not exist in the data.
+
+**Fix**: More training examples for `adj_05`. Consider adding common hallucinated values to `_NE_SUBTYPE_FIXES` in `sql.py` as a runtime safety net.
+
+---
+
+## 5. NE subtype casing inconsistency between model output and data
+
+**Example**: Model generates `'River'`, `'Basin'`, `'Ocean'` but data has `'river'`, `'basin'`, `'ocean'`.
+
+**Current workaround**: `_normalize_ne_subtypes()` in `sql.py` does string replacement of known title-cased literals at query time (`_NE_SUBTYPE_FIXES` dict). This is brittle and only covers a hardcoded list.
+
+**Root cause**: The original Natural Earth data had title-cased `featurecla` values (e.g. `River`, `Basin`, `Ocean`). Training data was generated before the lowercase fix to `convert_natural_earth.py`, so the model learned to emit title-cased subtypes. The data is now lowercased but the model still outputs the old casing.
+
+**Fix**: Regenerate training data with the lowercased NE parquet so all subtype literals in SQL examples are lowercase. After re-finetune, the model will natively emit lowercase subtypes and the `_normalize_ne_subtypes` hack can be removed.
+
+---
+
+## 6. "Largest/smallest" queries always return at least 3 results
+
+**Query**: "the largest region in India", "smallest county in France"
+**Expected**: Return 1 result (the single largest/smallest).
+**Actual**: Model generates `LIMIT 3` by default, returning top 3 instead of 1.
+
+**Root cause**: The aggregation templates (`agg_01`, `agg_02`) use `LIMIT 3` as the default. The model learns this as a fixed pattern and applies it even when the query clearly asks for a single result ("the largest", "the smallest").
+
+**Fix**: During data generation, vary the LIMIT value based on the question hint phrasing. Use `LIMIT 1` for singular hints ("the largest X", "the smallest X") and `LIMIT 3` or `LIMIT 5` for plural hints ("the 3 largest", "top 5 smallest"). This teaches the model to infer the correct LIMIT from the query.

dataset/config.yaml

@@ -19,11 +19,11 @@ countries:
 sample_targets:
   direct_lookup:      1000
   disambiguation:     2000   # 3 templates (disambiguate_01..03) - "Puri, Odisha" pattern
-  adjacency:          2000   # 6 templates (adj_01..06) - adj_06 is counties
+  adjacency:          2000   # 8 templates (adj_01..08) - adj_05/07/08 cover terrain queries, adj_06 is counties
   multi_adjacency:    1000
   containment:        2000   # 4 templates (contain_01..04) - contain_02 reversed, contain_03/04 NE anchor
-  intersection:       2000   # 4 templates (intersect_01..04) - intersect_02/03 NE anchor
-  buffer:             2000   # 5 templates (buffer_01..05)
+  intersection:       2000   # 5 templates (intersect_01..05) - intersect_02/03/05 include NE anchor patterns
+  buffer:             2000   # 6 templates (buffer_01..06)
   chained:            2000   # 11 templates (chained_01..11) - 10/11 are coastal/inland regions
   difference:         2000   # 2 templates, one is mixed (diff_02)
   border_corridor:    1000

dataset/scripts/build_relations.py

@@ -52,16 +52,19 @@ _CONTAINMENT_SUBTYPE_PAIRS = (
 _NE_CROSS_SOURCE_SUBTYPES = (
     "sea",
     "ocean",
-    "Lake",
-    "River",
-    "Basin",
+    "lake",
+    "river",
+    "basin",
     "gulf",
     "bay",
-    "Island group",
-    "Peninsula",
     "strait",
-    "Range/mtn",
-    "Depression",
+    "range/mtn",
+    "plateau",
+    "plain",
+    "lowland",
+    "valley",
+    "depression",
+    "gorge",
 )
 
 

dataset/scripts/export_training_data.py

@@ -7,8 +7,8 @@ Produces two task datasets from the same source samples:
 2. Place extraction (prompt = question only, completion = PlacesResult JSON)
 
 Place extraction pairs are derived automatically: for each SQL sample the
-selected_candidates give us the correct place names, subtypes, and country
-codes that the extractor should return.
+selected_candidates give us the correct place names that the extractor should
+return.
 
 Output layout (all paths relative to dataset/):
     output/runs/{run_name}/sql/train.jsonl
@@ -124,7 +124,7 @@ You have access to two DuckDB parquet tables. Given a set of candidate entities
      id VARCHAR              -- unique feature id prefixed 'ne_'
      names STRUCT("primary" VARCHAR, ...)
      country VARCHAR
-     subtype VARCHAR         -- e.g. 'ocean', 'sea', 'bay', 'Range/mtn', 'Island group'
+     subtype VARCHAR         -- e.g. 'ocean', 'sea', 'bay', 'range/mtn', 'island group'
      class VARCHAR
      region VARCHAR
      admin_level INTEGER
@@ -139,7 +139,7 @@ Use ST_AsGeoJSON(geometry) for all geometry outputs."""
 
 _CANDIDATES_COLS = [
     "source", "id", "name", "subtype", "country", "region",
-    "admin_level", "similarity",
+    "admin_level",
 ]
 
 
@@ -209,87 +209,74 @@ def sample_to_sql_pair(sample: Dict[str, Any]) -> Optional[Dict]:
 _PLACE_SYSTEM = """You are a geographic entity extractor. Extract the place names the user is asking about and return valid JSON only.
 
 OUTPUT FORMAT:
-{"places": [{"place": "<name>", "country": "<ISO-2>", "subtype": "<subtype>"}]}
-"country" and "subtype" are optional; omit if not applicable.
+{"places": [{"place": "<name>"}]}
 
 RULES:
-- Extract the place(s) that are the target of the query.
-- When a place is followed by its containing region, state, or country as disambiguation context ("Puri, Odisha", "Lisboa, Portugal", "Goa, India", "Manchester in US"), extract ONLY the specific place. Do not return the container as a separate place — record its info on the target using `country` (ISO-2) when unambiguous.
-- When a query names two or more distinct anchors joined by words like "and", "both", "between", "or" ("France and Germany", "between Nairobi and Mombasa"), or mixes an admin area with a physical feature as independent anchors ("part of Ecuador in the Amazon basin"), extract every anchor in the order they appear.
-- Do not infer or expand category nouns like "regions", "districts", "counties", "rivers", "mountains" when they refer to a type rather than a specific place ("regions of India" -> extract "India" only).
+- Extract the place or places that are the actual anchors of the query.
+- Physical features are valid places: oceans, seas, gulfs, bays, straits, rivers, lakes, basins, mountain ranges, peninsulas, island groups, deserts, and terrain regions.
+- When a place is followed by its containing region, state, or country as disambiguation context ("Puri, Odisha", "Lisboa, Portugal", "Goa, India", "Manchester in US"), extract ONLY the specific place. Do not return the container as a separate place.
+- When a query names two or more distinct anchors joined by words like "and", "both", "between", or mixes an admin area with a physical feature as separate anchors, extract every anchor in the order they appear.
+- Do not infer or expand category nouns like "regions", "districts", "counties", "rivers", or "mountains" when they refer to a type rather than a specific named place ("regions of India" -> extract "India" only).
+- Only extract places explicitly mentioned.
 - No duplicate place names.
-- "country": ISO 3166-1 alpha-2. Include only if explicitly mentioned or unambiguous.
-- "subtype": include only when the geographic level is clear from the query.
-
-SUBTYPES:
-country, dependency, region, county, localadmin, locality, macrohood, neighborhood, microhood
-- Default to locality for cities/towns; omit for physical features (oceans, seas, rivers, lakes, basins, mountains, ranges, peninsulas, islands, terrain areas).
 
 EXAMPLES:
 Query: "Puri, Odisha"
--> {"places": [{"place": "Puri", "subtype": "locality", "country": "IN"}]}
+-> {"places": [{"place": "Puri"}]}
 
 Query: "Lisboa, Portugal"
--> {"places": [{"place": "Lisboa", "subtype": "locality", "country": "PT"}]}
+-> {"places": [{"place": "Lisboa"}]}
 
 Query: "Goa, India"
--> {"places": [{"place": "Goa", "subtype": "region", "country": "IN"}]}
+-> {"places": [{"place": "Goa"}]}
 
 Query: "Manchester in US"
--> {"places": [{"place": "Manchester", "subtype": "locality", "country": "US"}]}
+-> {"places": [{"place": "Manchester"}]}
 
 Query: "Springfield, Illinois"
--> {"places": [{"place": "Springfield", "subtype": "locality", "country": "US"}]}
+-> {"places": [{"place": "Springfield"}]}
 
 Query: "coastal districts of Brazil"
--> {"places": [{"place": "Brazil", "subtype": "country"}]}
+-> {"places": [{"place": "Brazil"}]}
 
 Query: "northern half of India"
--> {"places": [{"place": "India", "subtype": "country"}]}
+-> {"places": [{"place": "India"}]}
 
 Query: "what's within 50 km of Paris?"
--> {"places": [{"place": "Paris", "subtype": "locality"}]}
+-> {"places": [{"place": "Paris"}]}
 
 Query: "countries the Nile crosses"
 -> {"places": [{"place": "Nile"}]}
 
+Query: "which countries touch the Gulf of Maine"
+-> {"places": [{"place": "Gulf of Maine"}]}
+
+Query: "10 km buffer around Odisha"
+-> {"places": [{"place": "Odisha"}]}
+
 Query: "part of Ecuador in the Amazon basin"
--> {"places": [{"place": "Ecuador", "subtype": "country"}, {"place": "Amazon basin"}]}
+-> {"places": [{"place": "Ecuador"}, {"place": "Amazon basin"}]}
 
 Query: "Amazon basin inside Ecuador"
--> {"places": [{"place": "Amazon basin"}, {"place": "Ecuador", "subtype": "country"}]}
+-> {"places": [{"place": "Amazon basin"}, {"place": "Ecuador"}]}
+
+Query: "the part of Chad in Lake Chad"
+-> {"places": [{"place": "Chad"}, {"place": "Lake Chad"}]}
 
 Query: "which regions border both France and Germany?"
--> {"places": [{"place": "France", "subtype": "country"}, {"place": "Germany", "subtype": "country"}]}
+-> {"places": [{"place": "France"}, {"place": "Germany"}]}
 
 Query: "merge Nairobi and Mombasa"
--> {"places": [{"place": "Nairobi", "subtype": "locality"}, {"place": "Mombasa", "subtype": "locality"}]}"""
-
-# Overture division subtypes — used to filter out natural_earth candidates
-# from the place extraction output (NE features don't have these subtypes).
-_DIVISION_SUBTYPES = {
-    "country", "region", "dependency", "county", "localadmin",
-    "locality", "macrohood", "neighborhood", "microhood",
-}
+-> {"places": [{"place": "Nairobi"}, {"place": "Mombasa"}]}"""
 
 
 def _candidate_to_place(c: Dict) -> Optional[Dict]:
-    """Convert a selected candidate to a Place dict for PlacesResult."""
+    """Convert a selected candidate to a minimal Place dict for PlacesResult."""
     name = c.get("name", "").strip()
     if not name:
         return None
 
-    place: Dict[str, Any] = {"place": name}
-
-    subtype = c.get("subtype", "")
-    if subtype in _DIVISION_SUBTYPES:
-        place["subtype"] = subtype
-
-    country = c.get("country", "")
-    if country and len(country) == 2:
-        place["country"] = country
-
-    return place
+    return {"place": name}
 
 
 def sample_to_place_pair(sample: Dict[str, Any]) -> Optional[Dict]:

dataset/scripts/generate_samples.py

@@ -61,29 +61,30 @@ get_templates_by_family = sql_templates.get_templates_by_family
 
 
 _NE_NAMED_LOOKUP_SUBTYPES = {
-    'sea', 'ocean', 'Lake', 'River', 'Basin', 'gulf', 'bay',
-    'Island group', 'Peninsula', 'strait', 'Range/mtn', 'Depression',
+    'sea', 'ocean', 'lake', 'river', 'basin', 'gulf', 'bay',
+    'island group', 'peninsula', 'strait', 'range/mtn', 'depression',
 }
 
 _NE_TEMPLATE_SUBTYPES = {
-    'lookup_02': {'sea', 'ocean', 'Lake', 'River', 'Basin', 'gulf', 'bay', 'Island group', 'Peninsula', 'strait', 'Range/mtn', 'Depression'},
+    'lookup_02': {'sea', 'ocean', 'lake', 'river', 'basin', 'gulf', 'bay', 'island group', 'peninsula', 'strait', 'range/mtn', 'depression'},
     'adj_03': {'sea', 'ocean'},
-    'adj_04': {'River', 'Lake', 'Basin'},
-    'adj_05': {'Range/mtn', 'Peninsula', 'Depression'},
-    'contain_03': {'sea', 'ocean', 'gulf', 'bay', 'Basin', 'Island group', 'Peninsula', 'Range/mtn', 'Depression'},
+    'adj_04': {'river', 'lake', 'basin'},
+    'adj_05': {'range/mtn', 'peninsula', 'depression'},
+    'contain_03': {'sea', 'ocean', 'gulf', 'bay', 'basin', 'island group', 'peninsula', 'range/mtn', 'depression'},
     'contain_04': {'sea', 'ocean', 'gulf', 'bay', 'strait'},
-    'intersect_02': {'River', 'Lake', 'Basin', 'gulf', 'bay', 'strait', 'Range/mtn', 'Peninsula', 'Depression'},
-    'intersect_03': {'River', 'Lake', 'Basin', 'gulf', 'bay', 'strait', 'Range/mtn', 'Peninsula', 'Depression'},
-    'buffer_03': {'sea', 'ocean', 'Lake', 'River', 'Basin', 'gulf', 'bay', 'Island group', 'Peninsula', 'strait', 'Range/mtn', 'Depression'},
-    'buffer_04': {'sea', 'ocean', 'Lake', 'River', 'Basin', 'gulf', 'bay', 'Island group', 'Peninsula', 'strait', 'Range/mtn', 'Depression'},
-    'buffer_05': {'sea', 'ocean', 'Lake', 'River', 'Basin', 'gulf', 'bay', 'Island group', 'Peninsula', 'strait', 'Range/mtn', 'Depression'},
-    'chained_03': {'Island group', 'Peninsula', 'Range/mtn', 'Depression'},
-    'chained_04': {'River', 'Lake', 'Basin'},
-    'chained_05': {'Range/mtn', 'Depression'},
-    'chained_08': {'River', 'Lake', 'Basin'},
-    'chained_09': {'Range/mtn', 'Depression'},
-    'partial_05': {'sea', 'ocean', 'Lake', 'River', 'Basin', 'gulf', 'bay', 'Island group', 'Peninsula', 'strait', 'Range/mtn', 'Depression'},
-    'diff_02': {'sea', 'ocean', 'Lake', 'River', 'Basin', 'gulf', 'bay', 'Island group', 'Peninsula', 'strait', 'Range/mtn', 'Depression'},
+    'intersect_02': {'river', 'lake', 'basin', 'gulf', 'bay', 'strait', 'range/mtn', 'peninsula', 'depression'},
+    'intersect_03': {'river', 'lake', 'basin', 'gulf', 'bay', 'strait', 'range/mtn', 'peninsula', 'depression'},
+    'intersect_05': {'river', 'lake', 'basin', 'gulf', 'bay', 'strait', 'range/mtn', 'peninsula', 'depression'},
+    'buffer_03': {'sea', 'ocean', 'lake', 'river', 'basin', 'gulf', 'bay', 'island group', 'peninsula', 'strait', 'range/mtn', 'depression'},
+    'buffer_04': {'sea', 'ocean', 'lake', 'river', 'basin', 'gulf', 'bay', 'island group', 'peninsula', 'strait', 'range/mtn', 'depression'},
+    'buffer_05': {'sea', 'ocean', 'lake', 'river', 'basin', 'gulf', 'bay', 'island group', 'peninsula', 'strait', 'range/mtn', 'depression'},
+    'chained_03': {'island group', 'peninsula', 'range/mtn', 'depression'},
+    'chained_04': {'river', 'lake', 'basin'},
+    'chained_05': {'range/mtn', 'depression'},
+    'chained_08': {'river', 'lake', 'basin'},
+    'chained_09': {'range/mtn', 'depression'},
+    'partial_05': {'sea', 'ocean', 'lake', 'river', 'basin', 'gulf', 'bay', 'island group', 'peninsula', 'strait', 'range/mtn', 'depression'},
+    'diff_02': {'sea', 'ocean', 'lake', 'river', 'basin', 'gulf', 'bay', 'island group', 'peninsula', 'strait', 'range/mtn', 'depression'},
 }
 
 
@@ -722,14 +723,17 @@ def generate_template_based_sample(
         anchor = {"id": pair["contained_id"], "name": pair["contained_name"]}
 
     elif template.family == "adjacency":
-        # adj_03/04/05 target natural_earth features (seas, rivers, ranges).
+        # adj_03/04/05/07/08 target natural_earth features (marine, water,
+        # mountain, plateau, and broad landform regions).
         # Their SQL hardcodes NE subtypes and does not use {target_subtype}.
         # Sample from cross_source_relations so the anchor is a division
         # that actually intersects the right NE features.
         _NE_ADJ_SUBTYPES = {
             "adj_03": ("ocean", "sea"),
-            "adj_04": ("River", "Lake", "Basin"),
-            "adj_05": ("Range/mtn", "Peninsula", "Depression"),
+            "adj_04": ("river", "lake", "basin"),
+            "adj_05": ("range/mtn",),
+            "adj_07": ("plateau",),
+            "adj_08": ("plain", "lowland", "basin", "valley", "depression", "gorge"),
         }
         if template.template_id in _NE_ADJ_SUBTYPES:
             cs_df = tables.get('cross_source_relations', pd.DataFrame())
@@ -1019,8 +1023,10 @@ def generate_template_based_sample(
     
     elif template.family == "buffer":
         # Buffer operations
-        # Kilometre distances used by buffer_01 and buffer_03 templates.
-        # Metre distances used by buffer_02 and buffer_04 templates.
+        # Kilometre distances used by km-based buffer templates (for example
+        # buffer_01, buffer_03, buffer_05, and buffer_06).
+        # Metre distances used by metre-based buffer templates (buffer_02 and
+        # buffer_04).
         # The template SQL divides by 111 320 to convert to degrees.
         _buffer_km_choices = [1, 2, 5, 10, 25, 50, 100, 200]
         _buffer_m_choices = [100, 250, 500, 1000, 2000, 5000]
@@ -1166,8 +1172,13 @@ def generate_template_based_sample(
             candidates = _merge_candidate_lists(div_cands, ne_cands, max_total=10)
     
     elif template.family == "aggregation":
-        top_n = random.choice([3, 5, 10])
+        # Teach the model to distinguish singular superlatives ("the largest")
+        # from explicit top-N requests ("top 5 largest").
+        top_n = random.choice([1, 3, 5, 10])
         target_subtype = random.choice(['locality', 'region'])
+        singular_hints = [h for h in template.question_hints if '{top_n}' not in h]
+        plural_hints = [h for h in template.question_hints if '{top_n}' in h]
+        question_hint_pool = singular_hints if top_n == 1 and singular_hints else plural_hints or template.question_hints
 
         if template.template_id in ['agg_03', 'agg_04']:
             # Country-level aggregation: SQL uses country code, so the anchor
@@ -1194,7 +1205,7 @@ def generate_template_based_sample(
                 num_candidates=10, difficulty="hard"
             )
 
-            question = random.choice(template.question_hints).format(
+            question = random.choice(question_hint_pool).format(
                 top_n=top_n,
                 target_subtype=target_subtype,
                 anchor_name=anchor['name'],
@@ -1216,7 +1227,7 @@ def generate_template_based_sample(
                 num_candidates=10, difficulty="hard"
             )
 
-            question = random.choice(template.question_hints).format(
+            question = random.choice(question_hint_pool).format(
                 top_n=top_n,
                 target_subtype=target_subtype,
                 anchor_name=anchor['container_name'],

dataset/scripts/sql_templates.py

@@ -125,6 +125,10 @@ TEMPLATES = [
             "map the {anchor_name}",
             "how big is the {anchor_name}?",
             "outline of the {anchor_name}",
+            "show the shape of the {anchor_name}",
+            "trace the {anchor_name}",
+            "map out the {anchor_name}",
+            "where exactly is the {anchor_name}",
         ],
     ),
 
@@ -163,6 +167,10 @@ TEMPLATES = [
             "{anchor_name} {container_name}",
             "pull up {anchor_name} in {container_name}",
             "find {anchor_name} in {container_name}",
+            "locate {anchor_name} in {container_name}",
+            "need {anchor_name} from {container_name}",
+            "show {anchor_name} under {container_name}",
+            "{anchor_name} near {container_name}",
         ],
     ),
 
@@ -189,6 +197,10 @@ TEMPLATES = [
             "pull up {anchor_name} ({container_name})",
             "find {anchor_name} in {container_name}",
             "{anchor_name} {container_name}",
+            "locate {anchor_name} in {container_name}",
+            "need the {anchor_name} in {container_name}",
+            "show {anchor_name} from {container_name}",
+            "bring up {anchor_name}, {container_name}",
         ],
     ),
 
@@ -215,6 +227,10 @@ TEMPLATES = [
             "{anchor_name} province of {container_name}",
             "pull up {anchor_name} in {container_name}",
             "find {anchor_name} {container_name}",
+            "locate {anchor_name} within {container_name}",
+            "show the {anchor_name} part of {container_name}",
+            "need {anchor_name} from {container_name}",
+            "bring up {anchor_name} in {container_name}",
         ],
     ),
 
@@ -246,6 +262,11 @@ TEMPLATES = [
             "what surrounds {anchor_name}?",
             "places next to {anchor_name}",
             "everything bordering {anchor_name}",
+            "show adjacent places to {anchor_name}",
+            "areas touching {anchor_name}",
+            "find the neighbours of {anchor_name}",
+            "bordering places for {anchor_name}",
+            "places that meet {anchor_name}",
         ],
     ),
 
@@ -275,6 +296,10 @@ TEMPLATES = [
             "which {target_subtype}s are adjacent to {anchor_name}?",
             "{target_subtype}s along the {anchor_name} border",
             "find {target_subtype}s next to {anchor_name}",
+            "show {target_subtype}s bordering {anchor_name}",
+            "{target_subtype}s beside {anchor_name}",
+            "all {target_subtype}s touching {anchor_name}",
+            "{target_subtype}s meeting {anchor_name}",
         ],
     ),
 
@@ -305,6 +330,11 @@ TEMPLATES = [
             "which water bodies does {anchor_name} border?",
             "does {anchor_name} have sea access?",
             "what ocean is {anchor_name} on?",
+            "is {anchor_name} on the coast?",
+            "what sea is off the coast of {anchor_name}?",
+            "which ocean lies off {anchor_name}?",
+            "what water is {anchor_name} on the shore of?",
+            "which sea or ocean is {anchor_name} along?",
         ],
     ),
 
@@ -368,6 +398,12 @@ TEMPLATES = [
             "regions adjacent to 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}",
+            "show places touching both {anchor_1_name} and {anchor_2_name}",
+            "areas bordering both {anchor_1_name} and {anchor_2_name}",
+            "shared neighbours of {anchor_1_name} and {anchor_2_name}",
+            "find places adjacent to both {anchor_1_name} and {anchor_2_name}",
+            "places meeting both {anchor_1_name} and {anchor_2_name}",
+            "places on the border of both {anchor_1_name} and {anchor_2_name}",
         ],
     ),
 
@@ -399,6 +435,13 @@ TEMPLATES = [
             "all {target_subtype}s within {anchor_name}",
             "{target_subtype}s of {anchor_name}",
             "show every {target_subtype} in {anchor_name}",
+            "show {target_subtype}s inside {anchor_name}",
+            "find {target_subtype}s in {anchor_name}",
+            "give me the {target_subtype}s in {anchor_name}",
+            "{anchor_name} {target_subtype}s",
+            "which {target_subtype}s does {anchor_name} contain?",
+            "what all {target_subtype}s are there in {anchor_name}?",
+            "{target_subtype}s under {anchor_name}",
         ],
     ),
 
@@ -428,6 +471,12 @@ TEMPLATES = [
             "{anchor_name} is part of which country?",
             "where is {anchor_name}",
             "what country is {anchor_name} in",
+            "{anchor_name} belongs to which country?",
+            "show country for {anchor_name}",
+            "find the country of {anchor_name}",
+            "which country does {anchor_name} fall in?",
+            "{anchor_name} under which country",
+            "tell me the country for {anchor_name}",
         ],
     ),
 
@@ -456,6 +505,14 @@ TEMPLATES = [
             "all regions inside the {anchor_name}",
             "what {target_subtype}s does the {anchor_name} contain?",
             "{target_subtype}s covered by the {anchor_name}",
+            "which regions are in the {anchor_name} basin?",
+            "what admin regions lie within the {anchor_name}?",
+            "which provinces are inside the {anchor_name}?",
+            "show the regions in the {anchor_name}",
+            "find provinces inside the {anchor_name}",
+            "give me admin regions within the {anchor_name}",
+            "regions belonging to the {anchor_name}",
+            "areas contained in the {anchor_name}",
         ],
     ),
 
@@ -486,6 +543,12 @@ TEMPLATES = [
             "which {target_subtype}s overlap {anchor_name}?",
             "{target_subtype}s partially inside {anchor_name}",
             "what {target_subtype}s extend into {anchor_name}?",
+            "show {target_subtype}s overlapping {anchor_name}",
+            "find {target_subtype}s crossing {anchor_name}",
+            "{target_subtype}s meeting {anchor_name}",
+            "areas intersecting {anchor_name}",
+            "{anchor_name} overlapping {target_subtype}s",
+            "which {target_subtype}s are partly in {anchor_name}?",
         ],
     ),
 
@@ -516,6 +579,10 @@ TEMPLATES = [
             "countries along the {anchor_name}",
             "what countries does the {anchor_name} cover?",
             "countries the {anchor_name} spans across",
+            "what countries is the {anchor_name} in?",
+            "which countries lie along the {anchor_name}?",
+            "what countries does the {anchor_name} run through?",
+            "which countries border the {anchor_name}?",
         ],
     ),
 
@@ -607,6 +674,15 @@ TEMPLATES = [
             "what falls within {buffer_km} km of the {anchor_name}?",
             "admin divisions within a {buffer_km} km radius of the {anchor_name}",
             "places within {buffer_km} kilometers of the {anchor_name}",
+            "what places are near the {anchor_name}?",
+            "what admin areas are close to the {anchor_name}?",
+            "which regions are around the {anchor_name}?",
+            "what lies within {buffer_km} km of the shoreline of the {anchor_name}?",
+            "show places around the {anchor_name}",
+            "find areas near the {anchor_name}",
+            "admin units close to the {anchor_name}",
+            "what is around the {anchor_name} within {buffer_km} km",
+            "give me nearby admin regions for the {anchor_name}",
         ],
     ),
 
@@ -633,6 +709,40 @@ TEMPLATES = [
             "admin units within {buffer_m} m of the {anchor_name}",
             "places within {buffer_m} metres of the {anchor_name}",
             "{buffer_m} meter buffer around the {anchor_name}",
+            "what places are right next to the {anchor_name}?",
+            "what lies close to the {anchor_name}?",
+            "which admin units are near the edge of the {anchor_name}?",
+            "show places very near the {anchor_name}",
+            "find admin areas next to the {anchor_name}",
+            "what is just around the {anchor_name}",
+            "give me places within {buffer_m} m of the {anchor_name}",
+        ],
+    ),
+
+    SQLTemplate(
+        template_id="buffer_06",
+        family="buffer",
+        sql_difficulty="medium",
+        anchor_source="divisions_area",
+        num_anchors=1,
+        requires_buffer=True,
+        sql_template=(
+            "SELECT ST_AsGeoJSON(ST_Buffer(geometry, {buffer_km} * 1000.0 / 111320.0)) AS geometry"
+            " FROM read_parquet('divisions_area')"
+            " WHERE id = '{anchor_id}'"
+        ),
+        question_hints=[
+            "{buffer_km} km buffer around {anchor_name}",
+            "draw a {buffer_km} km buffer around {anchor_name}",
+            "show the {buffer_km} km buffer around {anchor_name}",
+            "create a {buffer_km} kilometer buffer around {anchor_name}",
+            "map a {buffer_km} km radius around {anchor_name}",
+            "outline the {buffer_km} km buffer around {anchor_name}",
+            "make a {buffer_km} km zone around {anchor_name}",
+            "generate a {buffer_km} km radius for {anchor_name}",
+            "buffer {anchor_name} by {buffer_km} km",
+            "show radius {buffer_km} km from {anchor_name}",
+            "{anchor_name} with a {buffer_km} km buffer",
         ],
     ),
 
@@ -670,6 +780,11 @@ TEMPLATES = [
             "{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?",
+            "show coastal {target_subtype}s in {anchor_name}",
+            "find {target_subtype}s of {anchor_name} on the shore",
+            "{target_subtype}s of {anchor_name} by the sea",
+            "which {target_subtype}s of {anchor_name} touch the ocean?",
+            "coastline {target_subtype}s in {anchor_name}",
         ],
     ),
 
@@ -702,6 +817,11 @@ TEMPLATES = [
             "{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",
+            "show inland {target_subtype}s in {anchor_name}",
+            "find non-coastal {target_subtype}s of {anchor_name}",
+            "{target_subtype}s of {anchor_name} away from the sea",
+            "which {target_subtype}s in {anchor_name} are not coastal?",
+            "inner {target_subtype}s of {anchor_name}",
         ],
     ),
 
@@ -723,7 +843,7 @@ TEMPLATES = [
             "   AND ST_Within(b.geometry, region.geometry)"
             "   AND EXISTS ("
             "     SELECT 1 FROM read_parquet('natural_earth') AS n"
-            "     WHERE n.subtype IN ('Range/mtn', 'Island group', 'Peninsula', 'Depression')"
+            "     WHERE n.subtype IN ('range/mtn', 'island group', 'peninsula', 'depression')"
             "       AND ST_Intersects(b.geometry, n.geometry)"
             "   )"
         ),
@@ -732,6 +852,10 @@ TEMPLATES = [
             "{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}",
+            "show {target_subtype}s in {anchor_name} on major landforms",
+            "find {target_subtype}s of {anchor_name} on islands or peninsulas",
+            "{target_subtype}s in {anchor_name} on terrain regions",
+            "places in {anchor_name} associated with islands or peninsulas",
         ],
     ),
 
@@ -764,6 +888,10 @@ TEMPLATES = [
             "{anchor_1_name} with {anchor_2_name} cut out",
             "subtract {anchor_2_name} from {anchor_1_name}",
             "what's left of {anchor_1_name} after removing {anchor_2_name}?",
+            "difference between {anchor_1_name} and {anchor_2_name}",
+            "keep only {anchor_1_name} outside {anchor_2_name}",
+            "cut {anchor_2_name} out of {anchor_1_name}",
+            "show {anchor_1_name} without {anchor_2_name}",
         ],
     ),
 
@@ -792,6 +920,10 @@ TEMPLATES = [
             "{anchor_name} with the {clip_feature_name} removed",
             "what's left of {anchor_name} after removing the {clip_feature_name}?",
             "show me {anchor_name} excluding the {clip_feature_name}",
+            "keep only the part of {anchor_name} outside the {clip_feature_name}",
+            "cut the {clip_feature_name} out of {anchor_name}",
+            "difference of {anchor_name} and the {clip_feature_name}",
+            "{anchor_name} after subtracting the {clip_feature_name}",
         ],
     ),
 
@@ -828,6 +960,11 @@ TEMPLATES = [
             "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",
+            "show the border zone between {anchor_1_name} and {anchor_2_name}",
+            "map the corridor along the {anchor_1_name}-{anchor_2_name} border",
+            "find the area near the border of {anchor_1_name} and {anchor_2_name}",
+            "give me the border buffer for {anchor_1_name} and {anchor_2_name}",
+            "border area of {anchor_1_name} and {anchor_2_name} within {buffer_km} km",
         ],
     ),
 
@@ -899,6 +1036,10 @@ TEMPLATES = [
             "show {target_subtype}s across {anchor_1_name} and {anchor_2_name}",
             "{target_subtype}s belonging to {anchor_1_name} and {anchor_2_name}",
             "list {target_subtype}s in both {anchor_1_name} and {anchor_2_name}",
+            "give me {target_subtype}s from {anchor_1_name} and {anchor_2_name}",
+            "{anchor_1_name} and {anchor_2_name} {target_subtype}s",
+            "show all {target_subtype}s for {anchor_1_name} plus {anchor_2_name}",
+            "find {target_subtype}s across both {anchor_1_name} and {anchor_2_name}",
         ],
     ),
 
@@ -921,6 +1062,10 @@ TEMPLATES = [
             "all {target_subtype}s in {anchor_1_name}, {anchor_2_name} and {anchor_3_name}",
             "show {target_subtype}s across {anchor_1_name}, {anchor_2_name} and {anchor_3_name}",
             "list {target_subtype}s in {anchor_1_name}, {anchor_2_name} and {anchor_3_name}",
+            "give me {target_subtype}s from {anchor_1_name}, {anchor_2_name}, and {anchor_3_name}",
+            "{anchor_1_name}, {anchor_2_name}, and {anchor_3_name} {target_subtype}s",
+            "show all {target_subtype}s for these three: {anchor_1_name}, {anchor_2_name}, {anchor_3_name}",
+            "find {target_subtype}s across {anchor_1_name}, {anchor_2_name}, and {anchor_3_name}",
         ],
     ),
 
@@ -947,6 +1092,11 @@ TEMPLATES = [
             "union of all {target_subtype}s within {anchor_name}",
             "all {target_subtype}s of {anchor_name} merged together",
             "the overall extent of {target_subtype}s in {anchor_name}",
+            "show one merged shape for all {target_subtype}s in {anchor_name}",
+            "dissolve all {target_subtype}s in {anchor_name}",
+            "make one geometry from all {target_subtype}s in {anchor_name}",
+            "single outline of all {target_subtype}s in {anchor_name}",
+            "combine the {target_subtype}s of {anchor_name} into one area",
         ],
     ),
 
@@ -979,6 +1129,11 @@ TEMPLATES = [
             "the top half of {anchor_name}",
             "northern portion of {anchor_name}",
             "upper half of {anchor_name}",
+            "top side of {anchor_name}",
+            "show north half of {anchor_name}",
+            "cut {anchor_name} to the north half",
+            "only the northern side of {anchor_name}",
+            "north part of {anchor_name}",
         ],
     ),
 
@@ -1008,6 +1163,11 @@ TEMPLATES = [
             "the bottom half of {anchor_name}",
             "southern portion of {anchor_name}",
             "lower half of {anchor_name}",
+            "bottom side of {anchor_name}",
+            "show south half of {anchor_name}",
+            "cut {anchor_name} to the south half",
+            "only the southern side of {anchor_name}",
+            "south part of {anchor_name}",
         ],
     ),
 
@@ -1036,6 +1196,11 @@ TEMPLATES = [
             "eastern part of {anchor_name}",
             "the right half of {anchor_name}",
             "eastern portion of {anchor_name}",
+            "east side of {anchor_name}",
+            "show east half of {anchor_name}",
+            "cut {anchor_name} to the east half",
+            "only the eastern side of {anchor_name}",
+            "right side of {anchor_name}",
         ],
     ),
 
@@ -1064,6 +1229,11 @@ TEMPLATES = [
             "western part of {anchor_name}",
             "the left half of {anchor_name}",
             "western portion of {anchor_name}",
+            "west side of {anchor_name}",
+            "show west half of {anchor_name}",
+            "cut {anchor_name} to the west half",
+            "only the western side of {anchor_name}",
+            "left side of {anchor_name}",
         ],
     ),
 
@@ -1095,6 +1265,10 @@ TEMPLATES = [
             "{clip_feature_name} inside {anchor_name}",
             "parts of {anchor_name} covered by the {clip_feature_name}",
             "show me where {anchor_name} and the {clip_feature_name} overlap",
+            "keep only the part of {anchor_name} in the {clip_feature_name}",
+            "intersection of {anchor_name} and the {clip_feature_name}",
+            "give me the overlap between {anchor_name} and the {clip_feature_name}",
+            "only the shared area of {anchor_name} and the {clip_feature_name}",
         ],
     ),
 
@@ -1129,6 +1303,10 @@ TEMPLATES = [
             "the {top_n} biggest {target_subtype}s within {anchor_name}",
             "largest {target_subtype} in {anchor_name}",
             "which {target_subtype} in {anchor_name} has the most area?",
+            "show the biggest {target_subtype}s in {anchor_name}",
+            "list the largest {target_subtype}s for {anchor_name}",
+            "give me the biggest {target_subtype}s in {anchor_name}",
+            "{anchor_name} largest {target_subtype}s",
         ],
     ),
 
@@ -1160,6 +1338,10 @@ TEMPLATES = [
             "the {top_n} tiniest {target_subtype}s within {anchor_name}",
             "smallest {target_subtype} in {anchor_name}",
             "which {target_subtype} in {anchor_name} has the least area?",
+            "show the smallest {target_subtype}s in {anchor_name}",
+            "list the smallest {target_subtype}s for {anchor_name}",
+            "give me the tiniest {target_subtype}s in {anchor_name}",
+            "{anchor_name} smallest {target_subtype}s",
         ],
     ),
 
@@ -1188,6 +1370,10 @@ TEMPLATES = [
             "the {top_n} largest {target_subtype}s in {anchor_name}",
             "biggest {target_subtype} in {anchor_name}",
             "which {target_subtype} in {anchor_name} is the largest?",
+            "show the largest {target_subtype}s in {anchor_name}",
+            "list the biggest {target_subtype}s in {anchor_name}",
+            "give me the largest {target_subtype}s for {anchor_name}",
+            "{anchor_name} biggest {target_subtype}s",
         ],
     ),
 
@@ -1216,6 +1402,10 @@ TEMPLATES = [
             "the {top_n} smallest {target_subtype}s in {anchor_name}",
             "smallest {target_subtype} in {anchor_name}",
             "which {target_subtype} in {anchor_name} is the smallest?",
+            "show the smallest {target_subtype}s in {anchor_name}",
+            "list the smallest {target_subtype}s in {anchor_name}",
+            "give me the smallest {target_subtype}s for {anchor_name}",
+            "{anchor_name} tiniest {target_subtype}s",
         ],
     ),
 
@@ -1249,6 +1439,11 @@ TEMPLATES = [
             "biggest {target_subtype} per region in {anchor_name}",
             "largest {target_subtype} for every region of {anchor_name}",
             "the biggest {target_subtype} in each province of {anchor_name}",
+            "show the largest {target_subtype} in every region of {anchor_name}",
+            "list biggest {target_subtype} by region in {anchor_name}",
+            "for each region in {anchor_name}, give the largest {target_subtype}",
+            "largest {target_subtype}s grouped by region in {anchor_name}",
+            "one biggest {target_subtype} for each region of {anchor_name}",
         ],
     ),
 
@@ -1279,6 +1474,11 @@ TEMPLATES = [
             "smallest {target_subtype} per region in {anchor_name}",
             "tiniest {target_subtype} for every region of {anchor_name}",
             "the smallest {target_subtype} in each province of {anchor_name}",
+            "show the smallest {target_subtype} in every region of {anchor_name}",
+            "list smallest {target_subtype} by region in {anchor_name}",
+            "for each region in {anchor_name}, give the smallest {target_subtype}",
+            "smallest {target_subtype}s grouped by region in {anchor_name}",
+            "one tiniest {target_subtype} for each region of {anchor_name}",
         ],
     ),
 
@@ -1307,6 +1507,10 @@ TEMPLATES = [
             "{anchor_name}'s land {target_subtype}s",
             "dependencies of {anchor_name} with land area",
             "show the land dependencies of {anchor_name}",
+            "find land dependencies of {anchor_name}",
+            "give me {anchor_name} dependencies on land",
+            "which dependencies of {anchor_name} are land-based?",
+            "non-island {target_subtype}s of {anchor_name}",
         ],
     ),
 
@@ -1330,6 +1534,11 @@ TEMPLATES = [
             "official territorial divisions of {anchor_name}",
             "recognised territorial {target_subtype}s belonging to {anchor_name}",
             "which territorial regions does {anchor_name} have?",
+            "show territorial {target_subtype}s of {anchor_name}",
+            "find official territorial regions of {anchor_name}",
+            "give me recognised territorial {target_subtype}s of {anchor_name}",
+            "territorial regions under {anchor_name}",
+            "{anchor_name} official territorial {target_subtype}s",
         ],
     ),
 
@@ -1353,6 +1562,11 @@ TEMPLATES = [
             "{target_subtype}s of {anchor_name} that are not on land",
             "water-associated {target_subtype}s of {anchor_name}",
             "marine or offshore {target_subtype}s of {anchor_name}",
+            "show offshore {target_subtype}s of {anchor_name}",
+            "find {target_subtype}s of {anchor_name} in water",
+            "give me non-land {target_subtype}s of {anchor_name}",
+            "water-side {target_subtype}s of {anchor_name}",
+            "{anchor_name} {target_subtype}s not on land",
         ],
     ),
 
@@ -1374,7 +1588,7 @@ TEMPLATES = [
             " 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')"
+            " WHERE n.subtype IN ('river', 'lake', 'basin')"
             "   AND ST_Intersects(a.geometry, n.geometry)"
         ),
         question_hints=[
@@ -1386,6 +1600,10 @@ TEMPLATES = [
             "what bodies of water cross {anchor_name}?",
             "rivers of {anchor_name}",
             "show me the lakes in {anchor_name}",
+            "what rivers run through {anchor_name}?",
+            "which lakes lie in {anchor_name}?",
+            "what waterways are in {anchor_name}?",
+            "which basins, lakes, or rivers are in {anchor_name}?",
         ],
     ),
 
@@ -1395,7 +1613,7 @@ TEMPLATES = [
         sql_difficulty="medium",
         anchor_source="divisions_area",
         num_anchors=1,
-        target_subtype="range",
+        target_subtype="range/mtn",
         sql_template=(
             "WITH a AS ("
             "  SELECT geometry FROM read_parquet('divisions_area') WHERE id = '{anchor_id}'"
@@ -1403,18 +1621,84 @@ TEMPLATES = [
             " 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/mtn', 'Peninsula', 'Depression')"
+            " WHERE n.subtype = 'range/mtn'"
             "   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?",
+            "mountain regions in {anchor_name}",
+            "what hills are in {anchor_name}?",
+            "which hills cross {anchor_name}?",
+            "ghats of {anchor_name}",
+            "what ghats are in {anchor_name}?",
+            "highlands in {anchor_name}",
+            "mountain belts within {anchor_name}",
+        ],
+    ),
+
+    SQLTemplate(
+        template_id="adj_07",
+        family="adjacency",
+        sql_difficulty="medium",
+        anchor_source="divisions_area",
+        num_anchors=1,
+        target_subtype="plateau",
+        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 = 'plateau'"
+            "   AND ST_Intersects(a.geometry, n.geometry)"
+        ),
+        question_hints=[
+            "what plateaus are in {anchor_name}?",
+            "which plateaus cross {anchor_name}?",
+            "uplands in {anchor_name}",
+            "what uplands are in {anchor_name}?",
+            "tablelands of {anchor_name}",
+            "plateau regions within {anchor_name}",
+            "show plateaus in {anchor_name}",
+            "find uplands of {anchor_name}",
+            "give me plateau areas in {anchor_name}",
+            "{anchor_name} plateaus and uplands",
+            "what tablelands are there in {anchor_name}?",
+        ],
+    ),
+
+    SQLTemplate(
+        template_id="adj_08",
+        family="adjacency",
+        sql_difficulty="medium",
+        anchor_source="divisions_area",
+        num_anchors=1,
+        target_subtype="landform",
+        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 ('plain', 'lowland', 'basin', 'valley', 'depression', 'gorge')"
+            "   AND ST_Intersects(a.geometry, n.geometry)"
+        ),
+        question_hints=[
+            "what plains are in {anchor_name}?",
+            "basins and valleys of {anchor_name}",
+            "which basins are in {anchor_name}?",
+            "what valleys cross {anchor_name}?",
+            "lowlands in {anchor_name}",
+            "major landforms in {anchor_name}",
+            "plains, basins, and valleys within {anchor_name}",
+            "show me the main landforms in {anchor_name}",
+            "landforms of {anchor_name}",
+            "find plains and basins in {anchor_name}",
+            "{anchor_name} valleys and lowlands",
         ],
     ),
 
@@ -1449,6 +1733,13 @@ TEMPLATES = [
             "what provinces does the {anchor_name} span?",
             "regions along the {anchor_name}",
             "which provinces overlap the {anchor_name}?",
+            "which regions is the {anchor_name} in?",
+            "what states does the {anchor_name} run through?",
+            "which provinces lie along the {anchor_name}?",
+            "show regions crossed by the {anchor_name}",
+            "find administrative regions along the {anchor_name}",
+            "give me the regions touched by the {anchor_name}",
+            "regions of the {anchor_name}",
         ],
     ),
 
@@ -1475,6 +1766,45 @@ TEMPLATES = [
             "everything natural that touches {anchor_name}",
             "what geographic features does {anchor_name} contain?",
             "natural features within or crossing {anchor_name}",
+            "show natural features overlapping {anchor_name}",
+            "find the natural features in or across {anchor_name}",
+            "{anchor_name} intersecting natural features",
+            "what physical features are associated with {anchor_name}?",
+        ],
+    ),
+
+    SQLTemplate(
+        template_id="intersect_05",
+        family="intersection",
+        sql_difficulty="medium-hard",
+        anchor_source="natural_earth",
+        num_anchors=1,
+        target_subtype="county",
+        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 districts does the {anchor_name} pass through?",
+            "what districts does the {anchor_name} cross?",
+            "districts intersected by the {anchor_name}",
+            "which counties does the {anchor_name} flow through?",
+            "what counties overlap the {anchor_name}?",
+            "districts along the {anchor_name}",
+            "which districts are crossed by the {anchor_name}?",
+            "what districts is the {anchor_name} in?",
+            "which counties lie along the {anchor_name}?",
+            "what districts does the {anchor_name} run through?",
+            "show districts crossed by the {anchor_name}",
+            "find counties along the {anchor_name}",
+            "give me the districts touched by the {anchor_name}",
+            "districts of the {anchor_name}",
         ],
     ),
 
@@ -1500,7 +1830,7 @@ TEMPLATES = [
             "   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')"
+            "     WHERE n.subtype IN ('river', 'lake', 'basin')"
             "       AND ST_Intersects(b.geometry, n.geometry)"
             "   )"
         ),
@@ -1512,6 +1842,10 @@ TEMPLATES = [
             "{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}",
+            "show water-side {target_subtype}s in {anchor_name}",
+            "find {target_subtype}s of {anchor_name} by rivers or lakes",
+            "give me riverside places in {anchor_name}",
+            "{target_subtype}s of {anchor_name} on the water",
         ],
     ),
 
@@ -1533,7 +1867,7 @@ TEMPLATES = [
             "   AND ST_Within(b.geometry, region.geometry)"
             "   AND EXISTS ("
             "     SELECT 1 FROM read_parquet('natural_earth') AS n"
-            "     WHERE n.subtype IN ('Range/mtn', 'Depression')"
+            "     WHERE n.subtype IN ('range/mtn', 'depression')"
             "       AND ST_Intersects(b.geometry, n.geometry)"
             "   )"
         ),
@@ -1544,6 +1878,10 @@ TEMPLATES = [
             "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",
+            "show mountain {target_subtype}s in {anchor_name}",
+            "find {target_subtype}s of {anchor_name} in hilly terrain",
+            "give me highland {target_subtype}s of {anchor_name}",
+            "{target_subtype}s of {anchor_name} by the mountains",
         ],
     ),
 
@@ -1581,6 +1919,10 @@ TEMPLATES = [
             "{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}",
+            "show coastal districts of {anchor_name}",
+            "find {target_subtype}s of {anchor_name} by the sea",
+            "give me shoreline {target_subtype}s in {anchor_name}",
+            "{target_subtype}s of {anchor_name} on the coast",
         ],
     ),
 
@@ -1613,6 +1955,10 @@ TEMPLATES = [
             "{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}",
+            "show inland districts of {anchor_name}",
+            "find non-coastal {target_subtype}s in {anchor_name}",
+            "give me inner {target_subtype}s of {anchor_name}",
+            "{target_subtype}s of {anchor_name} away from the coast",
         ],
     ),
 
@@ -1634,7 +1980,7 @@ TEMPLATES = [
             "   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')"
+            "     WHERE n.subtype IN ('river', 'lake', 'basin')"
             "       AND ST_Intersects(b.geometry, n.geometry)"
             "   )"
         ),
@@ -1645,6 +1991,10 @@ TEMPLATES = [
             "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?",
+            "show water-side {target_subtype}s of {anchor_name}",
+            "find {target_subtype}s in {anchor_name} near rivers and lakes",
+            "give me riverside districts of {anchor_name}",
+            "{target_subtype}s of {anchor_name} by the water",
         ],
     ),
 
@@ -1666,7 +2016,7 @@ TEMPLATES = [
             "   AND ST_Within(b.geometry, region.geometry)"
             "   AND EXISTS ("
             "     SELECT 1 FROM read_parquet('natural_earth') AS n"
-            "     WHERE n.subtype IN ('Range/mtn', 'Depression')"
+            "     WHERE n.subtype IN ('range/mtn', 'depression')"
             "       AND ST_Intersects(b.geometry, n.geometry)"
             "   )"
         ),
@@ -1677,6 +2027,10 @@ TEMPLATES = [
             "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?",
+            "show mountain districts of {anchor_name}",
+            "find {target_subtype}s of {anchor_name} in hilly areas",
+            "give me highland {target_subtype}s in {anchor_name}",
+            "{target_subtype}s of {anchor_name} by the mountains",
         ],
     ),
 
@@ -1718,6 +2072,10 @@ TEMPLATES = [
             "seaside regions of {anchor_name}",
             "which provinces of {anchor_name} touch the sea?",
             "states of {anchor_name} along the coast",
+            "show coastal regions of {anchor_name}",
+            "find seaside states of {anchor_name}",
+            "give me provinces of {anchor_name} on the coast",
+            "{anchor_name} regions by the sea",
         ],
     ),
 
@@ -1752,6 +2110,10 @@ TEMPLATES = [
             "regions of {anchor_name} without sea access",
             "interior states of {anchor_name}",
             "states of {anchor_name} that don't border the ocean",
+            "show inland regions of {anchor_name}",
+            "find non-coastal states of {anchor_name}",
+            "give me inner provinces of {anchor_name}",
+            "{anchor_name} regions away from the sea",
         ],
     ),
 
@@ -1784,6 +2146,10 @@ TEMPLATES = [
             "which countries touch the {anchor_name}?",
             "countries with coastline on the {anchor_name}",
             "what nations lie on the {anchor_name}?",
+            "which countries are on the coast of the {anchor_name}?",
+            "what countries lie around the {anchor_name}?",
+            "which nations have shores on the {anchor_name}?",
+            "what countries front the {anchor_name}?",
         ],
     ),
 
@@ -1816,6 +2182,15 @@ TEMPLATES = [
             "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}",
+            "what natural features are around the {anchor_name}?",
+            "what lies near the {anchor_name}?",
+            "which features are close to the {anchor_name}?",
+            "what natural features are near the shoreline of the {anchor_name}?",
+            "show nearby natural features for the {anchor_name}",
+            "find features around the {anchor_name}",
+            "give me natural features near the {anchor_name}",
+            "features around the {anchor_name}",
+            "what is close to the {anchor_name} within {buffer_km} km",
         ],
     ),
 

src/gazet/config.py

@@ -80,7 +80,7 @@ Available DuckDB datasets (read via read_parquet):
    columns:
      id VARCHAR              -- unique feature id prefixed 'ne_'
      names STRUCT("primary" VARCHAR, ...)
-     subtype VARCHAR         -- e.g. 'ocean', 'sea', 'bay', 'Terrain area', 'Island group'
+     subtype VARCHAR         -- e.g. 'ocean', 'sea', 'bay', 'range/mtn', 'island group'
      class VARCHAR
      country VARCHAR
      region VARCHAR

src/gazet/lm.py

@@ -31,8 +31,6 @@ class ExtractPlaces(dspy.Signature):
     - If the user mentions a natural earth physical feature, use the natural earth physical features.
     - If the user mentions a place name that is not in the overture divisions or natural earth physical features, return the place name as is.
 
-    Where possible and relevant, also extract the ISO country code for each place.
-
     Only extract place names that are explicitly mentioned in the query.
     Do NOT generate or infer place names from your own knowledge.
     For example:
@@ -41,47 +39,14 @@ class ExtractPlaces(dspy.Signature):
     - "neighbouring states of Odisha" -> extract "Odisha", NOT neighbouring state names
 
     Do not repeat the same place name in the result.
-
-    If the user does not explicitly mention a country, dont add the country code to the result.
-
-    If the user does not mention an admin level, dont add the subtype to the result.
-
-    If the query asks for some kind of subdivision (e.g. 'municipalities in Bern', 'States in Brazil'),
-    return the subdivision type in the places result.
-
-    When identifying a place name from the user's query, also infer the most appropriate
-    Overture division subtype from the list below. Only include a subtype if the query
-    makes it reasonably clear what geographic level is intended. If ambiguous, omit it.
-
-    SUBTYPES:
-    - country      : Sovereign nation. E.g. "France", "Brazil"
-    - dependency   : Territory dependent on a country but not a full sub-region. E.g. "Puerto Rico", "Guam"
-    - region       : Largest admin unit within a country; state, province, canton, etc. E.g. "California", "Alberta", "Bavaria"
-    - county       : Second-level admin subdivision within a region. E.g. "Kings County", "Kent"
-    - localadmin   : A governing layer (common in Europe) that contains localities which have no authority of their own. E.g. a French commune or Belgian municipality. Use when the place is clearly an admin unit but not a city itself.
-    - locality     : A populated place — city, town, village. The most common subtype for named settlements. E.g. "Lisbon", "Taipei", "Salt Lake City"
-    - macrohood    : A large super-neighborhood grouping smaller neighborhoods. E.g. "BoCoCa" in Brooklyn
-    - neighborhood : A named community area within a city or town. E.g. "Cobble Hill", "Alfama"
-    - microhood    : A mini-neighborhood within a neighborhood. Very fine-grained, rarely referenced explicitly.
-
-    HIERARCHY (coarse to fine):
-    country → dependency / region → county → localadmin → locality → macrohood → neighborhood → microhood
-
-    GUIDANCE:
-    - "Paris" with no qualifier → locality
-    - "Île-de-France" or "Catalonia" → region
-    - "the 11th arrondissement" → neighborhood (or localadmin)
-    - "Greater London" style phrasing → county or region depending on context
-    - If the user says "neighborhood in X" or "district of X" → neighborhood
-    - Default to locality for any named city/town if unsure
-    - Omit subtype entirely if the query gives no signal (e.g. bare coordinates or a POI name)
+    Return only the place names, in the order they appear in the query.
     """
 
     query: str = dspy.InputField(
         desc="Natural language query mentioning one or more place names"
     )
     result: PlacesResult = dspy.OutputField(
-        desc="Extracted places with optional country codes and optional subtype"
+        desc="Extracted place names in query order"
     )
 
 
@@ -203,7 +168,7 @@ You have access to two DuckDB parquet tables. Given a set of candidate entities
      id VARCHAR              -- unique feature id prefixed 'ne_'
      names STRUCT("primary" VARCHAR, ...)
      country VARCHAR
-     subtype VARCHAR         -- e.g. 'ocean', 'sea', 'bay', 'Terrain area', 'Island group'
+     subtype VARCHAR         -- e.g. 'ocean', 'sea', 'bay', 'range/mtn', 'island group'
      class VARCHAR
      region VARCHAR
      admin_level INTEGER
@@ -265,21 +230,68 @@ def _llama_chat_complete(messages: list[dict]) -> str:
     return resp.json()["choices"][0]["message"]["content"]
 
 
-_PLACES_SYSTEM_PROMPT = """You are a geographic entity extractor. Extract place names from the user query and return valid JSON only.
+_PLACES_SYSTEM_PROMPT = """You are a geographic entity extractor. Extract the place names the user is asking about and return valid JSON only.
 
 OUTPUT FORMAT:
-{"places": [{"place": "<name>", "country": "<ISO-2>", "subtype": "<subtype>"}]}
-"country" and "subtype" are optional; omit if not applicable.
+{"places": [{"place": "<name>"}]}
 
 RULES:
-- Only extract places explicitly mentioned. Never infer or expand (e.g. "states of India" -> extract "India" only).
+- Extract the place or places that are the actual anchors of the query.
+- Physical features are valid places: oceans, seas, gulfs, bays, straits, rivers, lakes, basins, mountain ranges, peninsulas, island groups, deserts, and terrain regions.
+- When a place is followed by its containing region, state, or country as disambiguation context ("Puri, Odisha", "Lisboa, Portugal", "Goa, India", "Manchester in US"), extract ONLY the specific place. Do not return the container as a separate place.
+- When a query names two or more distinct anchors joined by words like "and", "both", "between", or mixes an admin area with a physical feature as separate anchors, extract every anchor in the order they appear.
+- Do not infer or expand category nouns like "regions", "districts", "counties", "rivers", or "mountains" when they refer to a type rather than a specific named place ("regions of India" -> extract "India" only).
+- Only extract places explicitly mentioned.
 - No duplicate place names.
-- "country": ISO 3166-1 alpha-2. Include only if explicitly mentioned or unambiguous.
-- "subtype": include only when the geographic level is clear from the query.
 
-SUBTYPES:
-country, dependency, region, county, localadmin, locality, macrohood, neighborhood, microhood
-- Default to locality for cities/towns; omit for physical features (oceans, rivers, mountains)."""
+EXAMPLES:
+Query: "Puri, Odisha"
+-> {"places": [{"place": "Puri"}]}
+
+Query: "Lisboa, Portugal"
+-> {"places": [{"place": "Lisboa"}]}
+
+Query: "Goa, India"
+-> {"places": [{"place": "Goa"}]}
+
+Query: "Manchester in US"
+-> {"places": [{"place": "Manchester"}]}
+
+Query: "Springfield, Illinois"
+-> {"places": [{"place": "Springfield"}]}
+
+Query: "coastal districts of Brazil"
+-> {"places": [{"place": "Brazil"}]}
+
+Query: "northern half of India"
+-> {"places": [{"place": "India"}]}
+
+Query: "what's within 50 km of Paris?"
+-> {"places": [{"place": "Paris"}]}
+
+Query: "countries the Nile crosses"
+-> {"places": [{"place": "Nile"}]}
+
+Query: "which countries touch the Gulf of Maine"
+-> {"places": [{"place": "Gulf of Maine"}]}
+
+Query: "10 km buffer around Odisha"
+-> {"places": [{"place": "Odisha"}]}
+
+Query: "part of Ecuador in the Amazon basin"
+-> {"places": [{"place": "Ecuador"}, {"place": "Amazon basin"}]}
+
+Query: "Amazon basin inside Ecuador"
+-> {"places": [{"place": "Amazon basin"}, {"place": "Ecuador"}]}
+
+Query: "the part of Chad in Lake Chad"
+-> {"places": [{"place": "Chad"}, {"place": "Lake Chad"}]}
+
+Query: "which regions border both France and Germany?"
+-> {"places": [{"place": "France"}, {"place": "Germany"}]}
+
+Query: "merge Nairobi and Mombasa"
+-> {"places": [{"place": "Nairobi"}, {"place": "Mombasa"}]}"""
 
 
 def generate_places(user_query: str) -> PlacesResult:
@@ -318,7 +330,7 @@ def generate_sql(user_query: str, candidates_df: pd.DataFrame) -> str:
     Single-shot — no retry loop (the finetuned model can't improve from error feedback).
     """
     # Keep only columns the model was trained on
-    keep_cols = ["source", "id", "name", "subtype", "country", "region", "admin_level", "similarity"]
+    keep_cols = ["source", "id", "name", "subtype", "country", "region", "admin_level"]
     cols = [c for c in keep_cols if c in candidates_df.columns]
     candidates_csv = candidates_df[cols].to_csv(index=False)
 

src/gazet/schemas.py

@@ -292,10 +292,7 @@ COUNTRIES = Literal[
 
 class Place(BaseModel):
     place: str
-    country: Optional[COUNTRIES] = None
-    subtype: Optional[SUBTYPES] = None
 
 
 class PlacesResult(BaseModel):
     places: List[Place]
-    subtype: Optional[SUBTYPES] = None

src/gazet/sql.py

@@ -2,6 +2,17 @@ import json
 import re
 from typing import Any, Generator, Optional
 
+
+_CANDIDATE_PROMPT_COLS = [
+    "source",
+    "id",
+    "name",
+    "subtype",
+    "country",
+    "region",
+    "admin_level",
+]
+
 import duckdb
 import pandas as pd
 from shapely import wkb
@@ -88,11 +99,21 @@ _NE_SUBTYPE_FIXES = {
     "'Sea'": "'sea'",
 }
 
+_TERRAIN_AREA_PATTERN = re.compile(
+    r"n\.subtype\s*(=|IN\s*\()\s*'Terrain area'\s*\)?",
+    flags=re.IGNORECASE,
+)
+
 
 def _normalize_ne_subtypes(sql: str) -> str:
-    """Lowercase known NE subtype literals so they match the normalised data."""
+    """Lowercase known NE subtype literals and fix common terrain hallucinations."""
     for old, new in _NE_SUBTYPE_FIXES.items():
         sql = sql.replace(old, new)
+
+    sql = _TERRAIN_AREA_PATTERN.sub(
+        "n.subtype IN ('range/mtn', 'peninsula', 'depression')",
+        sql,
+    )
     return sql
 
 
@@ -189,7 +210,8 @@ def run_geo_sql_dspy(
         yield {"type": "result", "df": None, "sql": ""}
         return
 
-    candidates_str = candidates_df.to_string(index=False)
+    cols = [c for c in _CANDIDATE_PROMPT_COLS if c in candidates_df.columns]
+    candidates_str = candidates_df[cols].to_string(index=False)
     previous_sql = ""
     error = ""