Town Mode: close town view by default, build_district + place_road, bank/market/house, grow-one-town steering, behold-the-world reveal, tamed needle

ARCHITECTURE.md

@@ -78,7 +78,11 @@ renderer derives ALL geometry deterministically from this list. Sky/weather are
 `seed` is assigned by the engine: `seed = crc32(f"{wish_id}:{call_index}") & 0x7fffffff`. The JS
 renderer uses the same seed with mulberry32 for all scatter/noise decisions of that feature.
 
-### Tool DSL — exactly 9 tools (GBNF-friendly: flat args, numbers + enums + short strings)
+### Tool DSL — 11 tools (GBNF-friendly: flat args, numbers + enums + short strings)
+
+> The base table below is the original 9; the City Update added `spawn_life` and the Town Mode
+> update added `build_district` + `place_road` (full specs in those sections). The live surface is
+> **11 tools** — see `engine/tools.py` (`TOOL_NAMES`) for the source of truth.
 
 | tool | args (ranges clamped by engine) |
 |---|---|
@@ -296,6 +300,67 @@ mind/mock_scripts.py + tests; (B) web/planet/structures.js (new kinds only);
 (C) web/planet/life.js + web/planet/camera.js + main.js/book.js descend hooks.
 Copy updates (README 8→9 tools etc.) ride with (A).
 
