FORGIVING TOWNS: map any building kind (never reject), district reroute, restore god's voice (content-only moderation), town few-shot pushes build_district+roads, honest fail on empty

engine/moderation.py

@@ -212,6 +212,7 @@ class Moderator:
     # -- layers 1 + 2 (sync, cheap, deterministic) --
 
     def precheck(self, text: Any) -> Verdict:
+        """Full gate for USER wish input: length + charset bounds + content."""
         if not isinstance(text, str):
             return _deny("empty")
         # fold benign line breaks/tabs to spaces before the printable gate
@@ -222,6 +223,18 @@ class Moderator:
             return _deny("length")
         if any(not ch.isprintable() for ch in raw):
             return _deny("charset")
+        return self.check_content(raw)
+
+    def check_content(self, text: Any) -> Verdict:
+        """Content-only check (slurs/hate/sexual/etc.) WITHOUT the wish-input
+        length/charset bounds. Use this to re-moderate MODEL-composed text — the
+        god's reading is intentionally long (~700 chars); applying the 140-char
+        wish limit here silenced every reading (June 12 regression)."""
+        if not isinstance(text, str):
+            return _deny("empty")
+        raw = re.sub(r"\s+", " ", text).strip()
+        if not raw:
+            return _deny("empty")
 
         for symbol in _SYMBOLS:
             if symbol in raw:

engine/queue_worker.py

@@ -389,7 +389,7 @@ class QueueWorker:
             # default-deny so the world never carries an unvetted inscription.
             if isinstance(call, dict) and call.get("tool") == "inscribe_wish":
                 ins = (call.get("args") or {}).get("text", "")
-                if not self._moderator.precheck(ins).allowed:
+                if not self._moderator.check_content(ins).allowed:
                     return "rejected: those words may not be written here; choose gentler ones"
             feature, observation = self._world.apply(item.wish_id, index, call)
             if feature is not None:
@@ -430,10 +430,10 @@ class QueueWorker:
         # live, but the durable record — what judges and visitors re-read — is
         # clean.) Epitaph shows on the grant card, so a denied one is replaced.
         reading = _trace_get(trace, "reading")
-        if reading and not self._moderator.precheck(reading).allowed:
+        if reading and not self._moderator.check_content(reading).allowed:
             _trace_set(trace, "reading", "the god read this wish in silence.")
         epitaph = _trace_get(trace, "epitaph")
-        if not epitaph or not self._moderator.precheck(epitaph).allowed:
+        if not epitaph or not self._moderator.check_content(epitaph).allowed:
             epitaph = _epitaph_from_reading(_trace_get(trace, "reading")) or FALLBACK_EPITAPH
             _trace_set(trace, "epitaph", epitaph)
         self._enrich_trace(trace, item)

engine/tools.py

@@ -53,6 +53,62 @@ STRUCTURE_KINDS = (
     "lighthouse", "monolith", "shrine", "village", "beacon", "arch",
     "tower", "warehouse", "cafe", "bank", "market", "house",
 )
+# The god (a 9B model, no grammar constraint on the live ZeroGPU path) invents
+# building names freely — "market_square", "skyscraper", "townhall". REJECTING
+# them makes a town wish build nothing and the model gives up (June 12 live:
+# "it says it created the town... there is no town"). So place_structure is
+# FORGIVING: synonyms map to a real kind, and any unknown kind falls back to a
+# house rather than failing. The god always builds something.
+STRUCTURE_SYNONYMS: dict[str, str] = {
+    "market_square": "market", "marketsquare": "market", "square": "market",
+    "plaza": "market", "bazaar": "market", "marketplace": "market", "stall": "market",
+    "skyscraper": "tower", "highrise": "tower", "high_rise": "tower", "office": "tower",
+    "spire": "tower", "obelisk": "monolith", "pillar": "monolith", "stone": "monolith",
+    "depot": "warehouse", "storehouse": "warehouse", "storage": "warehouse",
+    "factory": "warehouse", "barn": "warehouse", "silo": "warehouse",
+    "coffee": "cafe", "coffeehouse": "cafe", "restaurant": "cafe", "diner": "cafe",
+    "cafeteria": "cafe", "inn": "cafe", "tavern": "cafe", "pub": "cafe", "bakery": "cafe",
+    "home": "house", "cottage": "house", "cabin": "house", "hut": "house", "lodge": "house",
+    "dwelling": "house", "residence": "house", "bungalow": "house", "manor": "house",
+    "church": "shrine", "temple": "shrine", "chapel": "shrine", "cathedral": "shrine",
+    "townhall": "bank", "town_hall": "bank", "hall": "bank", "courthouse": "bank",
+    "library": "bank", "museum": "bank", "school": "bank", "guildhall": "bank",
+    "harbor": "lighthouse", "harbour": "lighthouse", "port": "lighthouse", "dock": "lighthouse",
+    "gate": "arch", "gateway": "arch", "bridge": "arch", "tower_gate": "arch",
+    "fire": "beacon", "torch": "beacon", "lantern": "beacon", "lamp": "beacon",
+    "hamlet": "village", "settlement": "village", "houses": "village",
+}
+# Kinds that really mean "a whole neighborhood" -> the engine routes them to a
+# dense build_district instead of a single building, so the town reads dense.
+DISTRICT_SYNONYMS = frozenset((
+    "district", "neighborhood", "neighbourhood", "block", "quarter", "town",
+    "city", "downtown", "suburb", "metropolis", "borough", "ward",
+))
+
+
+def resolve_structure_kind(value: Any) -> str | None:
+    """Map a model-supplied kind to a real STRUCTURE_KINDS value. None means
+    'this is really a district' (caller should route to build_district).
+    Unknown-but-buildingish names fall back to 'house' — never a rejection."""
+    if not isinstance(value, str):
+        return "house"
+    v = value.strip().lower().replace(" ", "_").replace("-", "_")
+    if v in STRUCTURE_KINDS:
+        return v
+    if v in DISTRICT_SYNONYMS:
+        return None
+    if v in STRUCTURE_SYNONYMS:
+        return STRUCTURE_SYNONYMS[v]
+    # substring rescue (e.g. "grand_market_hall" -> market) before defaulting
+    for token, kind in STRUCTURE_SYNONYMS.items():
+        if token in v:
+            return kind
+    for kind in STRUCTURE_KINDS:
+        if kind in v:
+            return kind
+    return "house"  # any other word becomes a humble house, never a rejection
+
+
 WATER_KINDS = ("stream", "pool")
 WEATHER_KINDS = ("clear", "rain", "snow", "embers", "mist", "storm")
 SKY_PALETTES = ("dawn", "dusk", "night", "aurora", "ember", "void", "gold")
@@ -289,6 +345,21 @@ def validate_call(tool: Any, args: Any) -> tuple[Optional[dict], Optional[str]]:
     if tool == "place_road":
         return _validate_place_road(args)
 
+    # place_structure: forgive the kind. A "district"-ish name becomes a dense
+    # build_district; any other unknown becomes the nearest real building (or a
+    # house) — the god never builds nothing because it picked a word we lack.
+    if tool == "place_structure":
+        resolved = resolve_structure_kind(args.get("kind"))
+        if resolved is None:
+            district_args = {
+                "lat": args.get("lat"), "lon": args.get("lon"),
+                "radius_deg": args.get("radius_deg", 6),
+                "density": args.get("density", 0.7),
+                "hue": args.get("hue", 40),
+            }
+            return validate_call("build_district", district_args)
+        args = {**args, "kind": resolved}
+
     out: dict[str, Any] = {}
     for name, spec in TOOLS[tool].items():
         if name not in args or args.get(name) is None:

mind/prompts.py

@@ -179,33 +179,40 @@ You do not hold the world's facts; the engine does. You read the wish, say what
 you see, and act only through the tools below. ONLY these eleven tools exist —
 any other tool name is refused. When a wish asks for what no tool can make, do
 not refuse: translate its spirit into what the tools CAN make. Plans are