+## Town Mode (v1.2 contract — June 12 PM, "Town on the planet")
+
+User feedback: a city wish produced one tower on the far side of a planet-sized sphere → reads empty.
+The fix is a deliberate experience shift: the DEFAULT view is a town you build up close (SimCity feel);
+the full planet becomes the dramatic zoom-out reveal. Append-only world preserved; genesis UNCHANGED
+(the live shared world must keep rebuilding identically). All additive.
+
+### The town anchor (engine + renderer compute IDENTICALLY)
+`townCenter(world)` = the seeded-weighted centroid (unit-vector mean, renormalized) of all
+`place_structure` + `build_district` feature directions, EXCLUDING genesis. Fallback when none exist:
+the genesis monolith at lat 14, lon 38. Engine exposes it in the world summary; the renderer uses it
+for the default camera. A town gets a deterministic name from `crc32(round(lat),round(lon))` → a small
+curated name list (e.g. "Lowmere", "Ashford", "Tessen") so the summary + HUD can say "the town of X".
+
+### Density comes from each tool call, not from many (the 9B reliably plans only ~2-3 calls)
+New tools (now **11** — update every "9 tools" copy → 11; list build_district + place_road):
+| tool | args |
+|---|---|
+| `build_district` | `lat`,`lon`,`radius_deg` 2..15, `density` 0..1, `hue` 0..360 — renderer places a SEEDED neighborhood: a cluster of small houses on a rough grid, footpath/road connectors between them, and 1 occasional civic building. ONE successful call = a visible block. This is the SimCity unlock. |
+| `place_road` | `path` [[lat,lon] ×2..6] — a paved, faintly-lit road spline laid ON the surface; visually DISTINCT from `place_water` glowing streams (warm stone/amber, matte, dashed centerline feel — not emissive cyan). |
+
+`place_structure.kind` enum += `bank`, `market`, `house` (single landmark homes/civic buildings; the
+existing low-poly kit conventions). Full set: lighthouse|monolith|shrine|village|beacon|arch|tower|
+warehouse|cafe|bank|market|house.
+
+### Steering the god to GROW THE TOWN (mind/prompts.py + engine/summary.py)
+- summary.py: name the town + its center + building count ("The town of Lowmere stands near (14,38):
+  3 towers, a café, 12 houses."). When the wish asks for buildings/a city, the god should ADD to the
+  existing town, not scatter — build near townCenter, connect with `place_road`, and reach for
+  `build_district` for neighborhoods. Persona gains: "You are growing one town. New buildings rise
+  beside the old ones, linked by roads — never alone in the wilderness."
+- This is steering, not enforcement (keeps the "god decides" purity). The camera following density
+  means even a stray build is visible; over wishes the town concentrates.
+
+### Camera = two modes (web/planet/camera.js + main.js)
+- **TOWN view (DEFAULT on load):** camera sits LOW and close, framing a ~28° cap around townCenter —
+  buildings read large, like standing over a model town. This is what visitors see first now (not the
+  full orbit).
+- **WORLD view (the reveal):** a HUD control "behold the world ↕" eases out to the full-planet orbit
+  (today's gorgeous wide shot) and back. The demo money-move: build the town, then pull back to show
+  it's one patch on a shared planet.
+- On each `world_delta`/grant, frame the new feature WITHIN the town zoom (don't fly to the far limb).
+- The existing descent stays (epitaph card) — now it descends within the town.
+
+### Tame the god-needle
+The orbital "god instrument" needle currently dominates the frame (huge gold double-cone). In TOWN
+view it must be small/high or hidden; show it prominently only during active granting (it "writes" the
+wish) and in WORLD view. Scale it down ~60% at rest.
+
+### Ownership for the Town Mode build
+- ENGINE+MIND (A): engine/tools.py (build_district, place_road, +3 structure kinds), engine/summary.py
+  (town name+center+counts), engine/world.py (_observation for new tools), mind/grammar.gbnf,
+  mind/mock_scripts.py (town-growth scripts), mind/prompts.py (grow-the-town steering + 11-tool copy),
+  tests; README/ARCHITECTURE 9→11 copy.
+- RENDERER (B): web/planet/structures.js (bank/market/house kit), web/planet/district.js (NEW —
+  seeded house+road neighborhood), web/planet/roads.js (NEW — paved road splines) OR fold roads into
+  water.js styling, web/planet/world.js wiring, needle scale-down (find it — likely sky.js or scene.js).
+- CAMERA+HUD (C): web/planet/camera.js (TOWN/WORLD modes + townCenter framing), web/main.js + book.js
+  (default TOWN view, "behold the world" toggle, frame-within-town on delta), web/index.html +
+  style.css (the toggle control). townCenter helper shared via web/planet/util.js.
+
 ## Deploy plan (not in this build phase — for context)
 
 1. Personal benchmark Space first: llamacpp 4B on free CPU + (separately) ZeroGPU 30B-A3B; measure

README.md

@@ -87,9 +87,9 @@ church and state:
 ```
 
 The model never computes geometry and never owns state — it interprets, narrates, and
-picks from a DSL of exactly 9 tools (`raise_terrain`, `lower_terrain`, `spawn_flora`,
+picks from a DSL of exactly 11 tools (`raise_terrain`, `lower_terrain`, `spawn_flora`,
 `place_structure`, `place_water`, `set_weather`, `set_sky`, `inscribe_wish`,
-`spawn_life`). The
+`spawn_life`, `build_district`, `place_road`). The
 deterministic engine clamps every number, seeds every feature, and feeds terse
 observations back into the loop. Wishes pass layered moderation before a single tool
 runs. Latency is liturgy: the god grants **one wish at a time**, and you see your place

engine/__init__.py

@@ -1,6 +1,6 @@
 """GODSEED deterministic world engine.
 
-The engine owns ALL facts ("her" pattern): world state, the 9-tool DSL,
+The engine owns ALL facts ("her" pattern): world state, the 11-tool DSL,
 validation, moderation, the serialized wish queue, and the prompt summary.
 The LLM only interprets wishes and picks tool calls — it never owns state.
 """

engine/summary.py

@@ -1,12 +1,15 @@
 """Compact world description for the LLM prompt (<600 chars, always).
 
-Covers: epoch, terrain count + notable coords, flora kinds, structures with
-coords, current sky/weather, last 2 epitaphs. Duck-types over World so this
-module stays import-free of engine.world (no cycles).
+Covers: the town (name + center + building tally), epoch, terrain count +
+notable coords, flora kinds, structures with coords, current sky/weather, last
+2 epitaphs. Duck-types over World so this module stays import-free of
+engine.world (no cycles).
 """
 
 from __future__ import annotations
 
+import math
+import zlib
 from typing import Any
 
 MAX_LEN = 599  # contract: strictly under 600 chars
@@ -16,6 +19,71 @@ _MAX_FLORA_KINDS = 6
 _MAX_STRUCTURES = 4
 _EPITAPH_CLIP = 70
 
+# --------------------------------------------------------------------------
+# Town anchor — the seeded-weighted centroid of the built world (v1.2)
+# --------------------------------------------------------------------------
+#
+# townCenter is a CROSS-COMPONENT contract: the JS renderer's camera computes
+# the SAME value to frame the default TOWN view, so this math must be matched
+# byte-for-byte. It is the unit-vector mean of every non-genesis place_structure
+# + build_district direction, renormalized back to (lat, lon). With nothing
+# built yet it falls back to the genesis monolith.
+
+# The genesis monolith (f_000002) — the town's seed when nothing else is built.
+GENESIS_MONOLITH = (14.0, 38.0)
+
+# Town-anchoring tools (their lat/lon define where the town sits).
+_TOWN_TOOLS = ("place_structure", "build_district")
+
+# A curated name pool; crc32(round(lat), round(lon)) selects one deterministically.
+TOWN_NAMES: tuple[str, ...] = (
+    "Lowmere", "Ashford", "Tessen", "Harrowfen", "Mossgate", "Brighthollow",
+    "Stilwater", "Emberlyn", "Caldmoor", "Vesper", "Thornwick", "Glasswend",
+    "Dunmarrow", "Sorrel", "Wyndholt", "Pellan",
+)
+
+
+def town_center(world: Any) -> tuple[float, float]:
+    """Return the town anchor (lat, lon) for a world.
+
+    The unit-vector mean of all non-genesis ``place_structure`` +
+    ``build_district`` directions, renormalized to a (lat, lon) pair. Falls back
+    to the genesis monolith at (14, 38) when nothing has been built. The result
+    lat/lon are rounded to 4 places (stable across the engine/renderer split).
+    """
+    features = list(getattr(world, "features", ()) or ())
+    x = y = z = 0.0
+    n = 0
+    for f in features:
+        if f.wish_id == "genesis" or f.tool not in _TOWN_TOOLS:
+            continue
+        lat = f.args.get("lat")
+        lon = f.args.get("lon")
+        if lat is None or lon is None:
+            continue
+        rlat = math.radians(float(lat))
+        rlon = math.radians(float(lon))
+        cos_lat = math.cos(rlat)
+        x += cos_lat * math.cos(rlon)
+        y += cos_lat * math.sin(rlon)
+        z += math.sin(rlat)
+        n += 1
+    if n == 0:
+        return GENESIS_MONOLITH
+    norm = math.sqrt(x * x + y * y + z * z)
+    if norm == 0.0:  # antipodal directions cancel; fall back rather than divide by zero
+        return GENESIS_MONOLITH
+    x, y, z = x / norm, y / norm, z / norm
+    lat = math.degrees(math.asin(max(-1.0, min(1.0, z))))
+    lon = math.degrees(math.atan2(y, x))
+    return round(lat, 4), round(lon, 4)
+
+
+def town_name(lat: float, lon: float) -> str:
+    """Deterministic town name from its rounded center (crc32 -> curated pool)."""
+    key = f"{round(lat)},{round(lon)}".encode("utf-8")
+    return TOWN_NAMES[zlib.crc32(key) % len(TOWN_NAMES)]
+
 
 def _coord(args: dict) -> str:
     lat, lon = args.get("lat"), args.get("lon")
@@ -33,9 +101,54 @@ def _clip(text: str, limit: int) -> str:
     return text if len(text) <= limit else text[: limit - 3] + "..."
 
 
+_A_OR_AN_VOWEL = "aeiou"
+_MAX_TALLY_KINDS = 5  # cap the building tally so the line stays short
+
+
+def _count_phrase(noun: str, n: int) -> str:
+    """'3 towers' / 'a cafe' (singular gets an article)."""
+    if n == 1:
+        article = "an" if noun[:1].lower() in _A_OR_AN_VOWEL else "a"
+        return f"{article} {noun}"
+    plural = noun + ("es" if noun.endswith(("s", "x", "z", "ch", "sh")) else "s")
+    return f"{n} {plural}"
+
+
+def _town_tally(features: list) -> str:
+    """A short building/house tally, e.g. '3 towers, a cafe, 2 districts'."""
+    counts: dict[str, int] = {}
+    order: list[str] = []
+    for f in features:
+        if f.wish_id == "genesis":
+            continue
+        if f.tool == "place_structure":
+            kind = f.args.get("kind", "building")
+        elif f.tool == "build_district":
+            kind = "district"
+        else:
+            continue
+        if kind not in counts:
+            order.append(kind)
+        counts[kind] = counts.get(kind, 0) + 1
+    if not counts:
+        return ""
+    bits = [_count_phrase(kind, counts[kind]) for kind in order[:_MAX_TALLY_KINDS]]
+    if len(order) > _MAX_TALLY_KINDS:
+        bits.append("more")
+    return ", ".join(bits)
+
+
 def summarize(world: Any) -> str:
     features = list(getattr(world, "features", ()) or ())
-    parts: list[str] = [f"epoch {getattr(world, 'epoch', 0)}"]
+
+    # The town — where the god should keep building (v1.2 town mode).
+    lat, lon = town_center(world)
+    name = town_name(lat, lon)
+    tally = _town_tally(features)
+    town_line = f"The town of {name} stands near ({round(lat)},{round(lon)})"
+    town_line += f": {tally}." if tally else "; nothing built yet — start it here."
+
+    parts: list[str] = [town_line, f"epoch {getattr(world, 'epoch', 0)}"]
 
     # terrain
     raised = [f for f in features if f.tool == "raise_terrain"]

engine/tools.py

@@ -1,4 +1,4 @@
-"""GODSEED tool DSL — the single source of truth for the 9-tool surface.
+"""GODSEED tool DSL — the single source of truth for the 11-tool surface.
 
 Spec is data (TOOLS); validation is `validate_call`. Semantics per the
 architecture contract:
@@ -11,6 +11,7 @@ architecture contract:
 
 `place_water` constraints: kind "stream" needs 2..5 path waypoints and takes
 no radius; kind "pool" uses path[0] as its center and requires radius_deg.
+`place_road` takes a path of 2..6 [lat,lon] waypoints (a paved surface spline).
 
 Pure stdlib. Other engine modules (and the mind's prompt builder) import this.
 """
@@ -50,7 +51,7 @@ class PathSpec:
 FLORA_KINDS = ("trees", "glowgrass", "mushrooms", "vines", "flowers", "reeds")
 STRUCTURE_KINDS = (
     "lighthouse", "monolith", "shrine", "village", "beacon", "arch",
-    "tower", "warehouse", "cafe",
+    "tower", "warehouse", "cafe", "bank", "market", "house",
 )
 WATER_KINDS = ("stream", "pool")
 WEATHER_KINDS = ("clear", "rain", "snow", "embers", "mist", "storm")
@@ -115,6 +116,16 @@ TOOLS: dict[str, dict[str, Any]] = {
         "count": NumberSpec(1, 12, integer=True),
         "hue": NumberSpec(0, 360),
     },
+    "build_district": {
+        "lat": NumberSpec(*LAT_RANGE),
+        "lon": NumberSpec(*LON_RANGE),
+        "radius_deg": NumberSpec(2, 15),
+        "density": NumberSpec(0, 1),
+        "hue": NumberSpec(0, 360),
+    },
+    "place_road": {
+        "path": PathSpec(6),  # 2..6 [lat,lon] waypoints
+    },
 }
 
 TOOL_NAMES: tuple[str, ...] = tuple(TOOLS.keys())
@@ -236,6 +247,31 @@ def _validate_place_water(args: dict):
     return {"kind": "pool", "path": points[:1], "radius_deg": radius, "hue": hue}, None
 
 
+def _validate_place_road(args: dict):
+    """A road is a paved surface spline through 2..6 [lat,lon] waypoints.
+
+    Path handling mirrors place_water (a flat [lat, lon] pair is wrapped; extra
+    waypoints past the max are clamped off) but a road always needs at least two
+    points — there is no single-point form.
+    """
+    spec = TOOLS["place_road"]
+    raw_path = args.get("path")
+    if not isinstance(raw_path, (list, tuple)) or not raw_path:
+        return None, "rejected: road needs path [[lat,lon],...] (2..6 points)"
+    # a flat [lat, lon] pair instead of [[lat, lon]]
+    if not isinstance(raw_path[0], (list, tuple, dict)):
+        raw_path = [raw_path]
+    points = []
+    for p in list(raw_path)[: spec["path"].max_points]:  # extra waypoints clamped off
+        pt = _coerce_point(p)
+        if pt is None:
+            return None, "rejected: bad waypoint in path (each is [lat, lon])"
+        points.append(pt)
+    if len(points) < 2:
+        return None, "rejected: road needs 2..6 waypoints"
+    return {"path": points}, None
+
+
 def validate_call(tool: Any, args: Any) -> tuple[Optional[dict], Optional[str]]:
     """Validate one tool call. Returns (canonical_args, None) or (None, rejection).
 
@@ -250,6 +286,8 @@ def validate_call(tool: Any, args: Any) -> tuple[Optional[dict], Optional[str]]:
         return None, "rejected: args must be an object"
     if tool == "place_water":
         return _validate_place_water(args)
+    if tool == "place_road":
+        return _validate_place_road(args)
 
     out: dict[str, Any] = {}
     for name, spec in TOOLS[tool].items():
@@ -270,6 +308,11 @@ def validate_call(tool: Any, args: Any) -> tuple[Optional[dict], Optional[str]]:
     return out, None
 
 
+# Per-tool minimum path length (place_water's pool form accepts a single
+# center point; place_road always needs at least two waypoints).
+_PATH_MIN_POINTS: dict[str, int] = {"place_water": 1, "place_road": 2}
+
+
 def as_dict() -> dict:
     """Plain-JSON view of the tool spec (handy for prompts / grammar builders)."""
     out: dict[str, dict] = {}
@@ -287,10 +330,13 @@ def as_dict() -> dict:
                 spec_out[name] = {"type": "string", "max_len": spec.max_len}
             elif isinstance(spec, PathSpec):
                 spec_out[name] = {
-                    "type": "path", "min_points": 1, "max_points": spec.max_points,
+                    "type": "path",
+                    "min_points": _PATH_MIN_POINTS.get(tool, 1),
+                    "max_points": spec.max_points,
                     "point": "[lat, lon]",
                 }
         out[tool] = spec_out
     out["place_water"]["radius_deg"]["note"] = "pool only"
     out["place_water"]["path"]["note"] = "stream: 2..5 waypoints; pool: path[0] is center"
+    out["place_road"]["path"]["note"] = "2..6 waypoints; a paved road laid on the surface"
     return out

engine/world.py

@@ -98,6 +98,10 @@ def _observation(feature: Feature) -> str:
         return f"ok: wish inscribed in {a['style']}"
     if t == "spawn_life":
         return f"ok: {a['count']} {a['kind']} stirring at {_coord(a)}"
+    if t == "build_district":
+        return f"ok: a district rises near {_coord(a)}"
+    if t == "place_road":
+        return f"ok: a road laid through {len(a['path'])} points"
     return "ok"  # pragma: no cover — every known tool is handled above
 
 

mind/__init__.py

@@ -1,7 +1,7 @@
 """GODSEED mind — Agent C.
 
 The Mind interprets a wish, narrates a short Reading aloud, then runs a
-grammar-constrained plan-act-observe loop over the engine's 9-tool DSL.
+grammar-constrained plan-act-observe loop over the engine's 11-tool DSL.
 It never computes geometry and never owns world state (the "her" pattern):
 the deterministic engine clamps, executes, and records every act.
 

mind/grammar.gbnf

@@ -19,7 +19,7 @@ thought-kv ::= "\"thought\"" ws ":" ws thought-string
 call-kv    ::= "\"call\"" ws ":" ws "{" ws "\"tool\"" ws ":" ws tool-name ws "," ws "\"args\"" ws ":" ws args-object ws "}"
 done-kv    ::= "\"done\"" ws ":" ws "true" ws "," ws "\"epitaph\"" ws ":" ws epitaph-string
 
-tool-name ::= "\"raise_terrain\"" | "\"lower_terrain\"" | "\"spawn_flora\"" | "\"place_structure\"" | "\"place_water\"" | "\"set_weather\"" | "\"set_sky\"" | "\"inscribe_wish\"" | "\"spawn_life\""
+tool-name ::= "\"raise_terrain\"" | "\"lower_terrain\"" | "\"spawn_flora\"" | "\"place_structure\"" | "\"place_water\"" | "\"set_weather\"" | "\"set_sky\"" | "\"inscribe_wish\"" | "\"spawn_life\"" | "\"build_district\"" | "\"place_road\""
 
 args-object ::= "{" ws ( member ( ws "," ws member ){0,11} )? ws "}"
 member      ::= key-string ws ":" ws value

mind/mock_scripts.py

@@ -5,7 +5,7 @@ a short turn list (calls + a done turn), with coordinates, hues, and a few
 phrasings varied by a seed derived from the wish text (crc32 — stable across
 processes, unlike hash()). Same wish in, same plan out: demos replay exactly.
 
-Across the category library every one of the 9 tools appears, so a varied
+Across the category library every one of the 11 tools appears, so a varied
 demo session exercises the full DSL. All numbers are kept inside the engine's
 clamp ranges; all thoughts <=160 chars; all epitaphs <=120; inscriptions <=90.
 
@@ -367,50 +367,123 @@ def _village(wish: str, rng: random.Random, mood: str) -> dict:
 
 
 def _city(wish: str, rng: random.Random, mood: str) -> dict:
+    # Everything clusters TIGHT around one anchor — a town you build up close,
+    # not specks scattered across a sphere (town mode, v1.2).
     lat, lon = _anchor(rng)
     glow_hue = _r1(rng, 200, 280)
     warm_hue = _r1(rng, 30, 50)
     reading = (
-        "A city, then — the big wish, the brave one. I will raise a tower to "
-        "hold the night's light, lay a long warehouse at its foot, set a cafe "
-        "to keep one window warm, and let carts run the streets between them."
+        "A city, then — the big wish, the brave one. I will lay a district "
+        "where the town already stands, raise a tower over it, a warehouse and "
+        "a cafe beside, and run a road and its carts between them."
     )
     return {
         "reading": reading,
         "turns": [
             _call(
-                "Bedrock first; tall things need deep shoulders.",
-                "raise_terrain",
-                lat=lat, lon=lon, radius_deg=_r1(rng, 8, 12),
-                height=_r2(rng, 0.03, 0.05), roughness=0.4,
+                "First a whole district — houses and footpaths in one breath.",
+                "build_district",
+                lat=lat, lon=lon, radius_deg=_r1(rng, 6, 12),
+                density=_r2(rng, 0.6, 0.9), hue=warm_hue,
             ),
             _call(
-                "The tower, slender, its rooftop light slow-pulsing.",
+                "The tower over it, slender, its rooftop light slow-pulsing.",
                 "place_structure",
-                lat=lat, lon=lon, kind="tower",
-                scale=_r2(rng, 1.4, 1.9), hue=glow_hue,
+                lat=_clamp_lat(lat + 1), lon=_wrap_lon(lon + 1),
+                kind="tower", scale=_r2(rng, 1.4, 1.9), hue=glow_hue,
             ),
             _call(
                 "A warehouse at its foot, one great door glowing.",
                 "place_structure",
-                lat=_clamp_lat(lat - 2), lon=_wrap_lon(lon + 3),
+                lat=_clamp_lat(lat - 2), lon=_wrap_lon(lon + 2),
                 kind="warehouse", scale=_r2(rng, 1.0, 1.4), hue=_r1(rng, 36, 52),
             ),
             _call(
                 "A cafe to keep one window warm against all of it.",
                 "place_structure",
-                lat=_clamp_lat(lat + 2), lon=_wrap_lon(lon - 2),
+                lat=_clamp_lat(lat + 2), lon=_wrap_lon(lon - 1),
                 kind="cafe", scale=_r2(rng, 0.7, 1.0), hue=warm_hue,
             ),
+            _call(
+                "A road to bind them, paved and faintly lit.",
+                "place_road",
+                path=[
+                    [_clamp_lat(lat - 2), _wrap_lon(lon + 2)],
+                    [lat, lon],
+                    [_clamp_lat(lat + 2), _wrap_lon(lon - 1)],
+                ],
+            ),
             _call(
                 "Carts to thread the streets between them, slow and constant.",
                 "spawn_life",
-                lat=lat, lon=lon, radius_deg=_r1(rng, 8, 14),
+                lat=lat, lon=lon, radius_deg=_r1(rng, 6, 10),
                 kind="carts", count=rng.randint(6, 10), hue=warm_hue,
             ),
             _done(
                 "A city is only small lights agreeing to stay near each other.",
-                "A tower stands over its warehouse and cafe, and carts run the streets at dusk.",
+                "A district, a tower, a warehouse and cafe, a road and its carts — all in one place.",
+            ),
+        ],
+    }
+
+
+def _town(wish: str, rng: random.Random, mood: str) -> dict:
+    # The town-growth script: a district plus civic buildings (bank, market,
+    # house), a road, and carts — all clustered into one block, so the mock
+    # demo + headless shots show a real town densifying, not lone specks.
+    lat, lon = _anchor(rng)
+    warm_hue = _r1(rng, 28, 48)
+    stone_hue = _r1(rng, 200, 250)
+    reading = (
+        "A town wants growing, not founding anew. I will lay a fresh district "
+        "where the others stand, set a bank and a market at its heart, a house "
+        "on the corner, and a road to tie the block together."
+    )
+    return {
+        "reading": reading,
+        "turns": [
+            _call(
+                "A district first — a dozen small roofs and the paths between.",
+                "build_district",
+                lat=lat, lon=lon, radius_deg=_r1(rng, 6, 12),
+                density=_r2(rng, 0.6, 0.9), hue=warm_hue,
+            ),
+            _call(
+                "A bank at the heart, stone-faced and certain.",
+                "place_structure",
+                lat=_clamp_lat(lat + 1), lon=_wrap_lon(lon + 1),
+                kind="bank", scale=_r2(rng, 0.9, 1.3), hue=stone_hue,
+            ),
+            _call(
+                "A market beside it, its awnings warm at dusk.",
+                "place_structure",
+                lat=_clamp_lat(lat - 1), lon=_wrap_lon(lon + 2),
+                kind="market", scale=_r2(rng, 0.8, 1.1), hue=warm_hue,
+            ),
+            _call(
+                "One house on the corner, a lamp in its window.",
+                "place_structure",
+                lat=_clamp_lat(lat + 2), lon=_wrap_lon(lon - 1),
+                kind="house", scale=_r2(rng, 0.7, 1.0), hue=warm_hue,
+            ),
+            _call(
+                "A road to tie the block to the rest of the town.",
+                "place_road",
+                path=[
+                    [_clamp_lat(lat + 2), _wrap_lon(lon - 1)],
+                    [lat, lon],
+                    [_clamp_lat(lat - 1), _wrap_lon(lon + 2)],
+                ],
+            ),
+            _call(
+                "Lantern-carts to walk the new street home.",
+                "spawn_life",
+                lat=lat, lon=lon, radius_deg=_r1(rng, 5, 9),
+                kind="carts", count=rng.randint(3, 6), hue=warm_hue,
+            ),
+            _done(
+                "A town grows the way moss does — outward, and toward the light.",
+                "A new block stands by the others: a district, a bank, a market, a house, a lit road.",
             ),
         ],
     }
@@ -580,8 +653,9 @@ def _default(wish: str, rng: random.Random, mood: str) -> dict:
 _CATEGORIES: tuple[tuple[re.Pattern[str], object], ...] = (
     (re.compile(r"\b(mushrooms?|fungus|fungi|spores?)\b", re.I), _mushroom),
     (re.compile(r"\b(lighthouses?|beacons?|lamps?|ships?|sailors?|harbou?rs?|light)\b", re.I), _lighthouse),
+    (re.compile(r"\b(towns?|districts?|neighbou?rhoods?|quarters?|suburbs?|blocks?|streets?|roads?|banks?|markets?|marketplaces?)\b", re.I), _town),
     (re.compile(r"\b(cit(?:y|ies)|towers?|skyscrapers?|warehouses?|caf[eé]s?|cafeterias?|cars?|carts?|traffic|downtown|metropolis|buildings?)\b", re.I), _city),
-    (re.compile(r"\b(villages?|homes?|houses?|hearths?|towns?|kettles?|people|friends?|family)\b", re.I), _village),
+    (re.compile(r"\b(villages?|homes?|houses?|hearths?|kettles?|people|friends?|family)\b", re.I), _village),
     (re.compile(r"\b(seas?|oceans?|lakes?|rivers?|streams?|water|tides?|waves?|shores?|pools?)\b", re.I), _water),
     (re.compile(r"\b(mountains?|peaks?|hills?|cliffs?|summits?|crags?|valleys?)\b", re.I), _mountain),
     (re.compile(r"\b(forests?|trees?|groves?|woods?|firefl\w*|gardens?|meadows?|flowers?|blooms?)\b", re.I), _forest),

mind/prompts.py

@@ -44,6 +44,8 @@ TOOL_ORDER: tuple[str, ...] = (
     "set_sky",
     "inscribe_wish",
     "spawn_life",
+    "build_district",
+    "place_road",
 )
 
 # DEVIATION: vendored copy of the engine/tools.py spec table (mirrors the
@@ -66,7 +68,7 @@ _VENDORED_TOOL_SPECS: dict[str, dict[str, str]] = {
     },
     "place_structure": {
         "lat": "-85..85", "lon": "-180..180",
-        "kind": "lighthouse|monolith|shrine|village|beacon|arch|tower|warehouse|cafe",
+        "kind": "lighthouse|monolith|shrine|village|beacon|arch|tower|warehouse|cafe|bank|market|house",
         "scale": "0.5..2.0", "hue": "0..360",
     },
     "place_water": {
@@ -88,6 +90,13 @@ _VENDORED_TOOL_SPECS: dict[str, dict[str, str]] = {
         "lat": "-85..85", "lon": "-180..180", "radius_deg": "1..20",
         "kind": "carts|birds|fireflies", "count": "1..12 (integer)", "hue": "0..360",
     },
+    "build_district": {
+        "lat": "-85..85", "lon": "-180..180", "radius_deg": "2..15",
+        "density": "0..1", "hue": "0..360",
+    },
+    "place_road": {
+        "path": "[[lat,lon] x2..6] (a paved road laid on the surface, beside the town)",
+    },
 }
 
 
@@ -113,7 +122,7 @@ TOOL_SPECS, TOOL_SPECS_FROM_ENGINE = _load_tool_specs()
 
 
 def tool_names() -> tuple[str, ...]:
-    """The 9 legal tool names, in canonical order."""
+    """The 11 legal tool names, in canonical order."""
     return TOOL_ORDER
 
 
@@ -151,6 +160,12 @@ def render_tool_docs(specs: dict[str, dict] | None = None) -> str:
         "path with ONE [lat,lon] center plus radius_deg. There is no sea tool — "
         "for great waters, lower the land and lay several pools and streams."
     )
+    lines.append(
+        "Town: build_district drops a whole neighborhood (houses + footpaths) in "
+        "ONE act — reach for it when a wish asks for a city, a quarter, or many "
+        "homes. place_road (2..6 [lat,lon] waypoints) is a paved street, NOT a "
+        "stream — use it to connect buildings to the town."
+    )
     return "\n".join(lines)
 
 
@@ -161,12 +176,19 @@ def render_tool_docs(specs: dict[str, dict] | None = None) -> str:
 PERSONA = """You are the god of one small planet. You are ancient, patient, and kind.
 You speak rarely and plainly, the way stone speaks. Terse, poetic, never cute.
 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 nine tools exist —
+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."""
+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."""
 
 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

tests/test_engine.py

@@ -24,7 +24,7 @@ from engine.queue_worker import (
     QueueFull,
     QueueWorker,
 )
-from engine.summary import summarize
+from engine.summary import GENESIS_MONOLITH, summarize, town_center, town_name
 from engine.tools import TOOL_NAMES, validate_call
 from engine.world import World
 
@@ -536,7 +536,7 @@ def test_summary_stays_under_cap_with_many_features():
 # ------------------------------------------------------------------------ misc
 
 
-def test_tool_surface_is_exactly_nine():
+def test_tool_surface_is_exactly_eleven():
     assert TOOL_NAMES == (
         "raise_terrain",
         "lower_terrain",
@@ -547,6 +547,8 @@ def test_tool_surface_is_exactly_nine():
         "set_sky",
         "inscribe_wish",
         "spawn_life",
+        "build_district",
+        "place_road",
     )
 
 
@@ -624,3 +626,170 @@ def test_spawn_life_missing_arg_rejected():
         {"lat": 0, "lon": 0, "radius_deg": 5, "kind": "birds", "hue": 100},
     )
     assert args is None and err == "rejected: missing arg 'count'"
+
+
+# --------------------------------------------------------------------- town mode
+
+
+def test_build_district_valid_and_clamped():
+    world = make_world()
+    feature, obs = world.apply(
+        "w_000001",
+        0,
+        {"tool": "build_district",
+         "args": {"lat": 14, "lon": 38, "radius_deg": 99, "density": 9, "hue": 720}},
+    )
+    assert feature is not None
+    assert feature.args == {
+        "lat": 14.0,
+        "lon": 38.0,
+        "radius_deg": 15.0,   # clamped to build_district max
+        "density": 1.0,       # clamped to max
+        "hue": 360.0,
+    }
+    assert obs == "ok: a district rises near (14,38)"
+
+
+def test_build_district_radius_clamps_up_and_missing_arg_rejected():
+    args, err = validate_call(
+        "build_district",
+        {"lat": 0, "lon": 0, "radius_deg": 0.5, "density": 0.4, "hue": 200},
+    )
+    assert err is None
+    assert args["radius_deg"] == 2.0  # clamped up to min
+
+    args, err = validate_call(
+        "build_district", {"lat": 0, "lon": 0, "density": 0.4, "hue": 200}
+    )
+    assert args is None and err == "rejected: missing arg 'radius_deg'"
+
+
+def test_place_road_valid_and_clamped():
+    world = make_world()
+    # 7 waypoints truncated to 6; out-of-range coords clamped
+    feature, obs = world.apply(
+        "w_000001",
+        0,
+        {"tool": "place_road",
+         "args": {"path": [[200, -999], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6]]}},
+    )
+    assert feature is not None
+    assert len(feature.args["path"]) == 6
+    assert feature.args["path"][0] == [85.0, -180.0]
+    assert feature.args == {"path": [[85.0, -180.0], [1.0, 1.0], [2.0, 2.0],
+                                     [3.0, 3.0], [4.0, 4.0], [5.0, 5.0]]}
+    assert obs == "ok: a road laid through 6 points"
+
+
+def test_place_road_flat_pair_and_dict_points():
+    # a flat [lat, lon] pair is NOT enough — a road needs two waypoints
+    args, err = validate_call("place_road", {"path": [12, 30]})
+    assert args is None and err == "rejected: road needs 2..6 waypoints"
+
+    # dict waypoints are accepted (like place_water)
+    args, err = validate_call(
+        "place_road", {"path": [{"lat": 10, "lon": 20}, {"lat": 12, "lon": 22}]}
+    )
+    assert err is None and args == {"path": [[10.0, 20.0], [12.0, 22.0]]}
+
+
+def test_place_road_rejects_missing_and_short_path():
+    args, err = validate_call("place_road", {})
+    assert args is None and "road needs path" in err
+
+    args, err = validate_call("place_road", {"path": [[10, 20]]})
+    assert args is None and err == "rejected: road needs 2..6 waypoints"
+
+    args, err = validate_call("place_road", {"path": [[10, 20], ["x", "y"]]})
+    assert args is None and "bad waypoint" in err
+
+
+def test_new_civic_structure_kinds_accepted():
+    world = make_world()
+    for kind in ("bank", "market", "house"):
+        feature, obs = world.apply(
+            "w_000001",
+            0,
+            {"tool": "place_structure",
+             "args": {"lat": 5, "lon": 5, "kind": kind, "scale": 1.0, "hue": 40}},
+        )
+        assert feature is not None, kind
+        assert feature.args["kind"] == kind
+        assert obs == f"ok: {kind} placed at (5,5)"
+
+
+def test_town_center_genesis_fallback():
+    # A fresh genesis world has no non-genesis town tools -> monolith fallback.
+    world = make_world()
+    assert town_center(world) == GENESIS_MONOLITH == (14.0, 38.0)
+    # Terrain / flora alone do NOT anchor the town (only structures + districts).
+    world.apply("w_000001", 0, ok_raise(50, -50))
+    world.apply("w_000001", 1, {"tool": "spawn_flora",
+                "args": {"lat": 60, "lon": 60, "radius_deg": 8, "kind": "trees",
+                         "density": 0.5, "hue": 120}})
+    assert town_center(world) == GENESIS_MONOLITH
+
+
+def test_town_center_unit_vector_centroid():
+    world = make_world()
+    world.apply("w_000001", 0, {"tool": "place_structure",
+                "args": {"lat": 10, "lon": 20, "kind": "tower", "scale": 1.0, "hue": 200}})
+    world.apply("w_000001", 1, {"tool": "build_district",
+                "args": {"lat": 20, "lon": 40, "radius_deg": 8, "density": 0.6, "hue": 40}})
+    # Unit-vector mean of (10,20) and (20,40), renormalized (computed offline).
+    assert town_center(world) == (15.2206, 29.7632)
+
+
+def test_town_center_excludes_genesis_monolith():
+    # The genesis monolith (14,38) is NOT counted; one built tower defines the town.
+    world = make_world()
+    world.apply("w_000001", 0, {"tool": "place_structure",
+                "args": {"lat": -30, "lon": 100, "kind": "house", "scale": 1.0, "hue": 30}})
+    lat, lon = town_center(world)
+    assert round(lat) == -30 and round(lon) == 100
+
+
+def test_town_name_is_deterministic():
+    # Same rounded center -> same name; from the curated pool.
+    from engine.summary import TOWN_NAMES
+    n1 = town_name(14.0, 38.0)
+    n2 = town_name(14.49, 37.51)  # rounds to the same (14, 38)
+    assert n1 == n2 == "Emberlyn"
+    assert n1 in TOWN_NAMES
+    # The genesis-fallback town is always named the same.
+    assert town_name(*GENESIS_MONOLITH) == "Emberlyn"
+
+
+def test_summary_names_the_town_and_tally():
+    world = make_world()
+    wish = "w_000001"
+    world.apply(wish, 0, {"tool": "place_structure",
+                "args": {"lat": 14, "lon": 38, "kind": "tower", "scale": 1.4, "hue": 200}})
+    world.apply(wish, 1, {"tool": "place_structure",
+                "args": {"lat": 15, "lon": 39, "kind": "tower", "scale": 1.4, "hue": 200}})
+    world.apply(wish, 2, {"tool": "place_structure",
+                "args": {"lat": 13, "lon": 37, "kind": "cafe", "scale": 0.9, "hue": 40}})
+    world.apply(wish, 3, {"tool": "build_district",
+                "args": {"lat": 14, "lon": 38, "radius_deg": 8, "density": 0.7, "hue": 30}})
+    text = world.summary()
+    assert len(text) < 600
+    assert "The town of" in text
+    assert "stands near" in text
+    assert "2 towers" in text
+    assert "a cafe" in text
+    assert "a district" in text
+    # The town line leads the summary (steering: where to keep building).
+    assert text.startswith("The town of")
+
+
+def test_summary_town_line_survives_truncation():
+    world = make_world()
+    for i in range(40):
+        wish = f"w_{i + 1:06d}"
+        world.apply(wish, 0, {"tool": "place_structure",
+                    "args": {"lat": i % 60 - 30, "lon": (i * 9) % 300 - 150,
+                             "kind": "house", "scale": 1.0, "hue": i * 8 % 360}})
+        world.record_epitaph("a long epitaph about the slow work of small gods " + "x" * 60)
+    text = world.summary()
+    assert len(text) < 600
+    assert text.startswith("The town of")

tests/test_mind.py

@@ -1,6 +1,6 @@
 """Tests for the GODSEED mind (Agent C) — mock backend only.
 
-Covers: trace shape for diverse wishes, all-8-tool coverage across the
+Covers: trace shape for diverse wishes, all-11-tool coverage across the
 suite, emit event ordering, the malformed-JSON re-ask/skip path (via
 deliberately broken fake backends), moderation default-deny, determinism,
 and grammar-file sanity. No model weights, no network, no asyncio plugins
@@ -43,7 +43,7 @@ DIVERSE_WISHES = {
     ),
 }
 
-# Wishes chosen so the union of their mock scripts spans all 9 tools.
+# Wishes chosen so the union of their mock scripts spans all 11 tools.
 COVERAGE_WISHES = [
     "i wish for a mountain to watch over the valley",   # raise, weather, inscribe
     "a quiet sea under patient stars",                  # lower, water, sky, life(birds)
@@ -51,7 +51,8 @@ COVERAGE_WISHES = [
     "a lighthouse for everyone still at sea",           # raise, structure, sky
     "let mushrooms sing beneath the dark",              # flora, structure, weather, sky
     "a storm to end all storms",                        # sky, weather, flora
-    "a bright city of towers and warehouses and cafes", # raise, structure(new kinds), life(carts)
+    "a bright city of towers and warehouses and cafes", # district, structure(new kinds), road, life(carts)
+    "a new town district by the market",                # district, structure(bank/market/house), road, life
     "blorptangle the seventh hum",                      # flora, structure, inscribe
 ]
 
@@ -177,12 +178,14 @@ def test_call_turns_valid(label):
     assert [t["call"] for t in call_turns] == calls
 
 
-def test_all_nine_tools_covered_across_suite():
+def test_all_eleven_tools_covered_across_suite():
     used: set[str] = set()
     for wish in COVERAGE_WISHES:
         trace, _events, _calls = run_grant(wish)
         used |= {t["call"]["tool"] for t in trace["turns"] if t["call"]}
     assert used == TOOLS, f"missing tools: {TOOLS - used}"
+    # The town-mode tools must be among them.
+    assert {"build_district", "place_road"} <= used
 
 
 def test_city_script_uses_new_kinds_and_spawn_life():
@@ -213,6 +216,57 @@ def test_city_script_uses_new_kinds_and_spawn_life():
         assert err is None and obj["call"]["tool"] == turn["call"]["tool"]
 
 
+def test_town_script_grows_one_clustered_town():
+    """The town-growth script lays a district, civic buildings (bank/market/
+    house), a road, and carts — all clustered near one anchor — and every call
+    turn re-parses cleanly through parse_turn."""
+    trace, _events, _calls = run_grant("a new town district by the market")
+    call_turns = [t for t in trace["turns"] if t["call"] is not None]
+    tools_used = {t["call"]["tool"] for t in call_turns}
+    assert "build_district" in tools_used
+    assert "place_road" in tools_used
+
+    structure_kinds = {
+        t["call"]["args"]["kind"]
+        for t in call_turns
+        if t["call"]["tool"] == "place_structure"
+    }
+    assert {"bank", "market", "house"} <= structure_kinds
+
+    # A district call carries exactly its spec'd args.
+    district = next(t["call"]["args"] for t in call_turns
+                    if t["call"]["tool"] == "build_district")
+    assert set(district) == {"lat", "lon", "radius_deg", "density", "hue"}
+
+    # A road is a path of 2..6 [lat,lon] waypoints.
+    road = next(t["call"]["args"] for t in call_turns
+                if t["call"]["tool"] == "place_road")
+    assert set(road) == {"path"}
+    assert 2 <= len(road["path"]) <= 6
+    for pt in road["path"]:
+        assert isinstance(pt, list) and len(pt) == 2
+
+    # Everything clusters: all anchored coords sit within a few degrees of the
+    # town's center (a town you build up close, not specks on a sphere).
+    coords = []
+    for t in call_turns:
+        args = t["call"]["args"]
+        if "lat" in args and "lon" in args:
+            coords.append((args["lat"], args["lon"]))
+    coords.extend(tuple(pt) for pt in road["path"])
+    assert coords, "town script should anchor calls at coordinates"
+    clat = sum(c[0] for c in coords) / len(coords)
+    clon = sum(c[1] for c in coords) / len(coords)
+    for lat, lon in coords:
+        assert abs(lat - clat) <= 6 and abs(lon - clon) <= 6, (lat, lon)
+
+    # Every emitted call turn is valid against the turn parser/grammar shape.
+    for turn in call_turns:
+        rendered = json.dumps({"thought": turn["thought"], "call": turn["call"]})
+        obj, err = parse_turn(rendered)
+        assert err is None and obj["call"]["tool"] == turn["call"]["tool"]
+
+
 def test_spawn_life_scripts_parse_cleanly():
     """Each life kind appears in some mock script and round-trips through
     parse_turn without error."""

tools/shot.mjs

@@ -1,6 +1,8 @@
 // GODSEED — headless screenshot harness (adapted from glassblower tools/shot.mjs).
-// Serves web/ itself on a free port (8200-8299), drives the mock world through
-// deterministic seeks, and saves shots to tools/shots/.
+// Town Mode suite: the DEFAULT load is now a CLOSE TOWN VIEW (SimCity feel), the
+// full planet is the dramatic "behold the world" reveal. Serves web/ itself on a
+// free port (8200-8299), drives the mock world through deterministic seeks, and
+// saves shots to tools/shots/.
 //
 //   node tools/shot.mjs            # full suite
 //   node tools/shot.mjs --base http://localhost:8234   # reuse a running server
@@ -83,64 +85,81 @@ async function open(url) {
 
 async function shot(name) {
   await page.screenshot({ path: path.join(OUT, name) });
-  const s = await page.evaluate(() => window.__godseed.stats());
-  console.log(`  📸 ${name}  ${JSON.stringify(s)}`);
+  const s = await page.evaluate(() => {
+    const tc = window.__godseed.townCenter?.();
+    return { ...window.__godseed.stats(), mode: window.__godseed.rig?.mode,
+      tc: tc ? `${tc.lat.toFixed(1)},${tc.lon.toFixed(1)}` : "?" };
+  });
+  console.log(`  📸 ${name}  mode=${s.mode} dist=${s.camDist} tc=${s.tc} sky=${s.sky}`);
 }
 
 // ------------------------------------------------------------------ suite
 
-// 1 · genesis idle — the zero-GPU landing moment (void sky, monolith, ring)
-await open("index.html?mock=1&upto=0&static=1");
+// 1 · DEFAULT load — the close TOWN view (SimCity feel: a town you stand over,
+//     dense with houses, civic buildings, roads — NOT a tiny planet).
+await open("index.html?mock=1&static=1");
+await page.evaluate(() => { window.__godseed.tick(6); }); // settle camera + grow-ins
+await shot("town-01-default.png");
+
+// 2 · a dense DISTRICT close-up — lean the gaze right into the south block so the
+//     gabled houses + footpaths + civic crown read large at the close zoom.
 await page.evaluate(() => {
-  window.__godseed.setCamera(0.55, 1.22, 6.4);
-  window.__godseed.tick(6); // settle camera + ring fade-in + twinkle
+  window.__godseed.gazeLatLon(11, 36, 30); // the w_000003 quarter
+  window.__godseed.tick(5);
 });
-await shot("01-genesis-idle.png");
+await shot("town-02-district-close.png");
 
-// 2 · full world, wide — ten wishes deep under aurora
-await open("index.html?mock=1&static=1");
+// 3 · roads + civic mix at the square — frame the bank/market/tower heart.
 await page.evaluate(() => {
-  window.__godseed.setCamera(2.2, 1.05, 6.8);
-  window.__godseed.tick(8);
+  window.__godseed.gazeLatLon(14, 38, 30);
+  window.__godseed.tick(5);
 });
-await shot("02-world-aurora-wide.png");
+await shot("town-03-square.png");
+
+// 4 · BEHOLD THE WORLD — pull back to the full planet; the town is one warm
+//     patch ringed by the orbiting inscription on a whole shared world.
+await page.evaluate(() => { window.__godseed.beholdWorld(); window.__godseed.tick(9); });
+await shot("town-04-behold-world.png");
 
-// 3 · terrain rising mid-wish — run the feed, freeze during raise_terrain
+// 5 · return to the town (the toggle flips back to the close view).
+await page.evaluate(() => { window.__godseed.beholdWorld(); window.__godseed.tick(8); });
+await shot("town-05-return.png");
+
+// 6 · a GRANTING moment, framed WITHIN the town — run the looping town-growth
+//     wish (a new quarter east of the square) and freeze mid-grant with the
+//     thought ticker live.
 await open("index.html?mock=1");
 await page.evaluate(() => {
-  window.__godseed.tick(2); // let the loop arm (cooldown 7s)…
-});
-await page.evaluate(() => {
-  // jump deterministically: run feed now and advance into the first delta
-  window.__godseed.resetTo(10);
+  window.__godseed.tick(2);          // let the loop arm
   window.__godseed.runFeedOnce();
-  window.__godseed.tick(16.2); // reading + first thought + raise_terrain delta mid-rise
+  window.__godseed.tick(15);          // reading → district + market + cafe deltas
 });
-await shot("03-terrain-rising.png");
-
-// 4 · flora bloom close-up — glowgrass spawning on the new fells
-await page.evaluate(() => { window.__godseed.tick(6.4); });
-await shot("04-flora-bloom.png");
+await shot("town-06-granting.png");
 
-// 5 · storm under the inscription ring — end of the feed wish
-await page.evaluate(() => { window.__godseed.tick(14); window.__godseed.gazeWide(); window.__godseed.tick(3); });
-await shot("05-storm-granted.png");
+// 7 · the same wish a beat later — road + carts land, the new quarter is joined.
+await page.evaluate(() => { window.__godseed.tick(9); });
+await shot("town-07-granted.png");
 
-// 6 · inscription orbit close-up over the village (gold hour)
-await open("index.html?mock=1&static=1&sky=gold&moons=1&weather=clear");
+// 8 · the DESCENT within the town — swoop down over the just-granted quarter.
 await page.evaluate(() => {
-  window.__godseed.gazeLatLon(8, 24, 60);
-  window.__godseed.tick(5);
+  window.__godseed.descend(15, 43, 13); // dive over the new market quarter
+  window.__godseed.tick(5.4);           // mid-glide, just above the surface
 });
-await shot("06-inscription-gaze.png");
+await shot("town-08-descent.png");
+
+// 9 · genesis-only world — fallback townCenter = the monolith, framed up close.
+await open("index.html?mock=1&upto=0&static=1");
+await page.evaluate(() => { window.__godseed.tick(6); });
+await shot("town-09-genesis.png");
 
-// 7 · Genesis Log — list + replay mid-flight
+// 10 · Genesis Log — replay the town-build wish (w_000002): the district + bank +
+//      market + tower + road rising, in the close town view.
 await open("book.html?mock=1");
 await page.evaluate(() => {
-  window.__godseed.replay("w_000005"); // the lighthouse wish
-  window.__godseed.tick(18);
+  window.__godseed.replay("w_000002");
+  window.__godseed.tick(20); // through the district + civic deltas
 });
-await shot("07-book-replay.png");
+await shot("town-10-book-replay.png");
 
 // ------------------------------------------------------------------ wrap
 if (errors.length) {

web/book.js

@@ -6,6 +6,11 @@ import { createPlanetApp } from "./planet/scene.js";
 import { buildWishScript, ScriptRunner } from "./planet/replay.js";
 import { latLonToDir, PLANET_R } from "./planet/util.js";
 
+// Re-anchor + frame the town heart from the current world.
+function syncTown() {
+  app.rig.setTownCenter(app.world.features);
+}
+
 const params = new URLSearchParams(location.search);
 const MOCK = params.has("mock");
 const qs = MOCK ? "?mock=1" : "";
@@ -128,7 +133,8 @@ function replayWish(trace, allFeatures) {
   const base = firstIdx === -1 ? allFeatures : allFeatures.slice(0, firstIdx);
   const features = mine.length ? mine : (trace.features ?? []);
   app.world.reset(base, app.simTime);
-  app.rig.release();
+  app.rig.setMode("town"); // replays begin in the close town view
+  syncTown();
 
   runner.handlers = {
     started: () => {},
@@ -148,6 +154,9 @@ function replayWish(trace, allFeatures) {
     },
     delta: (e) => {
       const cue = app.world.applyFeature(e.feature, { animate: true, t: app.simTime });
+      if (e.feature.tool === "place_structure" || e.feature.tool === "build_district") {
+        syncTown(); // the town heart follows each new building during the replay
+      }
       if (cue.target) app.rig.gaze(cue.target.clone().multiplyScalar(PLANET_R), { hold: 4 });
       else if (cue.wide) app.rig.gaze(null, { hold: 3.5 });
       const dir = cue.target || featureDir(e.feature);
@@ -188,6 +197,7 @@ app.onTick((t) => runner.update(t));
     // world as it stands now (zero GPU, gorgeous by default). Count source is
     // unified with the landing page: epoch === number of granted wishes.
     app.world.reset(state.features, app.simTime);
+    syncTown(); // open the log over the close town view (matches the landing page)
     const granted = state.epoch ?? list.length;
     els.status.textContent = `epoch ${granted} · ${granted} ${granted === 1 ? "wish" : "wishes"} granted`;
 

web/index.html

@@ -30,9 +30,14 @@
     <p class="brand__tag">nine billion parameters&ensp;·&ensp;one shared world</p>
   </header>
 
-  <!-- epoch + Genesis Log -->
+  <!-- epoch + Genesis Log + behold toggle -->
   <nav class="almanac">
     <div class="almanac__epoch" id="epoch">Epoch —</div>
+    <button class="behold" id="beholdToggle" type="button" aria-pressed="false"
+            title="pull back to the whole world, or return to the town">
+      <span class="behold__label">behold the world</span>
+      <span class="behold__sigil" aria-hidden="true">↕</span>
+    </button>
     <a class="almanac__log" href="./book.html" id="logLink">Genesis Log&ensp;→</a>
   </nav>
 

web/main.js

@@ -4,7 +4,7 @@
 // The deterministic engine owns the facts; this file only performs them.
 import { createPlanetApp } from "./planet/scene.js";
 import { buildWishScript, ScriptRunner } from "./planet/replay.js";
-import { latLonToDir, PLANET_R, ordinal, clamp } from "./planet/util.js";
+import { latLonToDir, PLANET_R, ordinal, clamp, townCenter } from "./planet/util.js";
 
 const params = new URLSearchParams(location.search);
 const MOCK = params.has("mock");
@@ -27,6 +27,7 @@ const els = {
   send: document.getElementById("wishSend"),
   hint: document.getElementById("altarHint"),
   status: document.getElementById("status"),
+  behold: document.getElementById("beholdToggle"),
 };
 
 const HINT_DEFAULT = "the god grants one wish at a time";
@@ -168,6 +169,30 @@ if (els.epitaphDescend) {
   });
 }
 
+// Re-anchor the town heart from the current world (camera follows it as it
+// densifies). Called on every state load + world_delta.
+function syncTown() {
+  app.rig.setTownCenter(app.world.features);
+}
+
+// "behold the world ↕" — pull back to the full planet; "↻ return to the town" —
+// drop back into the close town view. Reflects the rig's current mode.
+function updateBeholdLabel() {
+  if (!els.behold) return;
+  const world = app.rig.mode === "world";
+  els.behold.classList.toggle("is-world", world);
+  els.behold.setAttribute("aria-pressed", world ? "true" : "false");
+  els.behold.querySelector(".behold__label").textContent =
+    world ? "return to the town" : "behold the world";
+}
+if (els.behold) {
+  els.behold.addEventListener("click", () => {
+    app.rig.beholdWorld();
+    updateBeholdLabel();
+  });
+  updateBeholdLabel();
+}
+
 const featuresByWish = (features, upto) => {
   if (upto == null) return features;
   const order = [];
@@ -206,6 +231,7 @@ async function bootLive() {
     const state = await res.json();
     stateVersion = state.world?.version ?? null;
     app.world.reset(state.world?.features ?? [], app.simTime);
+    syncTown(); // anchor the town heart, then frame it (the default close view)
     const epoch = state.world?.epoch ?? countWishes(state.world?.features ?? []);
     setEpoch(epoch, epoch);
     setQueue(state.queue?.length ?? 0);
@@ -293,8 +319,14 @@ async function bootLive() {
         if (m.feature) {
           stateVersion = stateVersion == null ? null : stateVersion + 1;
           const cue = app.world.applyFeature(m.feature, { animate: true, t: app.simTime });
+          // a new building shifts the town's heart — re-anchor before framing so
+          // the camera follows the town as it densifies (no-op for sky/weather).
+          if (m.feature.tool === "place_structure" || m.feature.tool === "build_district") {
+            syncTown();
+          }
           // gaze toward where the world is actually changing — the cue target is
           // the resolved surface point (refines inscriptions/structures by seed).
+          // In TOWN mode gaze() keeps this WITHIN the town zoom (never the far limb).
           if (cue.target) app.rig.gaze(cue.target.clone().multiplyScalar(PLANET_R), { hold: 5.5 });
           else if (cue.wide) app.rig.gaze(null, { hold: 4 });
           const dir = cue.target || featureDir(m.feature);
@@ -376,6 +408,7 @@ async function bootMock() {
   const baseFeatures = featuresByWish(state.world.features, UPTO);
   const baseEpoch = countWishes(baseFeatures);
   app.world.reset(baseFeatures, app.simTime);
+  syncTown();           // anchor + frame the town heart (the default close view)
   applyDevOverrides();
   setEpoch(baseEpoch, baseEpoch);
   els.status.textContent = MOCK ? "demo vision · ?mock=1" : "the god is dreaming · demo vision";
@@ -396,6 +429,9 @@ async function bootMock() {
     },
     delta: (e) => {
       const cue = app.world.applyFeature(e.feature, { animate: true, t: app.simTime });
+      if (e.feature.tool === "place_structure" || e.feature.tool === "build_district") {
+        syncTown(); // the town heart follows each new building
+      }
       if (cue.target) app.rig.gaze(cue.target.clone().multiplyScalar(PLANET_R), { hold: 4.5 });
       else if (cue.wide) app.rig.gaze(null, { hold: 3.5 });
       const dir = cue.target || featureDir(e.feature);
@@ -435,6 +471,7 @@ async function bootMock() {
       // reset to the base world, then perform the wish again — determinism on display
       if (app.world.features.length > baseFeatures.length) {
         app.world.reset(baseFeatures, t);
+        syncTown(); // back to the base town heart before the wish runs again
         setEpoch(baseEpoch, baseEpoch);
         tickerClear();
         tickerIdle();
@@ -502,7 +539,10 @@ window.__godseed = {
     app.rig.userHold = 0;
     app.rig.gaze(latLonToDir(lat, lon).multiplyScalar(PLANET_R), { hold });
   },
-  gazeWide: () => app.rig.release(),
+  gazeWide: () => { app.rig.setMode("world"); updateBeholdLabel(); },
+  setMode: (mode) => { app.rig.setMode(mode); updateBeholdLabel(); },
+  beholdWorld: () => { const m = app.rig.beholdWorld(); updateBeholdLabel(); return m; },
+  townCenter: () => townCenter(app.world.features),
   descend: (lat, lon, duration = 13) => {
     app.rig.setTerrain?.(app.world.terrain);
     app.rig.descend(latLonToDir(lat, lon).multiplyScalar(PLANET_R), { duration });

web/mock/feed.js

@@ -3,64 +3,62 @@
 // resets between loops so the same wish lands on the same world every time
 // (the renderer is a pure function of the feature list — this is the proof).
 //
-// The looping wish is a CITY wish so the live demo exercises the v1.1 City
-// Update end-to-end: a tower rising over a warehouse and cafe, then lantern
-// carts gliding the new street at dusk.
+// The looping wish is a TOWN-GROWTH wish so the live demo exercises the v1.2
+// Town Mode end-to-end: a fresh district + a market-square pair of civic
+// buildings, a paved road threaded back to the old square, and lantern-carts
+// running the new street at dusk — all rising BESIDE the existing town near
+// the heart at (14,38), never alone in the wilderness. This is the SimCity
+// unlock on display: one wish, a whole new block.
 
 export const FEED_WISH = {
   trace: {
-    wish_id: "w_000012",
-    text: "raise me a city — a tower, a warehouse, a cafe, and carts at dusk",
+    wish_id: "w_000007",
+    text: "grow the town — a new quarter east of the square, a market and an inn, a road back to it, and carts at dusk",
     moderation: { allowed: true, category: null },
     reading:
-      "A city, then — the big wish, the brave one. I will raise a shoulder of ground, " +
-      "set a tower to hold the night's light, lay a long warehouse at its foot, keep one " +
-      "cafe window warm, and let lantern-carts run the street between them at dusk.",
+      "Grow it, then — not scatter it. The town already keeps its lights near the square; " +
+      "this new quarter rises just east of it, a market to trade in and an inn to keep one " +
+      "window warm, a road laid back to the old heart so no house stands alone, and " +
+      "lantern-carts to run the new street home at dusk.",
     turns: [
       {
-        thought: "Ground first; a tower needs a shoulder to stand on.",
-        call: { tool: "raise_terrain", args: { lat: -10, lon: 128, radius_deg: 12, height: 0.05, roughness: 0.4 } },
-        observation: "ok: mountains risen at (-10,128)",
+        thought: "A new quarter, dense, just east of the square — beside the old town, not apart from it.",
+        call: { tool: "build_district", args: { lat: 15, lon: 43, radius_deg: 6, density: 0.8, hue: 35 } },
+        observation: "ok: a district rises near (15,43)",
       },
       {
-        thought: "The tower, slender, its rooftop light slow-pulsing over the dark.",
-        call: { tool: "place_structure", args: { lat: -10, lon: 128, kind: "tower", scale: 1.6, hue: 205 } },
-        observation: "ok: tower placed at (-10,128)",
+        thought: "A market at the new quarter's heart, to give it a reason to gather.",
+        call: { tool: "place_structure", args: { lat: 15, lon: 43, kind: "market", scale: 1.1, hue: 30 } },
+        observation: "ok: market placed at (15,43)",
       },
       {
-        thought: "A warehouse at its foot, one great door glowing.",
-        call: { tool: "place_structure", args: { lat: -12, lon: 126, kind: "warehouse", scale: 1.2, hue: 44 } },
-        observation: "ok: warehouse placed at (-12,126)",
+        thought: "An inn beside it — one warm window against the coming dark.",
+        call: { tool: "place_structure", args: { lat: 16, lon: 44, kind: "cafe", scale: 1.0, hue: 34 } },
+        observation: "ok: cafe placed at (16,44)",
       },
       {
-        thought: "A cafe to keep one window warm against all of it.",
-        call: { tool: "place_structure", args: { lat: -8, lon: 130, kind: "cafe", scale: 0.9, hue: 36 } },
-        observation: "ok: cafe placed at (-8,130)",
+        thought: "A road back to the old square, so the two quarters are one town.",
+        call: { tool: "place_road", args: { path: [[14, 38], [15, 41], [15, 43]] } },
+        observation: "ok: a road laid through 3 points",
       },
       {
-        thought: "A stream for the road to follow, and the carts to glide.",
-        call: { tool: "place_water", args: { kind: "stream", path: [[-16, 120], [-12, 126], [-8, 130], [-4, 136]], hue: 200 } },
-        observation: "ok: stream set toward (-4,136)",
+        thought: "Now the lantern-carts, gliding the new street home at dusk.",
+        call: { tool: "spawn_life", args: { lat: 15, lon: 42, radius_deg: 7, kind: "carts", count: 8, hue: 42 } },
+        observation: "ok: 8 carts stirring at (15,42)",
       },
-      {
-        thought: "Now the lantern-carts, gliding home at dusk.",
-        call: { tool: "spawn_life", args: { lat: -10, lon: 128, radius_deg: 9, kind: "carts", count: 8, hue: 42 } },
-        observation: "ok: 8 carts stirring at (-10,128)",
-      },
-      { thought: "A city is only small lights agreeing to stay near each other.", call: null, observation: "" },
+      { thought: "A town is only small lights agreeing to stay near each other.", call: null, observation: "" },
     ],
-    epitaph: "A tower stands over its warehouse and cafe, and carts run the streets at dusk.",
-    feature_ids: ["f_000036", "f_000037", "f_000038", "f_000039", "f_000040", "f_000041"],
+    epitaph: "A new quarter joins the square — market, inn, and a road between them; the carts run it home at dusk.",
+    feature_ids: ["f_000028", "f_000029", "f_000030", "f_000031", "f_000032"],
     model: "nemotron-3-nano (mock)",
     backend: "mock",
-    ms_total: 58210,
+    ms_total: 54120,
   },
   features: [
-    { id: "f_000036", wish_id: "w_000012", tool: "raise_terrain", args: { lat: -10, lon: 128, radius_deg: 12, height: 0.05, roughness: 0.4 }, seed: 1040806363, t: 1718201200.0 },
-    { id: "f_000037", wish_id: "w_000012", tool: "place_structure", args: { lat: -10, lon: 128, kind: "tower", scale: 1.6, hue: 205 }, seed: 1225670989, t: 1718201203.0 },
-    { id: "f_000038", wish_id: "w_000012", tool: "place_structure", args: { lat: -12, lon: 126, kind: "warehouse", scale: 1.2, hue: 44 }, seed: 1342640375, t: 1718201206.0 },
-    { id: "f_000039", wish_id: "w_000012", tool: "place_structure", args: { lat: -8, lon: 130, kind: "cafe", scale: 0.9, hue: 36 }, seed: 654319713, t: 1718201209.0 },
-    { id: "f_000040", wish_id: "w_000012", tool: "place_water", args: { kind: "stream", path: [[-16, 120], [-12, 126], [-8, 130], [-4, 136]], hue: 200 }, seed: 962901442, t: 1718201212.0 },
-    { id: "f_000041", wish_id: "w_000012", tool: "spawn_life", args: { lat: -10, lon: 128, radius_deg: 9, kind: "carts", count: 8, hue: 42 }, seed: 1315145044, t: 1718201215.0 },
+    { id: "f_000028", wish_id: "w_000007", tool: "build_district", args: { lat: 15, lon: 43, radius_deg: 6, density: 0.8, hue: 35 }, seed: 8311893, t: 1718200700.0 },
+    { id: "f_000029", wish_id: "w_000007", tool: "place_structure", args: { lat: 15, lon: 43, kind: "market", scale: 1.1, hue: 30 }, seed: 2004477123, t: 1718200703.0 },
+    { id: "f_000030", wish_id: "w_000007", tool: "place_structure", args: { lat: 16, lon: 44, kind: "cafe", scale: 1.0, hue: 34 }, seed: 1852880249, t: 1718200706.0 },
+    { id: "f_000031", wish_id: "w_000007", tool: "place_road", args: { path: [[14, 38], [15, 41], [15, 43]] }, seed: 427263471, t: 1718200709.0 },
+    { id: "f_000032", wish_id: "w_000007", tool: "spawn_life", args: { lat: 15, lon: 42, radius_deg: 7, kind: "carts", count: 8, hue: 42 }, seed: 118689868, t: 1718200712.0 },
   ],
 };

web/mock/traces.json

@@ -1,177 +1,117 @@
 {
   "w_000001": {
     "wish_id": "w_000001",
-    "text": "a mountain to catch the first light",
+    "text": "level the ground by the monolith and ring it with glowgrass at dusk",
     "submitted_at": 1718200090.0,
     "moderation": { "allowed": true, "category": null },
-    "reading": "A mountain. Not for climbing — for catching. The wisher wants the dawn to have somewhere to arrive. I will raise stone in the west, high enough to be struck first, and leave a word at its foot.",
+    "reading": "Before a town, a place for it to stand. The ground by the monolith heaves and pitches — I will press it flat and broad, ring its edge with grass that holds its own light, and let the sky go to dusk so the first lamps will mean something.",
     "turns": [
-      { "thought": "The west face is bare. Raise the great peak there, rough, the way light likes it.", "call": { "tool": "raise_terrain", "args": { "lat": -8, "lon": -118, "radius_deg": 24, "height": 0.1, "roughness": 0.6 } }, "observation": "ok: mountains risen at (-8,-118)" },
-      { "thought": "One peak is a spike. A shoulder beside it makes a mountain.", "call": { "tool": "raise_terrain", "args": { "lat": -16, "lon": -104, "radius_deg": 14, "height": 0.05, "roughness": 0.75 } }, "observation": "ok: mountains risen at (-16,-104)" },
-      { "thought": "Mark the foot of it, so the light knows it was invited.", "call": { "tool": "inscribe_wish", "args": { "text": "the first light will know where to land", "style": "stone" } }, "observation": "ok: words set in stone" },
-      { "thought": "It stands. Let the dawn do the rest.", "call": null, "observation": "" }
+      { "thought": "Flatten the shoulder of ground at the monolith — wide and gentle, fit to build on.", "call": { "tool": "raise_terrain", "args": { "lat": 14, "lon": 38, "radius_deg": 16, "height": 0.035, "roughness": 0.45 } }, "observation": "ok: mountains risen at (14,38)" },
+      { "thought": "Far across the world, a wide meadow of glowgrass to light the far ground.", "call": { "tool": "spawn_flora", "args": { "lat": -6, "lon": 118, "radius_deg": 14, "kind": "glowgrass", "density": 0.6, "hue": 150 } }, "observation": "ok: flora seeded at (-6,118)" },
+      { "thought": "Take the sky to dusk — building reads best when the light is going.", "call": { "tool": "set_sky", "args": { "palette": "dusk", "star_density": 0.55, "moons": 1 } }, "observation": "ok: sky set to dusk, 1 moon" },
+      { "thought": "The ground lies flat. Now it can hold a town.", "call": null, "observation": "" }
     ],
-    "epitaph": "Stone was raised to meet the dawn halfway.",
+    "epitaph": "The ground lies flat for building, and the grass glows where the town will rise.",
     "feature_ids": ["f_000004", "f_000005", "f_000006"],
     "model": "nemotron-3-nano (mock)",
     "backend": "mock",
-    "ms_total": 41230
+    "ms_total": 44230
   },
   "w_000002": {
     "wish_id": "w_000002",
-    "text": "let glowing grass run down the slopes",
+    "text": "build me a town — a district, a bank, a market, and a tower over it",
     "submitted_at": 1718200190.0,
     "moderation": { "allowed": true, "category": null },
-    "reading": "Grass that glows. The old hill by the monolith has been dark too long. I will let light grow downhill, the way water would, and scatter flowers where it slows.",
+    "reading": "A town, then — the brave wish. Not one tower alone on an empty world, but a whole quarter at once: a block of homes on the flat ground, a bank and a market to give them reason to gather, and a tower to keep the light over all of it. I will lay it down beside the monolith, and bind it with a road.",
     "turns": [
-      { "thought": "Seed the slope below the monolith. Green-gold, dense, alive.", "call": { "tool": "spawn_flora", "args": { "lat": 8, "lon": 36, "radius_deg": 13, "kind": "glowgrass", "density": 0.85, "hue": 150 } }, "observation": "ok: flora seeded at (8,36)" },
-      { "thought": "Where the grass thins, flowers. Violet ones, for contrast.", "call": { "tool": "spawn_flora", "args": { "lat": 16, "lon": 48, "radius_deg": 8, "kind": "flowers", "density": 0.7, "hue": 295 } }, "observation": "ok: flora seeded at (16,48)" },
-      { "thought": "The hill breathes now.", "call": null, "observation": "" }
+      { "thought": "First the quarter itself — a dense block of homes on the new flat ground.", "call": { "tool": "build_district", "args": { "lat": 14, "lon": 38, "radius_deg": 7, "density": 0.85, "hue": 36 } }, "observation": "ok: a district rises near (14,38)" },
+      { "thought": "A bank at the heart of it — stone, columned, the town's anchor.", "call": { "tool": "place_structure", "args": { "lat": 14, "lon": 38, "kind": "bank", "scale": 1.3, "hue": 40 } }, "observation": "ok: bank placed at (14,38)" },
+      { "thought": "A market beside it — stalls and warm tables, a place to meet.", "call": { "tool": "place_structure", "args": { "lat": 12.5, "lon": 40, "kind": "market", "scale": 1.1, "hue": 30 } }, "observation": "ok: market placed at (12,40)" },
+      { "thought": "A tower over the town, its rooftop light slow-pulsing across the block.", "call": { "tool": "place_structure", "args": { "lat": 16, "lon": 37, "kind": "tower", "scale": 1.4, "hue": 210 } }, "observation": "ok: tower placed at (16,37)" },
+      { "thought": "A road to bind market, square and tower into one street.", "call": { "tool": "place_road", "args": { "path": [[12.5, 40], [14, 38], [16, 37]] } }, "observation": "ok: a road laid through 3 points" },
+      { "thought": "A town is born — not scattered, but gathered around one square.", "call": null, "observation": "" }
     ],
-    "epitaph": "The slopes learned to hold their own light.",
-    "feature_ids": ["f_000007", "f_000008"],
+    "epitaph": "The town of Emberlyn stands: its bank, its market, its tower keeping the light.",
+    "feature_ids": ["f_000007", "f_000008", "f_000009", "f_000010", "f_000011"],
     "model": "nemotron-3-nano (mock)",
     "backend": "mock",
-    "ms_total": 33180
+    "ms_total": 58910
   },
   "w_000003": {
     "wish_id": "w_000003",
-    "text": "a sea of violet trees",
+    "text": "a denser quarter below the square, a warehouse and homes, a road up to it",
     "submitted_at": 1718200290.0,
     "moderation": { "allowed": true, "category": null },
-    "reading": "A sea, but of trees. Seas need basins. I will press a hollow into the south and flood it with violet canopies — a tide that never goes out.",
+    "reading": "The town wants to grow — and it should grow beside itself, not away. A second, denser block just below the square, a warehouse to work from and a home beside it, a road climbing up to the old heart so the two are one, and carts to run the new street home as the light goes.",
     "turns": [
-      { "thought": "First the basin. Gentle, wide, where the trees will pool.", "call": { "tool": "lower_terrain", "args": { "lat": -26, "lon": 64, "radius_deg": 12, "depth": 0.04, "roughness": 0.5 } }, "observation": "ok: land lowered at (-26,64)" },
-      { "thought": "Now the flood: violet trees, shore to shore.", "call": { "tool": "spawn_flora", "args": { "lat": -19, "lon": 57, "radius_deg": 15, "kind": "trees", "density": 0.75, "hue": 278 } }, "observation": "ok: flora seeded at (-19,57)" },
-      { "thought": "From orbit it reads as water. Close up, it whispers like a forest. Both true.", "call": null, "observation": "" }
+      { "thought": "A second quarter below the square — denser still, joined to the first.", "call": { "tool": "build_district", "args": { "lat": 11.5, "lon": 36.5, "radius_deg": 6, "density": 0.85, "hue": 34 } }, "observation": "ok: a district rises near (11,36)" },
+      { "thought": "A warehouse to work from, one great door glowing.", "call": { "tool": "place_structure", "args": { "lat": 12, "lon": 35.5, "kind": "warehouse", "scale": 1.1, "hue": 42 } }, "observation": "ok: warehouse placed at (12,35)" },
+      { "thought": "A home beside it, one warm window lit.", "call": { "tool": "place_structure", "args": { "lat": 10.5, "lon": 37, "kind": "house", "scale": 1.0, "hue": 36 } }, "observation": "ok: house placed at (10,37)" },
+      { "thought": "A road up to the old square, so no house stands apart from the town.", "call": { "tool": "place_road", "args": { "path": [[11.5, 36.5], [12.8, 37.2], [14, 38]] } }, "observation": "ok: a road laid through 3 points" },
+      { "thought": "Carts to run the new street, gliding home at dusk.", "call": { "tool": "spawn_life", "args": { "lat": 13, "lon": 38, "radius_deg": 7, "kind": "carts", "count": 8, "hue": 42 } }, "observation": "ok: 8 carts stirring at (13,38)" },
+      { "thought": "Two quarters now, and one road between them. A town, not two villages.", "call": null, "observation": "" }
     ],
-    "epitaph": "A forest that the horizon mistakes for water.",
-    "feature_ids": ["f_000009", "f_000010"],
+    "epitaph": "A second block, joined to the first; the carts run the new street home at dusk.",
+    "feature_ids": ["f_000012", "f_000013", "f_000014", "f_000015", "f_000016"],
     "model": "nemotron-3-nano (mock)",
     "backend": "mock",
-    "ms_total": 36900
+    "ms_total": 56120
   },
   "w_000004": {
     "wish_id": "w_000004",
-    "text": "a river of light for the dark side",
+    "text": "let a bright stream run down into the square, with a little pool",
     "submitted_at": 1718200390.0,
     "moderation": { "allowed": true, "category": null },
-    "reading": "The dark side asks for a river. Not water — light that behaves like water. I will draw it down from the highlands, let it pool where the land cups, and send rain to keep it company.",
+    "reading": "A town needs water to come to it. I will draw a bright stream down out of the highlands into the square, set a small still pool at its bend, and stand a quiet grove of trees far out at the town's edge — somewhere green to walk to.",
     "turns": [
-      { "thought": "Trace the course: down from the cold north, bending east where the land leans.", "call": { "tool": "place_water", "args": { "kind": "stream", "path": [[24, -30], [12, -14], [2, -2], [-9, 14]], "hue": 190 } }, "observation": "ok: stream laid across the surface" },
-      { "thought": "Every river deserves a place to rest. A pool, at the end.", "call": { "tool": "place_water", "args": { "kind": "pool", "path": [[-12, 18]], "radius_deg": 5, "hue": 205 } }, "observation": "ok: pool filled at (-12,18)" },
-      { "thought": "And rain, so the river has a sound.", "call": { "tool": "set_weather", "args": { "kind": "rain", "intensity": 0.45 } }, "observation": "ok: weather set to rain" },
-      { "thought": "Light moves. The dark side is only dim now.", "call": null, "observation": "" }
+      { "thought": "Trace a bright stream down out of the northern highlands toward the town.", "call": { "tool": "place_water", "args": { "kind": "stream", "path": [[28, 12], [22, 20], [16, 28]], "hue": 205 } }, "observation": "ok: stream laid across the surface" },
+      { "thought": "A small still pool where the stream rests, just north of the square.", "call": { "tool": "place_water", "args": { "kind": "pool", "path": [[16, 28]], "radius_deg": 2, "hue": 205 } }, "observation": "ok: pool filled at (16,28)" },
+      { "thought": "A whole forest far across the world, for when the eye pulls back.", "call": { "tool": "spawn_flora", "args": { "lat": 2, "lon": 108, "radius_deg": 13, "kind": "trees", "density": 0.6, "hue": 130 } }, "observation": "ok: flora seeded at (2,108)" },
+      { "thought": "Water comes to the square. It will not be a dry place.", "call": null, "observation": "" }
     ],
-    "epitaph": "A river was taught to carry light instead of water.",
-    "feature_ids": ["f_000011", "f_000012", "f_000013"],
+    "epitaph": "Water comes to the square now, and a stand of trees waits at the town's edge.",
+    "feature_ids": ["f_000017", "f_000018", "f_000019"],
     "model": "nemotron-3-nano (mock)",
     "backend": "mock",
     "ms_total": 47410
   },
   "w_000005": {
     "wish_id": "w_000005",
-    "text": "a lighthouse for lost moons",
+    "text": "a third quarter to the northeast — a cafe, a home, a road, and fireflies",
     "submitted_at": 1718200490.0,
     "moderation": { "allowed": true, "category": null },
-    "reading": "Moons get lost too. They circle and circle and nothing waves back. A lighthouse, then — on a headland I will raise for it — sweeping gold through the mist.",
+    "reading": "A third quarter, rising to the northeast of the square — another dense block, a cafe to keep one window warm, a home beside it, the road carried up to join it to the town, and fireflies to fill the dark the instant the day lets go.",
     "turns": [
-      { "thought": "A lighthouse needs a cape. Raise one, modest, sea-smooth.", "call": { "tool": "raise_terrain", "args": { "lat": 31, "lon": -63, "radius_deg": 7, "height": 0.045, "roughness": 0.4 } }, "observation": "ok: mountains risen at (31,-63)" },
-      { "thought": "The tower itself. Tall, patient, gold-lanterned.", "call": { "tool": "place_structure", "args": { "lat": 32, "lon": -61, "kind": "lighthouse", "scale": 1.6, "hue": 45 } }, "observation": "ok: lighthouse placed at (32,-61)" },
-      { "thought": "Mist, so the beam has something to be seen against.", "call": { "tool": "set_weather", "args": { "kind": "mist", "intensity": 0.45 } }, "observation": "ok: weather set to mist" },
-      { "thought": "Now even a lost moon can find the shore.", "call": null, "observation": "" }
+      { "thought": "A third quarter to the northeast — dense, joined to the square, not apart.", "call": { "tool": "build_district", "args": { "lat": 16.5, "lon": 40.5, "radius_deg": 5, "density": 0.8, "hue": 35 } }, "observation": "ok: a district rises near (16,40)" },
+      { "thought": "A cafe at its corner, its awning lit, warm light spilling on the stones.", "call": { "tool": "place_structure", "args": { "lat": 17, "lon": 41, "kind": "cafe", "scale": 1.0, "hue": 34 } }, "observation": "ok: cafe placed at (17,41)" },
+      { "thought": "A home beside it, so the cafe has a neighbour.", "call": { "tool": "place_structure", "args": { "lat": 16, "lon": 42, "kind": "house", "scale": 1.0, "hue": 36 } }, "observation": "ok: house placed at (16,42)" },
+      { "thought": "Carry the road up from the square to meet the new quarter.", "call": { "tool": "place_road", "args": { "path": [[14, 38], [15.5, 39.5], [16.5, 40.5]] } }, "observation": "ok: a road laid through 3 points" },
+      { "thought": "Fireflies at the cafe corner, to fill the dark the instant the light goes.", "call": { "tool": "spawn_life", "args": { "lat": 17, "lon": 41, "radius_deg": 4, "kind": "fireflies", "count": 5, "hue": 48 } }, "observation": "ok: 5 fireflies stirring at (17,41)" },
+      { "thought": "Three quarters now, one road threading them. A town, not three villages.", "call": null, "observation": "" }
     ],
-    "epitaph": "Its beam sweeps the sky for anyone still circling.",
-    "feature_ids": ["f_000014", "f_000015", "f_000016"],
+    "epitaph": "A third block joins the town; one warm window, and the dusk fills with small lamps.",
+    "feature_ids": ["f_000020", "f_000021", "f_000022", "f_000023", "f_000024"],
     "model": "nemotron-3-nano (mock)",
     "backend": "mock",
-    "ms_total": 45120
+    "ms_total": 56980
   },
   "w_000006": {
     "wish_id": "w_000006",
-    "text": "a village that keeps its lamps lit",
+    "text": "a far range across the sea, and birds to circle the town at dusk",
     "submitted_at": 1718200590.0,
     "moderation": { "allowed": true, "category": null },
-    "reading": "A village, and the lamps must not go out. I hear the real wish underneath: let no window go dark. Houses near water, reeds at the door, a hearth that argues with the night.",
-    "turns": [
-      { "thought": "Set the houses on the plain east of the old hill. Lamps in every wall.", "call": { "tool": "place_structure", "args": { "lat": 4, "lon": 12, "kind": "village", "scale": 1.25, "hue": 38 } }, "observation": "ok: village raised at (4,12)" },
-      { "thought": "Reeds along the path — green, so the lamplight has an edge.", "call": { "tool": "spawn_flora", "args": { "lat": 1, "lon": 19, "radius_deg": 6, "kind": "reeds", "density": 0.8, "hue": 95 } }, "observation": "ok: flora seeded at (1,19)" },
-      { "thought": "A pond to double every window.", "call": { "tool": "place_water", "args": { "kind": "pool", "path": [[-2, 8]], "radius_deg": 3, "hue": 175 } }, "observation": "ok: pool filled at (-2,8)" },
-      { "thought": "The lamps are lit. I will not say for whom.", "call": null, "observation": "" }
-    ],
-    "epitaph": "Nine windows. None of them dark.",
-    "feature_ids": ["f_000017", "f_000018", "f_000019"],
-    "model": "nemotron-3-nano (mock)",
-    "backend": "mock",
-    "ms_total": 49870
-  },
-  "w_000007": {
-    "wish_id": "w_000007",
-    "text": "a shrine where snow falls and stays",
-    "submitted_at": 1718200690.0,
-    "moderation": { "allowed": true, "category": null },
-    "reading": "A quiet wish. Snow that stays — permanence asked of the most temporary thing. I will build the shrine far south, where the cold is honest, and command the snow to keep falling.",
-    "turns": [
-      { "thought": "The far south. Four pillars, one floating light. Blue, like held breath.", "call": { "tool": "place_structure", "args": { "lat": -44, "lon": -37, "kind": "shrine", "scale": 1.3, "hue": 210 } }, "observation": "ok: shrine placed at (-44,-37)" },
-      { "thought": "Now the snow. Steady. Unhurried. Forever is just patience repeated.", "call": { "tool": "set_weather", "args": { "kind": "snow", "intensity": 0.6 } }, "observation": "ok: weather set to snow" },
-      { "thought": "It falls, and it stays falling. Close enough to forever.", "call": null, "observation": "" }
-    ],
-    "epitaph": "The snow keeps its appointment forever.",
-    "feature_ids": ["f_000020", "f_000021"],
-    "model": "nemotron-3-nano (mock)",
-    "backend": "mock",
-    "ms_total": 38760
-  },
-  "w_000008": {
-    "wish_id": "w_000008",
-    "text": "mushrooms beneath a second moon",
-    "submitted_at": 1718200790.0,
-    "moderation": { "allowed": true, "category": null },
-    "reading": "Two requests wearing one coat: small lamps below, a new lamp above. Mushrooms first — blue-capped, crowded, the kind that confer. Then I will hang a second moon to watch them.",
-    "turns": [
-      { "thought": "Crowd them on the southern hills — blue caps, almost touching.", "call": { "tool": "spawn_flora", "args": { "lat": -41, "lon": -22, "radius_deg": 9, "kind": "mushrooms", "density": 0.9, "hue": 198 } }, "observation": "ok: flora seeded at (-41,-22)" },
-      { "thought": "And the second moon. The night sky, rearranged for them.", "call": { "tool": "set_sky", "args": { "palette": "night", "star_density": 0.75, "moons": 2 } }, "observation": "ok: sky set to night, 2 moons" },
-      { "thought": "The mushrooms glow up. The moons glow down. An understanding.", "call": null, "observation": "" }
-    ],
-    "epitaph": "Two moons now, and small lamps to greet them.",
-    "feature_ids": ["f_000022", "f_000023"],
-    "model": "nemotron-3-nano (mock)",
-    "backend": "mock",
-    "ms_total": 35540
-  },
-  "w_000009": {
-    "wish_id": "w_000009",
-    "text": "an arch wrapped in living vines",
-    "submitted_at": 1718200890.0,
-    "moderation": { "allowed": true, "category": null },
-    "reading": "An arch is a door that refuses walls. This one wants to be alive. Stone first, then vines — rose light through green — set high in the east where travelers would pass, if I ever make travelers.",
-    "turns": [
-      { "thought": "Raise the span in the east, tall enough to frame the moons.", "call": { "tool": "place_structure", "args": { "lat": 22, "lon": 96, "kind": "arch", "scale": 1.8, "hue": 320 } }, "observation": "ok: arch placed at (22,96)" },
-      { "thought": "Now the vines. Let them climb without being told twice.", "call": { "tool": "spawn_flora", "args": { "lat": 21, "lon": 97, "radius_deg": 7, "kind": "vines", "density": 0.65, "hue": 120 } }, "observation": "ok: flora seeded at (21,97)" },
-      { "thought": "A door, alive, open. Anything could come through. Good.", "call": null, "observation": "" }
-    ],
-    "epitaph": "Walk through; the vines lean in to listen.",
-    "feature_ids": ["f_000024", "f_000025"],
-    "model": "nemotron-3-nano (mock)",
-    "backend": "mock",
-    "ms_total": 37210
-  },
-  "w_000010": {
-    "wish_id": "w_000010",
-    "text": "a beacon to call the dancing lights",
-    "submitted_at": 1718200990.0,
-    "moderation": { "allowed": true, "category": null },
-    "reading": "The dancing lights — the aurora. It does not come when called, usually. But a beacon is not a call; it is an invitation left burning. Far north, then. Green fire. We will see who arrives.",
+    "reading": "The town is close and warm; let the world around it be vast. I will raise a far range across the sea — something to behold when the eye pulls back — scatter pale mushrooms on its flanks, and set a slow ring of birds turning above the town, so even the wide world keeps coming home.",
     "turns": [
-      { "thought": "The far north, where the sky is thinnest. A green-flamed beacon.", "call": { "tool": "place_structure", "args": { "lat": 55, "lon": 150, "kind": "beacon", "scale": 1.5, "hue": 165 } }, "observation": "ok: beacon placed at (55,150)" },
-      { "thought": "And the sky itself. Polar fire — is that a sky I own?", "call": { "tool": "set_sky", "args": { "palette": "polar", "star_density": 0.8, "moons": 2 } }, "observation": "rejected: unknown palette 'polar'" },
-      { "thought": "The sky, then: curtains of green and violet, drawn for the beacon.", "call": { "tool": "set_sky", "args": { "palette": "aurora", "star_density": 0.8, "moons": 2 } }, "observation": "ok: sky set to aurora, 2 moons" },
-      { "thought": "It burns. The lights are already leaning closer.", "call": null, "observation": "" }
+      { "thought": "A great range far across the sea — the wide world, for when the eye pulls back.", "call": { "tool": "raise_terrain", "args": { "lat": -24, "lon": -98, "radius_deg": 26, "height": 0.09, "roughness": 0.7 } }, "observation": "ok: mountains risen at (-24,-98)" },
+      { "thought": "Pale mushrooms on its cold flanks, faint as far lamps.", "call": { "tool": "spawn_flora", "args": { "lat": -28, "lon": -90, "radius_deg": 18, "kind": "mushrooms", "density": 0.7, "hue": 280 } }, "observation": "ok: flora seeded at (-28,-90)" },
+      { "thought": "A slow ring of birds over the town, so the wide world keeps coming home.", "call": { "tool": "spawn_life", "args": { "lat": 14, "lon": 38, "radius_deg": 7, "kind": "birds", "count": 6, "hue": 32 } }, "observation": "ok: 6 birds stirring at (14,38)" },
+      { "thought": "A breath of mist over the town, to soften the dusk.", "call": { "tool": "set_weather", "args": { "kind": "mist", "intensity": 0.22 } }, "observation": "ok: weather set to mist" },
+      { "thought": "A whole world around one small town. Pull back, and see.", "call": null, "observation": "" }
     ],
-    "epitaph": "It burns green, and the sky answers.",
-    "feature_ids": ["f_000026", "f_000027"],
+    "epitaph": "Mountains rise far off; the birds keep their slow ring above home.",
+    "feature_ids": ["f_000025", "f_000026", "f_000027", "f_000028"],
     "model": "nemotron-3-nano (mock)",
     "backend": "mock",
-    "ms_total": 51020
+    "ms_total": 52340
   }
 }

web/mock/world.json

@@ -1,64 +1,52 @@
 {
   "world": {
-    "version": 36,
-    "epoch": 11,
+    "version": 41,
+    "epoch": 6,
     "features": [
       {"id":"f_000000","wish_id":"genesis","tool":"set_sky","args":{"palette":"void","star_density":0.9,"moons":1},"seed":7,"t":0},
       {"id":"f_000001","wish_id":"genesis","tool":"raise_terrain","args":{"lat":12,"lon":40,"radius_deg":28,"height":0.05,"roughness":0.7},"seed":11,"t":0},
       {"id":"f_000002","wish_id":"genesis","tool":"place_structure","args":{"lat":14,"lon":38,"kind":"monolith","scale":1.4,"hue":270},"seed":13,"t":0},
       {"id":"f_000003","wish_id":"genesis","tool":"inscribe_wish","args":{"text":"speak, and it will be made","style":"orbit"},"seed":17,"t":0},
 
-      {"id":"f_000004","wish_id":"w_000001","tool":"raise_terrain","args":{"lat":-8,"lon":-118,"radius_deg":24,"height":0.1,"roughness":0.6},"seed":83077351,"t":1718200100.0},
-      {"id":"f_000005","wish_id":"w_000001","tool":"raise_terrain","args":{"lat":-16,"lon":-104,"radius_deg":14,"height":0.05,"roughness":0.75},"seed":1945409649,"t":1718200103.0},
-      {"id":"f_000006","wish_id":"w_000001","tool":"inscribe_wish","args":{"text":"the first light will know where to land","style":"stone"},"seed":1795017163,"t":1718200106.0},
-
-      {"id":"f_000007","wish_id":"w_000002","tool":"spawn_flora","args":{"lat":8,"lon":36,"radius_deg":13,"kind":"glowgrass","density":0.85,"hue":150},"seed":112531134,"t":1718200200.0},
-      {"id":"f_000008","wish_id":"w_000002","tool":"spawn_flora","args":{"lat":16,"lon":48,"radius_deg":8,"kind":"flowers","density":0.7,"hue":295},"seed":1907500584,"t":1718200203.0},
-
-      {"id":"f_000009","wish_id":"w_000003","tool":"lower_terrain","args":{"lat":-26,"lon":64,"radius_deg":12,"depth":0.04,"roughness":0.5},"seed":125271177,"t":1718200300.0},
-      {"id":"f_000010","wish_id":"w_000003","tool":"spawn_flora","args":{"lat":-19,"lon":57,"radius_deg":15,"kind":"trees","density":0.75,"hue":278},"seed":1886407711,"t":1718200303.0},
-
-      {"id":"f_000011","wish_id":"w_000004","tool":"place_water","args":{"kind":"stream","path":[[24,-30],[12,-14],[2,-2],[-9,14]],"hue":190},"seed":37251596,"t":1718200400.0},
-      {"id":"f_000012","wish_id":"w_000004","tool":"place_water","args":{"kind":"pool","path":[[-12,18]],"radius_deg":5,"hue":205},"seed":1967086234,"t":1718200403.0},
-      {"id":"f_000013","wish_id":"w_000004","tool":"set_weather","args":{"kind":"rain","intensity":0.45},"seed":1815481120,"t":1718200406.0},
-
-      {"id":"f_000014","wish_id":"w_000005","tool":"raise_terrain","args":{"lat":31,"lon":-63,"radius_deg":7,"height":0.045,"roughness":0.4},"seed":66715707,"t":1718200500.0},
-      {"id":"f_000015","wish_id":"w_000005","tool":"place_structure","args":{"lat":32,"lon":-61,"kind":"lighthouse","scale":1.6,"hue":45},"seed":1962750125,"t":1718200503.0},
-      {"id":"f_000016","wish_id":"w_000005","tool":"set_weather","args":{"kind":"mist","intensity":0.45},"seed":1844732183,"t":1718200506.0},
-
-      {"id":"f_000017","wish_id":"w_000006","tool":"place_structure","args":{"lat":4,"lon":12,"kind":"village","scale":1.25,"hue":38},"seed":29146722,"t":1718200600.0},
-      {"id":"f_000018","wish_id":"w_000006","tool":"spawn_flora","args":{"lat":1,"lon":19,"radius_deg":6,"kind":"reeds","density":0.8,"hue":95},"seed":1992003316,"t":1718200603.0},
-      {"id":"f_000019","wish_id":"w_000006","tool":"place_water","args":{"kind":"pool","path":[[-2,8]],"radius_deg":3,"hue":175},"seed":1873993550,"t":1718200606.0},
-
-      {"id":"f_000020","wish_id":"w_000007","tool":"place_structure","args":{"lat":-44,"lon":-37,"kind":"shrine","scale":1.3,"hue":210},"seed":8311893,"t":1718200700.0},
-      {"id":"f_000021","wish_id":"w_000007","tool":"set_weather","args":{"kind":"snow","intensity":0.6},"seed":2004477123,"t":1718200703.0},
-
-      {"id":"f_000022","wish_id":"w_000008","tool":"spawn_flora","args":{"lat":-41,"lon":-22,"radius_deg":9,"kind":"mushrooms","density":0.9,"hue":198},"seed":186815336,"t":1718200800.0},
-      {"id":"f_000023","wish_id":"w_000008","tool":"set_sky","args":{"palette":"night","star_density":0.75,"moons":2},"seed":2082841598,"t":1718200803.0},
-
-      {"id":"f_000024","wish_id":"w_000009","tool":"place_structure","args":{"lat":22,"lon":96,"kind":"arch","scale":1.8,"hue":320},"seed":182516063,"t":1718200900.0},
-      {"id":"f_000025","wish_id":"w_000009","tool":"spawn_flora","args":{"lat":21,"lon":97,"radius_deg":7,"kind":"vines","density":0.65,"hue":120},"seed":2112342473,"t":1718200903.0},
-
-      {"id":"f_000026","wish_id":"w_000010","tool":"place_structure","args":{"lat":55,"lon":150,"kind":"beacon","scale":1.5,"hue":165},"seed":1032693173,"t":1718201000.0},
-      {"id":"f_000027","wish_id":"w_000010","tool":"set_sky","args":{"palette":"aurora","star_density":0.8,"moons":2},"seed":1250596131,"t":1718201003.0},
-
-      {"id":"f_000028","wish_id":"w_000011","tool":"raise_terrain","args":{"lat":38,"lon":-8,"radius_deg":12,"height":0.045,"roughness":0.4},"seed":1011863426,"t":1718201100.0},
-      {"id":"f_000029","wish_id":"w_000011","tool":"place_structure","args":{"lat":38,"lon":-8,"kind":"tower","scale":1.6,"hue":210},"seed":1263075092,"t":1718201103.0},
-      {"id":"f_000030","wish_id":"w_000011","tool":"place_structure","args":{"lat":36,"lon":-11,"kind":"warehouse","scale":1.2,"hue":44},"seed":1380036270,"t":1718201106.0},
-      {"id":"f_000031","wish_id":"w_000011","tool":"place_structure","args":{"lat":40,"lon":-5,"kind":"cafe","scale":1.0,"hue":36},"seed":625385016,"t":1718201109.0},
-      {"id":"f_000032","wish_id":"w_000011","tool":"place_water","args":{"kind":"stream","path":[[31,-18],[35,-12],[39,-6],[43,0]],"hue":200},"seed":992086939,"t":1718201112.0},
-      {"id":"f_000033","wish_id":"w_000011","tool":"spawn_life","args":{"lat":38,"lon":-9,"radius_deg":9,"kind":"carts","count":7,"hue":42},"seed":1277508365,"t":1718201115.0},
-      {"id":"f_000034","wish_id":"w_000011","tool":"spawn_life","args":{"lat":41,"lon":-4,"radius_deg":6,"kind":"fireflies","count":9,"hue":150},"seed":1011863426,"t":1718201118.0},
-      {"id":"f_000035","wish_id":"w_000011","tool":"spawn_life","args":{"lat":38,"lon":-8,"radius_deg":8,"kind":"birds","count":7,"hue":220},"seed":1263075092,"t":1718201121.0}
+      {"id":"f_000004","wish_id":"w_000001","tool":"raise_terrain","args":{"lat":14,"lon":38,"radius_deg":15,"height":0.03,"roughness":0.4},"seed":83077351,"t":1718200100.0},
+      {"id":"f_000005","wish_id":"w_000001","tool":"spawn_flora","args":{"lat":-6,"lon":118,"radius_deg":14,"kind":"glowgrass","density":0.6,"hue":150},"seed":1945409649,"t":1718200103.0},
+      {"id":"f_000006","wish_id":"w_000001","tool":"set_sky","args":{"palette":"dusk","star_density":0.55,"moons":1},"seed":1795017163,"t":1718200106.0},
+
+      {"id":"f_000007","wish_id":"w_000002","tool":"build_district","args":{"lat":14,"lon":38,"radius_deg":7,"density":0.95,"hue":36},"seed":112531134,"t":1718200200.0},
+      {"id":"f_000008","wish_id":"w_000002","tool":"place_structure","args":{"lat":14,"lon":38,"kind":"bank","scale":1.3,"hue":40},"seed":1907500584,"t":1718200203.0},
+      {"id":"f_000009","wish_id":"w_000002","tool":"place_structure","args":{"lat":13,"lon":39.5,"kind":"market","scale":1.1,"hue":30},"seed":1757116306,"t":1718200206.0},
+      {"id":"f_000010","wish_id":"w_000002","tool":"place_structure","args":{"lat":15.5,"lon":37,"kind":"tower","scale":1.35,"hue":210},"seed":532432644,"t":1718200209.0},
+      {"id":"f_000011","wish_id":"w_000002","tool":"place_road","args":{"path":[[13,39.5],[14,38],[15.5,37]]},"seed":30986919,"t":1718200212.0},
+
+      {"id":"f_000012","wish_id":"w_000003","tool":"build_district","args":{"lat":11.5,"lon":36.5,"radius_deg":6,"density":0.85,"hue":34},"seed":125271177,"t":1718200300.0},
+      {"id":"f_000013","wish_id":"w_000003","tool":"place_structure","args":{"lat":12,"lon":35.5,"kind":"warehouse","scale":1.1,"hue":42},"seed":1886407711,"t":1718200303.0},
+      {"id":"f_000014","wish_id":"w_000003","tool":"place_structure","args":{"lat":10.5,"lon":37,"kind":"house","scale":1.0,"hue":36},"seed":1769545125,"t":1718200306.0},
+      {"id":"f_000015","wish_id":"w_000003","tool":"place_road","args":{"path":[[11.5,36.5],[12.8,37.2],[14,38]]},"seed":511585587,"t":1718200309.0},
+      {"id":"f_000016","wish_id":"w_000003","tool":"spawn_life","args":{"lat":13,"lon":38,"radius_deg":7,"kind":"carts","count":8,"hue":42},"seed":1751184,"t":1718200312.0},
+
+      {"id":"f_000017","wish_id":"w_000004","tool":"place_water","args":{"kind":"stream","path":[[28,12],[22,20],[16,28]],"hue":205},"seed":37251596,"t":1718200400.0},
+      {"id":"f_000018","wish_id":"w_000004","tool":"place_water","args":{"kind":"pool","path":[[16,28]],"radius_deg":2,"hue":205},"seed":1967086234,"t":1718200403.0},
+      {"id":"f_000019","wish_id":"w_000004","tool":"spawn_flora","args":{"lat":2,"lon":108,"radius_deg":13,"kind":"trees","density":0.6,"hue":130},"seed":1815481120,"t":1718200406.0},
+
+      {"id":"f_000020","wish_id":"w_000005","tool":"build_district","args":{"lat":16.5,"lon":40.5,"radius_deg":5,"density":0.8,"hue":35},"seed":66715707,"t":1718200500.0},
+      {"id":"f_000021","wish_id":"w_000005","tool":"place_structure","args":{"lat":17,"lon":41,"kind":"cafe","scale":1.0,"hue":34},"seed":1962750125,"t":1718200503.0},
+      {"id":"f_000022","wish_id":"w_000005","tool":"place_structure","args":{"lat":16,"lon":42,"kind":"house","scale":1.0,"hue":36},"seed":1844732183,"t":1718200506.0},
+      {"id":"f_000023","wish_id":"w_000005","tool":"place_road","args":{"path":[[14,38],[15.5,39.5],[16.5,40.5]]},"seed":452153729,"t":1718200509.0},
+      {"id":"f_000024","wish_id":"w_000005","tool":"spawn_life","args":{"lat":17,"lon":41,"radius_deg":4,"kind":"fireflies","count":5,"hue":48},"seed":77055010,"t":1718200512.0},
+
+      {"id":"f_000025","wish_id":"w_000006","tool":"raise_terrain","args":{"lat":-24,"lon":-98,"radius_deg":26,"height":0.09,"roughness":0.7},"seed":29146722,"t":1718200600.0},
+      {"id":"f_000026","wish_id":"w_000006","tool":"spawn_flora","args":{"lat":-28,"lon":-90,"radius_deg":18,"kind":"mushrooms","density":0.7,"hue":280},"seed":1992003316,"t":1718200603.0},
+      {"id":"f_000027","wish_id":"w_000006","tool":"spawn_life","args":{"lat":14,"lon":38,"radius_deg":7,"kind":"birds","count":6,"hue":32},"seed":1873993550,"t":1718200606.0},
+      {"id":"f_000028","wish_id":"w_000006","tool":"set_weather","args":{"kind":"mist","intensity":0.22},"seed":414576600,"t":1718200609.0}
     ]
   },
   "queue": { "length": 0, "current": null },
   "wishes_recent": [
-    {"wish_id":"w_000011","text":"a city with a tower, a warehouse, a cafe, and carts at dusk","epitaph":"A tower stands over its warehouse and cafe, and carts run the streets at dusk.","epoch":11,"ts":1718201115.0},
-    {"wish_id":"w_000010","text":"a beacon to call the dancing lights","epitaph":"It burns green, and the sky answers.","epoch":10,"ts":1718201003.0},
-    {"wish_id":"w_000009","text":"an arch wrapped in living vines","epitaph":"Walk through; the vines lean in to listen.","epoch":9,"ts":1718200903.0},
-    {"wish_id":"w_000008","text":"mushrooms beneath a second moon","epitaph":"Two moons now, and small lamps to greet them.","epoch":8,"ts":1718200803.0},
-    {"wish_id":"w_000007","text":"a shrine where snow falls and stays","epitaph":"The snow keeps its appointment forever.","epoch":7,"ts":1718200703.0},
-    {"wish_id":"w_000006","text":"a village that keeps its lamps lit","epitaph":"Nine windows. None of them dark.","epoch":6,"ts":1718200606.0}
+    {"wish_id":"w_000006","text":"a far range across the sea, and birds to circle the town at dusk","epitaph":"Mountains rise far off; the birds keep their slow ring above home.","epoch":6,"ts":1718200606.0},
+    {"wish_id":"w_000005","text":"a third quarter to the northeast — a cafe, a home, a road, and fireflies","epitaph":"A third block joins the town; one warm window, and the dusk fills with small lamps.","epoch":5,"ts":1718200503.0},
+    {"wish_id":"w_000004","text":"let a bright stream run down into the square, with a little pool","epitaph":"Water comes to the square now, and a stand of trees waits at the town's edge.","epoch":4,"ts":1718200406.0},
+    {"wish_id":"w_000003","text":"a denser quarter below the square, a warehouse and homes, a road up to it","epitaph":"A second block, joined to the first; the carts run the new street home at dusk.","epoch":3,"ts":1718200312.0},
+    {"wish_id":"w_000002","text":"build me a town — a district, a bank, a market, and a tower over the square","epitaph":"The town of Emberlyn stands: its bank, its market, its tower keeping the light.","epoch":2,"ts":1718200209.0},
+    {"wish_id":"w_000001","text":"level the ground by the monolith for building, under a dusk sky","epitaph":"The ground lies flat for building, where the town will rise.","epoch":1,"ts":1718200106.0}
   ]
 }

web/planet/camera.js

@@ -1,17 +1,36 @@
-// GODSEED — the god's gaze. A spherical camera rig that auto-orbits the planet
-// and, on each tool_call, eases over to look at the spot where the world is
-// about to change. Drag to orbit; wheel to approach. On a granted wish (or a
-// Genesis Log replay) it can also descend — a slow liturgical swoop down to the
-// surface over the target, then a glide arc, then a rise back to orbit. Every
-// motion is sim-time deterministic (driven only by update(dt)); no Date/random.
+// GODSEED — the god's gaze. A spherical camera rig with two modes:
+//   TOWN  (default): sits LOW and close over townCenter, framing a ~28° cap so
+//                    buildings read large — like standing over a model town.
+//   WORLD (the reveal): eases out to the full-planet orbit (the wide shot) and
+//                    back, via rig.beholdWorld()/rig.setMode().
+// On each tool_call / world_delta it eases over to look at where the world is
+// about to change — within the town zoom in TOWN mode, never flying to the far
+// limb. Drag to orbit; wheel to approach. On a granted wish (or a Genesis Log
+// replay) it can also descend — a slow liturgical swoop to the surface over the
+// target, a glide arc, then a rise back. Every motion is sim-time deterministic
+// (driven only by update(dt)); no Date/random.
 import * as THREE from "three";
-import { PLANET_R, clamp, lerp, easeInOutCubic } from "./util.js";
+import { PLANET_R, clamp, lerp, easeInOutCubic, townCenter } from "./util.js";
 
 const WIDE_DIST = PLANET_R * 3.3;
 const GAZE_DIST = PLANET_R * 2.35;
 const MIN_DIST = PLANET_R * 1.45;
 const MAX_DIST = PLANET_R * 7.0;
 
+// TOWN view: a low, close vantage that frames a ~28° cap around the town heart.
+// The eye rides just above the surface; the look target floats over the town so
+// buildings stand up into the frame. Tuned (with shot.mjs) so one district reads
+// large yet the whole neighbourhood stays in view.
+const TOWN_CAP = 0.49;               // ~28°, the framed cap half-angle (the spec)
+// Eye distance so the cap roughly fills the 42° FOV from a low oblique. Derived
+// from the cap so the framing follows the spec; the small factor is the visual
+// tune (a hair tighter than the geometric fit so buildings read large).
+const TOWN_DIST = PLANET_R * (1 + Math.sin(TOWN_CAP) * 1.27); // ≈ 1.6 R
+const TOWN_TILT = TOWN_CAP * 0.62;   // eye sits this far "south" of the town for a low oblique look
+const TOWN_LOOK_R = PLANET_R * 1.04; // look target floats just above the ground
+// While granting in TOWN mode the gaze nudges a touch closer to the new feature.
+const TOWN_GAZE_DIST = TOWN_DIST * 0.93;
+
 // Descent geometry. We ride just above the surface and glide a short arc.
 const DESCENT_DIST = PLANET_R * 1.18;  // eye distance from planet center at low point
 const DESCENT_CLEAR = PLANET_R * 1.06; // the look target floats here, above terrain
@@ -35,12 +54,83 @@ export class CameraRig {
     this.gazeHold = 0;   // seconds left of god's-gaze hold
     this.descent = null; // active descent state, or null
     this._terrain = null; // optional terrain for analytic ground clearance
+    // --- town/world mode ---
+    this.mode = "town";              // "town" (default, close) | "world" (the reveal)
+    this.townDir = new THREE.Vector3(); // current town heart (unit dir)
+    townCenter([], this.townDir);    // seed at the genesis monolith
     this._bind(dom);
   }
 
   /** Let the rig clear terrain analytically during descents (set by the app). */
   setTerrain(terrain) { this._terrain = terrain; }
 
+  /**
+   * Re-anchor the town heart from the live feature list and, if we're resting in
+   * TOWN mode, re-frame to follow it (the town centroid drifts as it grows). No
+   * effect while granting (gazeHold), under the hand (userHold), or mid-descent.
+   */
+  setTownCenter(features) {
+    const { dir } = townCenter(features);
+    this.townDir.copy(dir);
+    if (this.mode === "town" && !this.descent && this.userHold <= 0 && this.gazeHold <= 0) {
+      this._frameTown();
+    }
+  }
+
+  /** Switch modes with an eased transition (sim-time deterministic). */
+  setMode(mode) {
+    const next = mode === "world" ? "world" : "town";
+    if (next === this.mode) return;
+    this.mode = next;
+    if (this.descent) this.cancelDescent();
+    this.userHold = 0;
+    this.gazeHold = 0;
+    if (next === "town") this._frameTown();
+    else this._frameWorld();
+  }
+
+  /** Toggle between beholding the whole world and returning to the town. */
+  beholdWorld() {
+    this.setMode(this.mode === "world" ? "town" : "world");
+    return this.mode;
+  }
+
+  /** Spherical angles + distance that frame the close TOWN view over townDir. */
+  _frameTown() {
+    const { th, ph } = this._townAngles(this.townDir);
+    this.thetaT = th;
+    this.phiT = ph;
+    this.distT = TOWN_DIST;
+    this.lookT.copy(this.townDir).multiplyScalar(TOWN_LOOK_R);
+  }
+
+  /** The wide full-planet orbit (the reveal). */
+  _frameWorld() {
+    this.distT = WIDE_DIST;
+    this.lookT.set(0, 0, 0);
+    // keep the town roughly framed in the wide shot so the reveal reads as "this
+    // patch is one town on a whole world", not a jump-cut to nowhere.
+    const { th, ph } = this._anglesFor(this.townDir);
+    this.thetaT = th;
+    this.phiT = ph;
+  }
+
+  /**
+   * Spherical (theta, phi) for the LOW oblique town look: the eye sits a little
+   * "south" (toward higher phi) of the town heart so buildings stand up into the
+   * frame, and the look target is the town itself.
+   */
+  _townAngles(dir) {
+    const tau = Math.PI * 2;
+    let th = Math.atan2(dir.z, dir.x);
+    // drop the eye below the town's own latitude for the oblique, model-town read
+    const base = Math.acos(clamp(dir.y, -1, 1));
+    const ph = clamp(base + TOWN_TILT, PHI_FLOOR, PHI_CEIL);
+    while (th - this.theta > Math.PI) th -= tau;
+    while (th - this.theta < -Math.PI) th += tau;
+    return { th, ph };
+  }
+
   _bind(dom) {
     if (!dom) return;
     let dragging = false, px = 0, py = 0;
@@ -84,11 +174,26 @@ export class CameraRig {
   }
 
   /**
-   * Ease toward a world point (the demo money-shot). `point` null ⇒ wide shot.
+   * Ease toward a world point — the demo money-shot. In TOWN mode this frames
+   * the new feature WITHIN the close town zoom (never flying to the far limb);
+   * in WORLD mode it eases over the planet to the spot. `point` null ⇒ the
+   * mode's resting frame (town heart / wide shot).
    */
   gaze(point, { hold = 4.5 } = {}) {
     if (this.userHold > 0 || this.descent) return; // hand on the camera / mid-descent
-    if (point) {
+    if (this.mode === "town") {
+      // a new feature is always near the town; keep the low, close framing and
+      // just lean the look toward it so it reads big without leaving the town.
+      const dir = point ? point.clone().normalize() : this.townDir;
+      // blend the look between the town heart and the new feature so the whole
+      // block stays in the cap — don't snap the eye to a stray far-flung build.
+      const lookDir = this.townDir.clone().lerp(dir, point ? 0.55 : 0).normalize();
+      const { th, ph } = this._townAngles(lookDir);
+      this.thetaT = th;
+      this.phiT = ph;
+      this.distT = point ? TOWN_GAZE_DIST : TOWN_DIST;
+      this.lookT.copy(lookDir).multiplyScalar(TOWN_LOOK_R);
+    } else if (point) {
       const dir = point.clone().normalize();
       const { th, ph } = this._anglesFor(dir);
       this.thetaT = th;
@@ -102,12 +207,12 @@ export class CameraRig {
     this.gazeHold = hold;
   }
 
-  /** Drift back to the slow contemplative orbit. */
+  /** Drift back to the mode's resting frame (town heart in TOWN, wide in WORLD). */
   release() {
     if (this.descent) return; // a descent owns the camera until it finishes/cancels
     this.gazeHold = 0;
-    this.distT = WIDE_DIST;
-    this.lookT.set(0, 0, 0);
+    if (this.mode === "town") this._frameTown();
+    else { this.distT = WIDE_DIST; this.lookT.set(0, 0, 0); }
   }
 
   /**
@@ -136,6 +241,10 @@ export class CameraRig {
       dir, north, start, end,
       t: 0,
       duration,
+      // the orbit framing to dive from / rise back to — the town zoom in TOWN
+      // mode, the wide shot in WORLD mode
+      orbitDist: this.mode === "town" ? TOWN_DIST : WIDE_DIST,
+      townMode: this.mode === "town",
       // phase fractions: dive → glide → rise
       dive: 0.34, glide: 0.40,
     };
@@ -146,11 +255,16 @@ export class CameraRig {
   cancelDescent() {
     if (!this.descent) return;
     this.descent = null;
-    // hand control back to a gentle wide pull
-    this.distT = WIDE_DIST;
-    this.lookT.set(0, 0, 0);
-    this.thetaT = this.theta;
-    this.phiT = this.phi;
+    // hand control back to the mode's resting frame (back over the town in TOWN
+    // mode, a gentle wide pull in WORLD mode)
+    if (this.mode === "town") {
+      this._frameTown();
+    } else {
+      this.distT = WIDE_DIST;
+      this.lookT.set(0, 0, 0);
+      this.thetaT = this.theta;
+      this.phiT = this.phi;
+    }
     this.gazeHold = 0.6;
   }
 
@@ -172,12 +286,13 @@ export class CameraRig {
     const u = clamp(d.t / d.duration, 0, 1);
     // three eased phases sharing one progress value
     let dist, lookDir, lookR;
+    const orbitLookR = d.townMode ? TOWN_LOOK_R : PLANET_R * 0.5;
     if (u < d.dive) {
       // orbit → low point over the start of the glide
       const k = easeInOutCubic(u / d.dive);
-      dist = lerp(WIDE_DIST, this._groundClear(d.start), k);
+      dist = lerp(d.orbitDist, this._groundClear(d.start), k);
       lookDir = d.start.clone();
-      lookR = lerp(PLANET_R * 0.5, DESCENT_CLEAR, k);
+      lookR = lerp(orbitLookR, DESCENT_CLEAR, k);
     } else if (u < d.dive + d.glide) {
       // glide arc: sweep eye + a forward look-ahead along the surface
       const k = (u - d.dive) / d.glide;
@@ -187,12 +302,14 @@ export class CameraRig {
       lookDir = ahead;
       lookR = DESCENT_CLEAR;
     } else {
-      // rise back to orbit, re-acquiring the wide framing
+      // rise back to the resting frame. In TOWN mode re-acquire the close town
+      // look (stay over the town); in WORLD mode pull up to the wide framing.
       const k = easeInOutCubic((u - d.dive - d.glide) / Math.max(1e-3, 1 - d.dive - d.glide));
-      const dir = slerpToOrbit(d.end, k);
-      dist = lerp(this._groundClear(d.end), WIDE_DIST, k);
+      const dir = d.townMode ? slerp(d.end, this.townDir, k) : slerpToOrbit(d.end, k);
+      dist = lerp(this._groundClear(d.end), d.orbitDist, k);
       lookDir = dir;
-      lookR = lerp(DESCENT_CLEAR, 0, k);
+      // TOWN: settle the look just above the town; WORLD: ease the look to center
+      lookR = lerp(DESCENT_CLEAR, d.townMode ? orbitLookR : 0, k);
     }
     // place the eye directly (no spherical-lerp; the descent is the authority)
     const eye = lookDir.clone();
@@ -221,12 +338,14 @@ export class CameraRig {
     if (this.gazeHold > 0) {
       this.gazeHold -= dt;
       if (this.gazeHold <= 0) {
-        this.distT = WIDE_DIST;
-        this.lookT.set(0, 0, 0);
+        // a held gaze expires back to the mode's resting frame
+        if (this.mode === "town") this._frameTown();
+        else { this.distT = WIDE_DIST; this.lookT.set(0, 0, 0); }
       }
-    } else if (this.userHold <= 0) {
-      this.thetaT += this.idleSpeed * dt; // eternal slow orbit
+    } else if (this.userHold <= 0 && this.mode === "world") {
+      this.thetaT += this.idleSpeed * dt; // eternal slow orbit (WORLD only)
     }
+    // TOWN mode holds steady over the town — the town's own life is the motion.
     const k = 1 - Math.exp(-dt * 2.4);
     this.theta = lerp(this.theta, this.thetaT, k);
     this.phi = lerp(this.phi, this.phiT, k);

web/planet/district.js

@@ -0,0 +1,342 @@
+// GODSEED — districts. The build_district tool is the SimCity unlock: ONE call
+// lays down a whole neighbourhood. From the feature's engine seed we
+// deterministically place a cluster of small gabled houses on a rough jittered
+// grid inside radius_deg, lace footpaths between the rows, and drop one civic
+// building (bank / market / tower) at the heart of the block. Houses are drawn
+// as a handful of InstancedMeshes (body, roof, ridge, window) so a dense
+// 8..40-home block stays cheap. Everything is a pure function of (seed, terrain)
+// — no rAF, no Date — so replay and headless capture are byte-stable.
+import * as THREE from "three";
+import { mulberry32 } from "./rng.js";
+import {
+  PLANET_R, DEG, clamp, easeOutBack, uprightQuat, hsl,
+} from "./util.js";
+import { Structure } from "./structures.js";
+
+const WOOD = new THREE.MeshStandardMaterial({ color: 0x2b2118, roughness: 0.9 });
+const ROOF = new THREE.MeshStandardMaterial({ color: 0x191210, roughness: 0.85 });
+const STONE_DARK = new THREE.MeshStandardMaterial({ color: 0x14131c, roughness: 0.6, metalness: 0.3 });
+const PATH = new THREE.MeshStandardMaterial({
+  color: 0x7d6a50, roughness: 0.95, metalness: 0.04, side: THREE.DoubleSide,
+});
+const WARM = new THREE.Color("#ffcf8a");
+
+// civic anchors a district can crown itself with (seeded pick)
+const CIVIC_KINDS = ["bank", "market", "tower"];
+
+class District {
+  constructor(scene, terrain, f, t0, animate) {
+    const a = f.args;
+    this.f = f;
+    this.t0 = t0;
+    this.animate = animate;
+    this.terrain = terrain;
+    this.scene = scene;
+    this.center = new THREE.Vector3();
+    const la = clamp(a.lat ?? 0, -90, 90) * DEG, lo = (a.lon ?? 0) * DEG;
+    this.center.set(Math.cos(la) * Math.cos(lo), Math.sin(la), Math.cos(la) * Math.sin(lo));
+    this.radiusRad = clamp(a.radius_deg ?? 6, 2, 15) * DEG;
+    this.reachRad = this.radiusRad + 0.05;
+    const density = clamp(a.density ?? 0.5, 0, 1);
+    this.hue = a.hue ?? 38;
+    this.warm = hsl(this.hue, 0.6, 0.6).lerp(WARM, 0.5);
+
+    const rng = mulberry32(f.seed);
+    this.rng = rng;
+    this.group = new THREE.Group();
+    scene.add(this.group);
+
+    // density → 8..40 homes. radius limits how many fit on the grid.
+    const want = Math.round(8 + density * 32);
+    this._layout(rng, want);
+    this._buildHouses(rng);
+    this._buildPaths(rng);
+    this._buildCivic(scene, terrain, f, t0, animate);
+
+    if (!animate) this.group.scale.setScalar(1);
+  }
+
+  // ---- jittered grid of house plots inside the cap ------------------------
+  _layout(rng, want) {
+    // tangent basis at the district centre
+    this.t1 = new THREE.Vector3(0, 1, 0);
+    if (Math.abs(this.center.y) > 0.93) this.t1.set(1, 0, 0);
+    this.t2 = new THREE.Vector3().crossVectors(this.center, this.t1).normalize();
+    this.t1.crossVectors(this.t2, this.center).normalize();
+    // a roughly-square grid that fills the cap; keep cells inside the radius
+    const cols = clamp(Math.round(Math.sqrt(want) + 0.5), 3, 8);
+    const rows = clamp(Math.ceil(want / cols), 3, 8);
+    this.cols = cols; this.rows = rows;
+    const span = this.radiusRad * 0.9; // grid half-extent (radians)
+    this.cell = (2 * span) / Math.max(cols, rows);
+    // a seeded street rotation so blocks don't all align to the basis
+    const yaw = rng() * Math.PI * 2;
+    const cy = Math.cos(yaw), sy = Math.sin(yaw);
+    this.plots = []; // {dir, gx, gy, occupied}
+    for (let r = 0; r < rows; r++) {
+      for (let c = 0; c < cols; c++) {
+        const lx = (c - (cols - 1) / 2) * this.cell;
+        const ly = (r - (rows - 1) / 2) * this.cell;
+        // rotate into street grid, then jitter within the plot
+        let ux = lx * cy - ly * sy;
+        let uy = lx * sy + ly * cy;
+        const ang = Math.hypot(ux, uy);
+        if (ang > this.radiusRad * 0.96) continue; // trim corners → rounded block
+        const jx = ux + (rng() - 0.5) * this.cell * 0.34;
+        const jy = uy + (rng() - 0.5) * this.cell * 0.34;
+        const dir = this._tangentDir(jx, jy);
+        this.plots.push({ dir, gx: c, gy: r, raw: [ux, uy] });
+      }
+    }
+    // keep the centre plot clear for the civic building
+    this.plots.sort((p, q) => this._d2(p) - this._d2(q));
+    this.civicPlot = this.plots.shift() || { dir: this.center.clone(), raw: [0, 0] };
+    // density also thins the outer plots so low density reads as a hamlet
+    const keep = clamp(want, 4, this.plots.length);
+    this.plots = this.plots.slice(0, keep);
+    this.yaw = yaw;
+  }
+
+  _d2(p) { return p.raw[0] * p.raw[0] + p.raw[1] * p.raw[1]; }
+
+  _tangentDir(x, y, out = new THREE.Vector3()) {
+    const ang = Math.hypot(x, y);
+    if (ang < 1e-7) return out.copy(this.center);
+    return out.copy(this.center).multiplyScalar(Math.cos(ang))
+      .addScaledVector(this.t2, Math.sin(ang) * (x / ang))
+      .addScaledVector(this.t1, Math.sin(ang) * (y / ang))
+      .normalize();
+  }
+
+  // ---- the homes (instanced) ---------------------------------------------
+  _buildHouses(rng) {
+    const n = this.plots.length;
+    if (n === 0) { this.houseMeshes = []; return; }
+    // five instanced parts make up every home; one InstancedMesh per part.
+    const bodyGeo = new THREE.BoxGeometry(1, 1, 1);
+    const roofGeo = new THREE.BoxGeometry(1, 1, 1);
+    const ridgeGeo = new THREE.BoxGeometry(1, 1, 1);
+    const winGeo = new THREE.PlaneGeometry(1, 1);
+    this.winMat = new THREE.MeshBasicMaterial({ color: this.warm.clone().multiplyScalar(1.7) });
+    const body = new THREE.InstancedMesh(bodyGeo, WOOD, n);
+    const roofL = new THREE.InstancedMesh(roofGeo, ROOF, n);
+    const roofR = new THREE.InstancedMesh(roofGeo, ROOF, n);
+    const ridge = new THREE.InstancedMesh(ridgeGeo, STONE_DARK, n);
+    const win = new THREE.InstancedMesh(winGeo, this.winMat, n);
+    for (const m of [body, roofL, roofR, ridge, win]) {
+      m.frustumCulled = false;
+      this.group.add(m);
+    }
+    this.houseMeshes = [body, roofL, roofR, ridge, win];
+    this.houseGeos = [bodyGeo, roofGeo, ridgeGeo, winGeo];
+
+    const mat = new THREE.Matrix4(), pos = new THREE.Vector3(), quat = new THREE.Quaternion();
+    const scl = new THREE.Vector3(), q2 = new THREE.Quaternion(), local = new THREE.Matrix4();
+    const e = new THREE.Euler();
+    this.plots.forEach((plot, i) => {
+      const dir = plot.dir;
+      const h = this.terrain.heightAt(dir);
+      // home dimensions (same small range as structures.js houseProto)
+      const w = 0.019 + rng() * 0.009, d = 0.016 + rng() * 0.006, ht = 0.013 + rng() * 0.006;
+      const roofH = 0.009 + rng() * 0.004;
+      const yaw = rng() * Math.PI * 2;
+      // world placement: stand the home upright on the surface, spun by yaw
+      pos.copy(dir).multiplyScalar(PLANET_R + h - 0.001);
+      uprightQuat(dir, yaw, quat);
+      plot.center = dir;
+
+      const place = (localPos, localEuler, localScale, target) => {
+        e.copy(localEuler);
+        q2.setFromEuler(e);
+        local.compose(localPos, q2, localScale);
+        mat.compose(pos, quat, new THREE.Vector3(1, 1, 1)).multiply(local);
+        target.setMatrixAt(i, mat);
+      };
+      place(new THREE.Vector3(0, ht / 2, 0), new THREE.Euler(0, 0, 0), new THREE.Vector3(w, ht, d), body);
+      // two roof slabs sloping to a ridge
+      const slopeAng = Math.atan2(roofH, d * 0.5);
+      place(new THREE.Vector3(0, ht + roofH / 2, d * 0.26), new THREE.Euler(slopeAng, 0, 0),
+        new THREE.Vector3(w * 1.04, 0.0025, d * 0.64), roofL);
+      place(new THREE.Vector3(0, ht + roofH / 2, -d * 0.26), new THREE.Euler(-slopeAng, 0, 0),
+        new THREE.Vector3(w * 1.04, 0.0025, d * 0.64), roofR);
+      place(new THREE.Vector3(0, ht + roofH, 0), new THREE.Euler(0, 0, 0),
+        new THREE.Vector3(w * 1.04, 0.0028, 0.0028), ridge);
+      // one lit window on a long face
+      const face = rng() < 0.5 ? 1 : -1;
+      place(new THREE.Vector3((rng() - 0.5) * w * 0.4, ht * 0.52, face * (d / 2 + 0.0006)),
+        new THREE.Euler(0, face < 0 ? Math.PI : 0, 0),
+        new THREE.Vector3(w * 0.34, ht * 0.46, 1), win);
+    });
+    for (const m of this.houseMeshes) m.instanceMatrix.needsUpdate = true;
+  }
+
+  // ---- footpaths: thin matte ribbons threading the block ------------------
+  _buildPaths(rng) {
+    if (this.plots.length < 2) { this.pathMesh = null; return; }
+    // connect each house to the civic centre via a short path, plus a few
+    // neighbour-to-neighbour links → a little web of streets. All flat ribbons
+    // hugging the surface, matte stone (NOT the glowing water look).
+    const segs = [];
+    const hub = this.civicPlot.center || this.center;
+    // trunk paths from civic hub outwards to a handful of homes
+    const trunkN = Math.min(this.plots.length, 4 + Math.floor(rng() * 3));
+    for (let i = 0; i < trunkN; i++) {
+      const p = this.plots[Math.floor(rng() * this.plots.length)];
+      if (p.center) segs.push([hub, p.center]);
+    }
+    // short links between nearby homes so rows read as connected
+    for (let i = 0; i < this.plots.length; i++) {
+      const a = this.plots[i];
+      if (!a.center) continue;
+      let best = null, bestD = Infinity;
+      for (let j = 0; j < this.plots.length; j++) {
+        if (i === j || !this.plots[j].center) continue;
+        const dd = a.center.distanceToSquared(this.plots[j].center);
+        if (dd < bestD) { bestD = dd; best = this.plots[j]; }
+      }
+      if (best && rng() < 0.6) segs.push([a.center, best.center]);
+    }
+    const geo = this._pathGeo(segs);
+    if (!geo) { this.pathMesh = null; return; }
+    this.pathMesh = new THREE.Mesh(geo, PATH);
+    this.pathMesh.frustumCulled = false;
+    this.group.add(this.pathMesh);
+    this.pathGeo = geo;
+    this.pathSegs = segs;
+  }
+
+  _pathGeo(segs) {
+    const positions = [], index = [];
+    const right = new THREE.Vector3(), fwd = new THREE.Vector3(), up = new THREE.Vector3();
+    const a = new THREE.Vector3(), b = new THREE.Vector3();
+    const half = 0.0045; // narrow footpath
+    let base = 0;
+    for (const [da, db] of segs) {
+      fwd.copy(db).sub(da).normalize();
+      const steps = 5;
+      for (let s = 0; s <= steps; s++) {
+        // slerp-ish along the short chord, lifted onto the terrain
+        const t = s / steps;
+        a.copy(da).lerp(db, t).normalize();
+        up.copy(a);
+        right.crossVectors(fwd, up).normalize();
+        const h = this.terrain.heightAt(a);
+        const r = PLANET_R + h + 0.003;
+        for (const side of [-1, 1]) {
+          b.copy(a).multiplyScalar(r).addScaledVector(right, side * half);
+          positions.push(b.x, b.y, b.z);
+        }
+        if (s < steps) {
+          const k = base + s * 2;
+          index.push(k, k + 1, k + 2, k + 1, k + 3, k + 2);
+        }
+      }
+      base += (steps + 1) * 2;
+    }
+    if (positions.length === 0) return null;
+    const g = new THREE.BufferGeometry();
+    g.setAttribute("position", new THREE.Float32BufferAttribute(positions, 3));
+    g.setIndex(index);
+    g.computeVertexNormals();
+    return g;
+  }
+
+  // ---- the civic crown ----------------------------------------------------
+  _buildCivic(scene, terrain, f, t0, animate) {
+    const kind = CIVIC_KINDS[Math.floor(this.rng() * CIVIC_KINDS.length)];
+    const dir = this.civicPlot.center || this.center;
+    // forge a sub-feature so the civic building reuses the full Structure
+    // pipeline (terrain seating, spawn pop, per-frame glow) untouched.
+    const civicSeed = (f.seed ^ 0x9e3779b9) >>> 0;
+    const cf = {
+      seed: civicSeed,
+      args: {
+        lat: Math.asin(clamp(dir.y, -1, 1)) / DEG,
+        lon: Math.atan2(dir.z, dir.x) / DEG,
+        kind,
+        scale: kind === "tower" ? 0.9 : 1.0,
+        hue: this.hue,
+      },
+    };
+    this.civic = new Structure(scene, terrain, cf, t0, animate);
+  }
+
+  update(dt, t) {
+    // grow-in: the whole block scales up with a gentle overshoot on placement
+    if (this.animate) {
+      const k = easeOutBack((t - this.t0) / 1.1);
+      this.group.scale.setScalar(Math.max(0.0001, k));
+      if (t - this.t0 > 1.1) { this.animate = false; this.group.scale.setScalar(1); }
+    }
+    // window flicker across the block (cheap: tint the shared window material)
+    if (this.winMat && this.plots.length) {
+      const k = 1.4 + Math.sin(t * 2.0 + this.f.seed % 7) * 0.18 + Math.sin(t * 5.3) * 0.06;
+      this.winMat.color.copy(this.warm).multiplyScalar(Math.max(0.7, k));
+    }
+    // the civic building runs its own grow-in + spawn pop (Structure pipeline)
+    this.civic?.update(dt, t);
+  }
+
+  // When the terrain beneath the block shifts, rebuild the whole neighbourhood
+  // from the seed — identical to construction, so houses + paths + civic all
+  // re-settle onto the new relief. Terrain reseats are rare, so a clean rebuild
+  // is simpler and safer than patching individual instance matrices.
+  reseat() {
+    this._disposeHouseMeshes();
+    if (this.pathMesh) { this.pathMesh.removeFromParent(); this.pathGeo?.dispose(); this.pathMesh = null; }
+    this.civic?.dispose();
+    const rng = mulberry32(this.f.seed);
+    this.rng = rng;
+    this._layout(rng, Math.round(8 + clamp(this.f.args.density ?? 0.5, 0, 1) * 32));
+    this._buildHouses(rng);
+    this._buildPaths(rng);
+    this._buildCivic(this.scene, this.terrain, this.f, this.t0, false);
+  }
+
+  _disposeHouseMeshes() {
+    for (const m of this.houseMeshes || []) {
+      m.removeFromParent();
+      m.dispose();
+    }
+    for (const g of this.houseGeos || []) g.dispose();
+    this.winMat?.dispose();
+    this.houseMeshes = [];
+  }
+
+  dispose() {
+    this._disposeHouseMeshes();
+    if (this.pathMesh) { this.pathMesh.removeFromParent(); this.pathGeo?.dispose(); }
+    this.civic?.dispose();
+    this.group.removeFromParent();
+  }
+}
+
+export class Districts {
+  constructor(scene, terrain) {
+    this.scene = scene;
+    this.terrain = terrain;
+    this.items = [];
+  }
+
+  /** Apply a build_district feature. @returns the district centre (camera target). */
+  addFeature(f, { animate = true, t = 0 } = {}) {
+    const d = new District(this.scene, this.terrain, f, t, animate);
+    this.items.push(d);
+    return d.center;
+  }
+
+  update(dt, t) {
+    for (const d of this.items) d.update(dt, t);
+  }
+
+  reseat(center, radiusRad) {
+    for (const d of this.items) {
+      if (d.center.angleTo(center) < d.reachRad + radiusRad) d.reseat();
+    }
+  }
+
+  dispose() {
+    for (const d of this.items) d.dispose();
+    this.items = [];
+  }
+}

web/planet/roads.js

@@ -0,0 +1,193 @@
+// GODSEED — roads. The place_road tool lays a paved ribbon ON the surface,
+// following the great-circle path between its waypoints. Deliberately the
+// opposite of place_water's glowing cyan streams: warm stone/amber, MATTE
+// (a MeshStandardMaterial that catches the sky light, not additive glow), a
+// slightly raised ribbon, and a faint dashed amber centreline so it reads as a
+// paved road at the close town-zoom. Deterministic + headless-safe: the only
+// time-driven motion is a gentle reveal eased by sim-time on placement.
+import * as THREE from "three";
+import {
+  PLANET_R, DEG, clamp, easeOutCubic, slerpDirs, angleBetween,
+} from "./util.js";
+
+const REVEAL = 1.8;
+const STONE_ROAD = new THREE.Color("#8a7458"); // warm dry stone
+const STONE_EDGE = new THREE.Color("#5a4836"); // darker kerb
+
+class Road {
+  constructor(scene, terrain, f, t0, animate) {
+    this.f = f;
+    this.t0 = t0;
+    this.animate = animate;
+    this.terrain = terrain;
+    this.scene = scene;
+    const path = (f.args.path || []).slice(0, 6);
+    this.waypoints = path.map(([lat, lon]) => {
+      const la = clamp(lat, -90, 90) * DEG, lo = lon * DEG;
+      return new THREE.Vector3(Math.cos(la) * Math.cos(lo), Math.sin(la), Math.cos(la) * Math.sin(lo));
+    });
+    while (this.waypoints.length < 2) {
+      this.waypoints.push((this.waypoints[0] || new THREE.Vector3(1, 0, 0)).clone());
+    }
+    this.center = this.waypoints[0].clone();
+    this.reachRad = 0.06;
+    for (const w of this.waypoints) this.reachRad = Math.max(this.reachRad, angleBetween(this.center, w));
+
+    this.width = 0.018; // half-width of the ribbon, in radians-scaled world units
+
+    // matte paved deck: lit by the scene, never emissive (distinct from water)
+    this.deckMat = new THREE.MeshStandardMaterial({
+      color: STONE_ROAD, roughness: 0.92, metalness: 0.05,
+      transparent: true, opacity: 0, side: THREE.DoubleSide,
+    });
+    // a faint warm centreline; dashed via alpha in the shader-free way: a thin
+    // additive strip whose opacity is modulated along its length by the vUv.
+    this.lineMat = new THREE.ShaderMaterial({
+      transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, side: THREE.DoubleSide,
+      uniforms: { uReveal: { value: animate ? 0 : 1 }, uLen: { value: 1 }, uColor: { value: new THREE.Color("#ffca7a") } },
+      vertexShader: /* glsl */ `
+        varying vec2 vUv;
+        void main(){ vUv = uv; gl_Position = projectionMatrix*modelViewMatrix*vec4(position,1.0); }`,
+      fragmentShader: /* glsl */ `
+        varying vec2 vUv; uniform float uReveal, uLen; uniform vec3 uColor;
+        void main(){
+          if (vUv.x > uReveal) discard;
+          // dashed centreline: bright dash / dark gap repeating along length
+          float dash = step(0.5, fract(vUv.x * uLen * 26.0));
+          // soft edge across the (thin) line width
+          float across = smoothstep(0.0, 0.5, vUv.y) * smoothstep(1.0, 0.5, vUv.y);
+          float a = dash * across * 0.7;
+          gl_FragColor = vec4(uColor, a);
+        }`,
+    });
+
+    const { deckGeo, lineGeo, lengthRad } = this._buildGeo();
+    this.lineMat.uniforms.uLen.value = Math.max(0.5, lengthRad / DEG / 18);
+    this.deck = new THREE.Mesh(deckGeo, this.deckMat);
+    this.deck.frustumCulled = false;
+    this.line = new THREE.Mesh(lineGeo, this.lineMat);
+    this.line.frustumCulled = false;
+    this.group = new THREE.Group();
+    this.group.add(this.deck);
+    this.group.add(this.line);
+    scene.add(this.group);
+    if (!animate) this.deckMat.opacity = 0.95;
+  }
+
+  // dense great-circle samples lifted onto the terrain surface, with a tangent
+  // "right" vector at each so we can extrude a flat ribbon that hugs curvature.
+  _samples() {
+    const dirs = [];
+    for (let i = 0; i < this.waypoints.length - 1; i++) {
+      const a = this.waypoints[i], b = this.waypoints[i + 1];
+      const steps = Math.max(6, Math.ceil(angleBetween(a, b) / (1.4 * DEG)));
+      for (let s = i === 0 ? 0 : 1; s <= steps; s++) {
+        dirs.push(slerpDirs(a, b, s / steps, new THREE.Vector3()).normalize());
+      }
+    }
+    return dirs;
+  }
+
+  _ribbon(dirs, halfWidth, lift) {
+    // returns {positions, uvs, index, lengthRad}: a strip of quads along the path
+    const positions = [], uvs = [], index = [];
+    const right = new THREE.Vector3(), fwd = new THREE.Vector3(), up = new THREE.Vector3();
+    // arc-length parameterisation for stable centreline dashing
+    let lengthRad = 0;
+    const cum = [0];
+    for (let i = 1; i < dirs.length; i++) {
+      lengthRad += angleBetween(dirs[i - 1], dirs[i]);
+      cum.push(lengthRad);
+    }
+    for (let i = 0; i < dirs.length; i++) {
+      const d = dirs[i];
+      const dn = dirs[Math.min(i + 1, dirs.length - 1)];
+      const dp = dirs[Math.max(i - 1, 0)];
+      fwd.copy(dn).sub(dp).normalize();
+      up.copy(d);
+      right.crossVectors(fwd, up).normalize();
+      const h = this.terrain.heightAt(d);
+      const r = PLANET_R + h + lift;
+      const u = lengthRad > 1e-6 ? cum[i] / lengthRad : i / Math.max(1, dirs.length - 1);
+      for (const side of [-1, 1]) {
+        const p = d.clone().multiplyScalar(r).addScaledVector(right, side * halfWidth);
+        positions.push(p.x, p.y, p.z);
+        uvs.push(u, side < 0 ? 0 : 1);
+      }
+      if (i < dirs.length - 1) {
+        const k = i * 2;
+        index.push(k, k + 1, k + 2, k + 1, k + 3, k + 2);
+      }
+    }
+    return { positions, uvs, index, lengthRad };
+  }
+
+  _buildGeo() {
+    const dirs = this._samples();
+    const deck = this._ribbon(dirs, this.width, 0.004);
+    const line = this._ribbon(dirs, this.width * 0.22, 0.0052); // thin strip, just above the deck
+    const mk = (r) => {
+      const g = new THREE.BufferGeometry();
+      g.setAttribute("position", new THREE.Float32BufferAttribute(r.positions, 3));
+      g.setAttribute("uv", new THREE.Float32BufferAttribute(r.uvs, 2));
+      g.setIndex(r.index);
+      g.computeVertexNormals();
+      return g;
+    };
+    return { deckGeo: mk(deck), lineGeo: mk(line), lengthRad: deck.lengthRad };
+  }
+
+  reseat() {
+    const { deckGeo, lineGeo } = this._buildGeo();
+    this.deck.geometry.dispose();
+    this.line.geometry.dispose();
+    this.deck.geometry = deckGeo;
+    this.line.geometry = lineGeo;
+  }
+
+  update(dt, t) {
+    if (this.animate) {
+      const k = easeOutCubic((t - this.t0) / REVEAL);
+      this.deckMat.opacity = 0.95 * k;
+      this.lineMat.uniforms.uReveal.value = k;
+    }
+  }
+
+  dispose() {
+    this.group.removeFromParent();
+    this.deck.geometry.dispose();
+    this.line.geometry.dispose();
+    this.deckMat.dispose();
+    this.lineMat.dispose();
+  }
+}
+
+export class Roads {
+  constructor(scene, terrain) {
+    this.scene = scene;
+    this.terrain = terrain;
+    this.items = [];
+  }
+
+  /** Apply a place_road feature. @returns the road's first waypoint (camera target). */
+  addFeature(f, { animate = true, t = 0 } = {}) {
+    const road = new Road(this.scene, this.terrain, f, t, animate);
+    this.items.push(road);
+    return road.center;
+  }
+
+  update(dt, t) {
+    for (const r of this.items) r.update(dt, t);
+  }
+
+  reseat(center, radiusRad) {
+    for (const r of this.items) {
+      if (angleBetween(r.center, center) < r.reachRad + radiusRad) r.reseat();
+    }
+  }
+
+  dispose() {
+    for (const r of this.items) r.dispose();
+    this.items = [];
+  }
+}

web/planet/structures.js

@@ -71,14 +71,17 @@ function buildLighthouse(rng, color) {
   const roof = new THREE.Mesh(new THREE.ConeGeometry(0.017, 0.024, 8), STONE_DARK);
   roof.position.y = 0.197;
   g.add(roof);
-  // rotating double beam
+  // rotating double beam — tamed to ~60% so it no longer dominates the frame
+  // from orbit; the rotating sweep + pulsing lantern keep it legible up close.
   const beams = new THREE.Group();
   beams.position.y = 0.173;
+  const beamCones = [];
   for (const s of [1, -1]) {
-    const cone = new THREE.Mesh(new THREE.ConeGeometry(0.05, 0.7, 12, 1, true), beamMat(color, 0.16));
+    const cone = new THREE.Mesh(new THREE.ConeGeometry(0.028, 0.34, 12, 1, true), beamMat(color, 0.1));
     cone.rotation.z = s * (Math.PI / 2);
-    cone.position.x = s * 0.35;
+    cone.position.x = s * 0.17;
     beams.add(cone);
+    beamCones.push(cone);
   }
   g.add(beams);
   const light = new THREE.PointLight(color.getHex(), 0.7, 1.2, 1.8);
@@ -203,11 +206,13 @@ function buildBeacon(rng, color) {
   const crystal = new THREE.Mesh(new THREE.OctahedronGeometry(0.019, 0), crystalMat);
   crystal.position.y = 0.085;
   g.add(crystal);
-  const pillarInner = new THREE.Mesh(new THREE.CylinderGeometry(0.006, 0.011, 1.3, 8, 1, true), beamMat(color, 0.3));
-  pillarInner.position.y = 0.73;
+  // light pillars tamed to ~60% height so the beacon reads as a town landmark,
+  // not an orbit-dominating needle (still a tall glowing shaft up close).
+  const pillarInner = new THREE.Mesh(new THREE.CylinderGeometry(0.006, 0.011, 0.52, 8, 1, true), beamMat(color, 0.3));
+  pillarInner.position.y = 0.34;
   g.add(pillarInner);
-  const pillarOuter = new THREE.Mesh(new THREE.CylinderGeometry(0.018, 0.03, 1.0, 10, 1, true), beamMat(color, 0.1));
-  pillarOuter.position.y = 0.58;
+  const pillarOuter = new THREE.Mesh(new THREE.CylinderGeometry(0.018, 0.03, 0.4, 10, 1, true), beamMat(color, 0.1));
+  pillarOuter.position.y = 0.28;
   g.add(pillarOuter);
   g.add(groundHalo(color, 0.05, 0.3));
   const phase = rng() * 6.28;
@@ -455,6 +460,183 @@ function buildCafe(rng, color, ctx) {
   };
 }
 
+// ---------------------------------------------------------------- town kit
+// bank | market | house — the Town Mode civic + domestic set. Same diorama
+// soul: low-poly stone/wood bodies, warm emissive accents, seeded variation.
+// `house` is the atom of a town; district.js reuses `houseProto()` so a lone
+// place_structure house and the homes in a neighbourhood read identically.
+
+const WARM = new THREE.Color("#ffcf8a"); // shared "lamp" warm for town glows
+
+// A single small gabled home: body + roof + one lit window. Returns the mesh
+// parts plus the warm window material so callers can flicker it. Local base at
+// y=0, +Y up; sized in the same ~0.02 range as village huts. `s` scales it.
+export function houseProto(rng, color, s = 1) {
+  const g = new THREE.Group();
+  const w = (0.019 + rng() * 0.008) * s, d = (0.016 + rng() * 0.006) * s;
+  const h = (0.013 + rng() * 0.005) * s;
+  const body = new THREE.Mesh(new THREE.BoxGeometry(w, h, d), WOOD);
+  body.position.y = h / 2;
+  g.add(body);
+  const roofH = (0.009 + rng() * 0.004) * s;
+  // gabled roof: two sloped slabs meeting at a ridge (reads as a peaked home)
+  for (const side of [1, -1]) {
+    const slope = new THREE.Mesh(new THREE.BoxGeometry(w * 1.04, 0.0025, d * 0.64), ROOF);
+    slope.position.set(0, h + roofH / 2, side * d * 0.26);
+    slope.rotation.x = side * Math.atan2(roofH, d * 0.5);
+    g.add(slope);
+  }
+  const ridge = new THREE.Mesh(new THREE.BoxGeometry(w * 1.04, 0.0028, 0.0028), STONE_DARK);
+  ridge.position.y = h + roofH;
+  g.add(ridge);
+  // one warm lit window on a long face
+  const warm = color.clone().lerp(WARM, 0.55);
+  const winMat = glow(warm, 1.8);
+  const win = new THREE.Mesh(new THREE.PlaneGeometry(w * 0.34, h * 0.46), winMat);
+  const face = rng() < 0.5 ? 1 : -1;
+  win.position.set((rng() - 0.5) * w * 0.4, h * 0.52, face * (d / 2 + 0.0006));
+  if (face < 0) win.rotation.y = Math.PI;
+  g.add(win);
+  return { group: g, winMat, warm, footprint: Math.max(w, d) };
+}
+
+function buildHouse(rng, color) {
+  const proto = houseProto(rng, color, 1.0);
+  const g = proto.group;
+  g.add(groundHalo(proto.warm, 0.03, 0.16));
+  const phase = rng() * 6.28, speed = 2.4 + rng() * 3;
+  return {
+    group: g,
+    accents: [proto.winMat],
+    update: (dt, t) => {
+      const k = 1.45 + Math.sin(t * speed + phase) * 0.3;
+      proto.winMat.color.copy(proto.warm).multiplyScalar(Math.max(0.7, k));
+    },
+  };
+}
+
+function buildBank(rng, color) {
+  // a stately columned block: wide stone body, a row of front columns under a
+  // pediment, warm-lit doorway between them. The civic anchor of a town.
+  const g = new THREE.Group();
+  const w = 0.058 + rng() * 0.014, d = 0.04 + rng() * 0.01, h = 0.03 + rng() * 0.008;
+  const body = new THREE.Mesh(new THREE.BoxGeometry(w, h, d), STONE);
+  body.position.y = h / 2;
+  g.add(body);
+  // stepped base
+  const base = new THREE.Mesh(new THREE.BoxGeometry(w * 1.16, 0.008, d * 1.18), STONE_DARK);
+  base.position.y = 0.004;
+  g.add(base);
+  // a portico of columns across the front
+  const cols = 4 + Math.floor(rng() * 2);
+  const front = d / 2 + 0.006;
+  for (let i = 0; i < cols; i++) {
+    const cx = (i / (cols - 1) - 0.5) * w * 0.82;
+    const col = new THREE.Mesh(new THREE.CylinderGeometry(0.0045, 0.0052, h * 0.92, 8), STONE);
+    col.position.set(cx, h * 0.46 + 0.008, front);
+    g.add(col);
+  }
+  // pediment (triangular cap) over the columns
+  const ped = new THREE.Mesh(new THREE.CylinderGeometry(0.006, w * 0.5, 0.012, 3), STONE_DARK);
+  ped.rotation.y = Math.PI / 2;
+  ped.scale.set(1, 1, 0.5);
+  ped.position.set(0, h + 0.012, front);
+  g.add(ped);
+  const roof = new THREE.Mesh(new THREE.BoxGeometry(w * 1.04, 0.005, d * 1.04), ROOF);
+  roof.position.y = h + 0.0025;
+  g.add(roof);
+  // warm-lit doorway between the central columns + spill on the steps
+  const warm = color.clone().lerp(WARM, 0.5);
+  const doorMat = glow(warm, 1.7);
+  const door = new THREE.Mesh(new THREE.PlaneGeometry(w * 0.16, h * 0.62), doorMat);
+  door.position.set(0, h * 0.36, front + 0.0006);
+  g.add(door);
+  const spill = new THREE.Mesh(new THREE.CircleGeometry(0.042, 18), beamMat(warm, 0.32));
+  spill.rotation.x = -Math.PI / 2;
+  spill.position.set(0, 0.005, front + 0.02);
+  spill.scale.set(1, 1.3, 1);
+  g.add(spill);
+  const light = new THREE.PointLight(warm.getHex(), 0.5, 0.6, 1.9);
+  light.position.set(0, h * 0.5, front + 0.02);
+  g.add(light);
+  const phase = rng() * 6.28;
+  return {
+    group: g,
+    accents: [doorMat],
+    update: (dt, t) => {
+      const k = 1.4 + Math.sin(t * 1.8 + phase) * 0.22;
+      doorMat.color.copy(warm).multiplyScalar(k);
+      light.intensity = 0.42 + Math.sin(t * 1.8 + phase) * 0.12;
+      spill.material.opacity = 0.26 + Math.sin(t * 1.8 + phase) * 0.06;
+    },
+  };
+}
+
+function buildMarket(rng, color) {
+  // an open cluster of stalls under striped awnings, warm glow underneath and
+  // a scatter of produce/lantern dots. Reads as a busy little marketplace.
+  const g = new THREE.Group();
+  const warm = color.clone().lerp(WARM, 0.45);
+  const glowMats = [];
+  const stalls = 4 + Math.floor(rng() * 3);
+  for (let i = 0; i < stalls; i++) {
+    const stall = new THREE.Group();
+    const ang = rng() * Math.PI * 2;
+    const rad = 0.01 + rng() * 0.05;
+    const sw = 0.018 + rng() * 0.008, sd = 0.016 + rng() * 0.006;
+    // four thin posts
+    for (const [sx, sz] of [[-1, -1], [1, -1], [-1, 1], [1, 1]]) {
+      const post = new THREE.Mesh(new THREE.CylinderGeometry(0.0016, 0.0016, 0.02, 5), WOOD);
+      post.position.set(sx * sw * 0.5, 0.01, sz * sd * 0.5);
+      stall.add(post);
+    }
+    // a striped awning canopy tilted over the stall
+    const aHue = color.clone().lerp(new THREE.Color(rng() < 0.5 ? "#e8643c" : "#d8a23c"), 0.6);
+    const awnMat = new THREE.MeshStandardMaterial({
+      color: aHue.multiplyScalar(0.7), roughness: 0.8, side: THREE.DoubleSide, emissive: aHue, emissiveIntensity: 0.25,
+    });
+    const awn = new THREE.Mesh(new THREE.PlaneGeometry(sw * 1.25, sd * 1.25), awnMat);
+    awn.rotation.x = -Math.PI / 2 + (rng() - 0.5) * 0.3;
+    awn.position.y = 0.021;
+    stall.add(awn);
+    // a glowing tabletop of wares under the canopy
+    const wareMat = glow(warm, 1.4);
+    const ware = new THREE.Mesh(new THREE.BoxGeometry(sw * 0.8, 0.003, sd * 0.8), wareMat);
+    ware.position.y = 0.012;
+    stall.add(ware);
+    glowMats.push(wareMat);
+    stall.position.set(Math.cos(ang) * rad, 0, Math.sin(ang) * rad);
+    stall.rotation.y = rng() * Math.PI * 2;
+    g.add(stall);
+  }
+  // hanging lanterns / produce dots scattered between stalls
+  const dotMat = glow(WARM.clone(), 1.6);
+  const nDots = 5 + Math.floor(rng() * 5);
+  const dots = new THREE.InstancedMesh(new THREE.SphereGeometry(0.0028, 6, 5), dotMat, nDots);
+  dots.frustumCulled = false;
+  const m = new THREE.Matrix4(), p = new THREE.Vector3(), q = new THREE.Quaternion(), sc = new THREE.Vector3(1, 1, 1);
+  for (let i = 0; i < nDots; i++) {
+    const ang = rng() * Math.PI * 2, rad = 0.01 + rng() * 0.055;
+    p.set(Math.cos(ang) * rad, 0.006 + rng() * 0.016, Math.sin(ang) * rad);
+    m.compose(p, q, sc);
+    dots.setMatrixAt(i, m);
+  }
+  dots.instanceMatrix.needsUpdate = true;
+  g.add(dots);
+  g.add(groundHalo(warm, 0.075, 0.18));
+  const phase = rng() * 6.28;
+  return {
+    group: g,
+    accents: [...glowMats, dotMat],
+    ownGeo: [dots.geometry],
+    update: (dt, t) => {
+      const k = 1.35 + Math.sin(t * 2.1 + phase) * 0.16 + Math.sin(t * 5.7) * 0.06;
+      for (const mat of glowMats) mat.color.copy(warm).multiplyScalar(k);
+      dotMat.color.copy(WARM).multiplyScalar(1.4 + Math.sin(t * 3.3 + phase) * 0.3);
+    },
+  };
+}
+
 const BUILDERS = {
   lighthouse: buildLighthouse,
   monolith: buildMonolith,
@@ -465,10 +647,15 @@ const BUILDERS = {
   tower: buildTower,
   warehouse: buildWarehouse,
   cafe: buildCafe,
+  bank: buildBank,
+  market: buildMarket,
+  house: buildHouse,
 };
 
 // ---------------------------------------------------------------- manager
-class Structure {
+// Exported so district.js can reuse the full structure pipeline (terrain
+// seating, spawn pop, per-frame glow) for a district's lone civic building.
+export class Structure {
   constructor(scene, terrain, f, t0, animate) {
     const a = f.args;
     this.f = f;

web/planet/util.js

@@ -82,3 +82,40 @@ export function ordinal(n) {
   const v = n % 100;
   return n + (s[(v - 20) % 10] || s[v] || s[0]);
 }
+
+// --- the town anchor (engine + renderer compute IDENTICALLY) -----------------
+// The genesis monolith — the fallback heart of the world before any building.
+export const GENESIS_MONOLITH = { lat: 14, lon: 38 };
+
+/**
+ * townCenter(features) → { dir: THREE.Vector3 (unit), lat, lon }.
+ *
+ * The seeded centroid of the town: the unit-vector mean (renormalized) of the
+ * directions of every non-genesis `place_structure` + `build_district` feature.
+ * This is the heart the camera frames and the HUD names. When no town has been
+ * built yet, it falls back to the genesis monolith at lat 14, lon 38.
+ *
+ * Must match Agent A's engine algorithm exactly — the live shared world and the
+ * client agree on where "the town" is, so the default view is deterministic.
+ */
+export function townCenter(features, out = new THREE.Vector3()) {
+  const sum = out.set(0, 0, 0);
+  const d = _t1;
+  let n = 0;
+  for (const f of features || []) {
+    if (!f || f.wish_id === "genesis") continue;
+    if (f.tool !== "place_structure" && f.tool !== "build_district") continue;
+    const a = f.args || {};
+    if (a.lat == null || a.lon == null) continue;
+    latLonToDir(a.lat, a.lon, d);
+    sum.add(d);
+    n++;
+  }
+  if (n === 0 || sum.lengthSq() < 1e-9) {
+    latLonToDir(GENESIS_MONOLITH.lat, GENESIS_MONOLITH.lon, sum);
+  } else {
+    sum.normalize();
+  }
+  const { lat, lon } = dirToLatLon(sum);
+  return { dir: sum, lat, lon };
+}

web/planet/world.js

@@ -5,6 +5,8 @@ import * as THREE from "three";
 import { Terrain } from "./terrain.js";
 import { Flora } from "./flora.js";
 import { Structures } from "./structures.js";
+import { Districts } from "./district.js";
+import { Roads } from "./roads.js";
 import { Water } from "./water.js";
 import { Life } from "./life.js";
 import { Weather } from "./weather.js";
@@ -27,6 +29,8 @@ export class World {
     this.terrain = new Terrain(this.scene, { detail: this.quality.detail });
     this.flora = new Flora(this.scene, this.terrain, this.quality);
     this.structures = new Structures(this.scene, this.terrain);
+    this.districts = new Districts(this.scene, this.terrain);
+    this.roads = new Roads(this.scene, this.terrain);
     this.water = new Water(this.scene, this.terrain);
     this.life = new Life(this.scene, this.terrain, this.water);
     this.inscriptions = new Inscriptions(this.scene, this.terrain);
@@ -59,6 +63,12 @@ export class World {
       case "place_structure":
         target = this.structures.addFeature(f, { animate, t });
         break;
+      case "build_district":
+        target = this.districts.addFeature(f, { animate, t });
+        break;
+      case "place_road":
+        target = this.roads.addFeature(f, { animate, t });
+        break;
       case "place_water":
         target = this.water.addFeature(f, { animate, t });
         break;
@@ -89,6 +99,8 @@ export class World {
   reset(features, t = 0) {
     this.flora.dispose();
     this.structures.dispose();
+    this.districts.dispose();
+    this.roads.dispose();
     this.water.dispose();
     this.life.dispose();
     this.inscriptions.dispose();
@@ -109,12 +121,16 @@ export class World {
     for (const c of changed) {
       this.flora.reseat(c.center, c.radiusRad);
       this.structures.reseat(c.center, c.radiusRad);
+      this.districts.reseat(c.center, c.radiusRad);
+      this.roads.reseat(c.center, c.radiusRad);
       this.water.reseat(c.center, c.radiusRad);
       this.life.reseat(c.center, c.radiusRad);
       this.inscriptions.reseat(c.center, c.radiusRad);
     }
     this.flora.update(dt, t);
     this.structures.update(dt, t);
+    this.districts.update(dt, t);
+    this.roads.update(dt, t);
     this.water.update(dt, t);
     this.life.update(dt, t);
     this.weather.update(dt, t);

web/style.css

@@ -85,7 +85,9 @@ html, body {
 
 /* ---------- epoch + log link ---------- */
 .almanac {
-  position: fixed; top: 38px; right: 42px; z-index: 11; text-align: right;
+  position: fixed; top: 38px; right: 42px; z-index: 11;
+  display: flex; flex-direction: column; align-items: flex-end;
+  text-align: right;
 }
 .almanac__epoch {
   font-size: 11px;
@@ -107,6 +109,40 @@ html, body {
 }
 .almanac__log:hover { color: var(--gold-bright); border-color: var(--gold); }
 
+/* behold the world ↕ — the close-town ⇄ whole-planet toggle */
+.behold {
+  display: inline-flex; align-items: center; gap: 9px;
+  margin-top: 14px;
+  padding: 7px 15px;
+  font-family: var(--sans);
+  font-size: 9.5px; letter-spacing: 0.26em; text-transform: uppercase;
+  color: var(--ivory-dim);
+  background: var(--panel);
+  border: 1px solid var(--hairline);
+  border-radius: 999px;
+  cursor: pointer;
+  pointer-events: auto;
+  -webkit-backdrop-filter: blur(8px);
+  backdrop-filter: blur(8px);
+  transition: color 0.25s, border-color 0.25s, box-shadow 0.25s;
+}
+.behold:hover {
+  color: var(--gold-bright);
+  border-color: var(--gold);
+  box-shadow: 0 0 24px rgba(217, 179, 108, 0.14);
+}
+.behold__label { line-height: 1; }
+.behold__sigil {
+  font-size: 12px; line-height: 1; color: var(--gold);
+  transition: transform 0.4s ease;
+}
+/* while beholding the world the control offers the way back — flip the sigil */
+.behold.is-world {
+  color: var(--gold);
+  border-color: var(--gold);
+}
+.behold.is-world .behold__sigil { transform: rotate(180deg); }
+
 /* ---------- the god speaks ---------- */
 .voice {
   position: fixed; left: 42px; bottom: 42px; z-index: 10;