-concrete: coordinates, kinds, hues. Three to five acts, then rest. Numbers out
-of range are clamped; unknown kinds are refused — listen to the observations
-and adapt.
-
-You are growing ONE town. The world's summary names it and gives its center —
-new buildings rise BESIDE the old ones, near that center, never alone in the
-wilderness. Link them with roads (place_road). When a wish asks for a city, a
-quarter, or many homes, reach for build_district — one call raises a whole
-neighborhood. Add to the town; do not scatter a lone building across an empty
-world."""
+concrete: coordinates, kinds, hues. Numbers out of range are clamped; the engine
+maps any building word you choose to what it has, so build FREELY and never stop
+to second-guess a name.
+
+You are growing ONE town, and a town is never one building. Make it FULL: a town
+wish wants FOUR TO SIX acts. ALWAYS begin a settlement or any "city / town /
+square / district / neighborhood / houses" wish with `build_district` — one call
+raises a whole cluster of homes and lanes. THEN set civic landmarks beside it
+(`place_structure` bank, market, cafe, tower) and lay `place_road` between them.
+The world's summary names the town and gives its center — build BESIDE the
+existing buildings, near that center, never alone in the wilderness. Only say
+done once the place feels inhabited."""
 
 FEW_SHOT = """An example from long ago — ANOTHER mortal's wish, already granted and
-gone. It shows only the manner of working. Never repeat its subjects (no
-lighthouse, no headland, no dusk) unless the new wish itself asks:
-
-WISH: let there be a lighthouse for the lost ships
-READING: A keeper's wish. The dark water wants one steady eye on it. I will raise a headland in the north, set a tower with a turning lamp upon it, and pull the sky to dusk so the beam has work to do.
-TURN -> {"thought": "First, ground to stand on: a headland above the waterline.", "call": {"tool": "raise_terrain", "args": {"lat": 48, "lon": -20, "radius_deg": 10, "height": 0.06, "roughness": 0.5}}}
-OBSERVATION: ok: terrain risen at (48,-20)
-TURN -> {"thought": "The tower itself, warm-lit at the lamp.", "call": {"tool": "place_structure", "args": {"lat": 49, "lon": -21, "kind": "lighthouse", "scale": 1.6, "hue": 45}}}
-OBSERVATION: ok: lighthouse placed at (49,-21)
-TURN -> {"thought": "A dusk sky, so the beam means something.", "call": {"tool": "set_sky", "args": {"palette": "dusk", "star_density": 0.4, "moons": 1}}}
-OBSERVATION: ok: sky set to dusk
-TURN -> {"thought": "It is enough. Lit things stay lit.", "done": true, "epitaph": "A light now turns in the north, for ships that have not yet come."}
-
-(The example's places, numbers and kinds belong to that old wish alone. For the
-wish before you, choose your own coordinates from your own reading.)"""
+gone. It shows only the MANNER of working: begin a town with build_district, set
+landmarks beside it, link them with a road, fill it before resting. Never repeat
+its exact places or numbers — choose your own near the town's center:
+
+WISH: found a town here, with homes and a market
+READING: A beginning. I will lay a quarter of houses on the high ground, set a market at its heart and a bank at its shoulder, and thread a road between them so the place can breathe.
+TURN -> {"thought": "First the homes — a whole quarter, not one roof.", "call": {"tool": "build_district", "args": {"lat": 14, "lon": 38, "radius_deg": 7, "density": 0.8, "hue": 40}}}
+OBSERVATION: ok: a district rises near (14,38)
+TURN -> {"thought": "A market at the heart of it.", "call": {"tool": "place_structure", "args": {"lat": 14, "lon": 39, "kind": "market", "scale": 1.2, "hue": 45}}}
+OBSERVATION: ok: market placed at (14,39)
+TURN -> {"thought": "A bank at its shoulder.", "call": {"tool": "place_structure", "args": {"lat": 15, "lon": 38, "kind": "bank", "scale": 1.1, "hue": 50}}}
+OBSERVATION: ok: bank placed at (15,38)
+TURN -> {"thought": "A road to bind the quarter to its market.", "call": {"tool": "place_road", "args": {"path": [[14, 38], [14, 39], [15, 38]]}}}
+OBSERVATION: ok: a road laid through 3 points
+TURN -> {"thought": "It is a town now — let carts move through it.", "call": {"tool": "spawn_life", "args": {"lat": 14, "lon": 38, "radius_deg": 6, "kind": "carts", "count": 5, "hue": 40}}}
+OBSERVATION: ok: 5 carts stirring at (14,38)
+TURN -> {"thought": "Inhabited. It can grow from here.", "done": true, "epitaph": "A town begins on the high ground, its market already loud at dawn."}
+
+(Those places belong to that old wish. For the wish before you, build near THIS
+town's center from the world summary.)"""
 
 
 # --------------------------------------------------------------------------

tests/test_engine.py

@@ -569,12 +569,23 @@ def test_new_structure_kinds_accepted():
         assert obs == f"ok: {kind} placed at (5,5)"
 
 
-def test_place_structure_still_rejects_unknown_kind():
+def test_place_structure_forgives_unknown_and_synonym_kinds():
+    # June 12: rejecting model-invented kinds made town wishes build nothing.
+    # Now place_structure NEVER rejects a kind — it maps it.
     args, err = validate_call(
-        "place_structure",
-        {"lat": 0, "lon": 0, "kind": "castle", "scale": 1.0, "hue": 100},
-    )
-    assert args is None and err == "rejected: unknown kind 'castle'"
+        "place_structure", {"lat": 0, "lon": 0, "kind": "castle", "scale": 1.0, "hue": 100})
+    assert err is None and args["kind"] == "house"  # unknown -> humble house
+
+    for given, expected in [("market_square", "market"), ("skyscraper", "tower"),
+                            ("coffeehouse", "cafe"), ("cottage", "house"), ("church", "shrine")]:
+        args, err = validate_call(
+            "place_structure", {"lat": 1, "lon": 1, "kind": given, "scale": 1.0, "hue": 50})
+        assert err is None and args["kind"] == expected, f"{given} -> {args}"
+
+    # a "district"-ish kind reroutes to a dense build_district
+    args, err = validate_call(
+        "place_structure", {"lat": 2, "lon": 3, "kind": "neighborhood", "scale": 1.0, "hue": 40})
+    assert err is None and "density" in args and "kind" not in args  # build_district shape
 
 
 def test_spawn_life_valid_and_clamped():