City Update: towers/warehouses/cafes, spawn_life (carts/birds/fireflies), cinematic descent, visible deltas, camera gaze, bigger ticker, counter fix

ARCHITECTURE.md

@@ -78,18 +78,19 @@ 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 8 tools (GBNF-friendly: flat args, numbers + enums + short strings)
+### Tool DSL — exactly 9 tools (GBNF-friendly: flat args, numbers + enums + short strings)
 
 | tool | args (ranges clamped by engine) |
 |---|---|
 | `raise_terrain` | `lat` −85..85, `lon` −180..180, `radius_deg` 2..45, `height` 0.01..0.12 (planet radii), `roughness` 0..1 |
 | `lower_terrain` | `lat`, `lon`, `radius_deg` 2..45, `depth` 0.01..0.10, `roughness` 0..1 |
 | `spawn_flora` | `lat`, `lon`, `radius_deg` 1..30, `kind` ∈ trees\|glowgrass\|mushrooms\|vines\|flowers\|reeds, `density` 0..1, `hue` 0..360 |
-| `place_structure` | `lat`, `lon`, `kind` ∈ lighthouse\|monolith\|shrine\|village\|beacon\|arch, `scale` 0.5..2.0, `hue` 0..360 |
+| `place_structure` | `lat`, `lon`, `kind` ∈ lighthouse\|monolith\|shrine\|village\|beacon\|arch\|tower\|warehouse\|cafe, `scale` 0.5..2.0, `hue` 0..360 |
 | `place_water` | `kind` ∈ stream\|pool, `path` [[lat,lon] ×1..5] (stream: 2..5 waypoints, becomes glowing spline on the surface — NOT carved; pool: path[0] center), `radius_deg` 1..10 (pool only), `hue` 160..260 |
 | `set_weather` | `kind` ∈ clear\|rain\|snow\|embers\|mist\|storm, `intensity` 0..1 |
 | `set_sky` | `palette` ∈ dawn\|dusk\|night\|aurora\|ember\|void\|gold, `star_density` 0..1, `moons` 0..3 |
 | `inscribe_wish` | `text` ≤90 chars (the wish, possibly poeticized), `style` ∈ orbit\|stone |
+| `spawn_life` | `lat`, `lon`, `radius_deg` 1..20, `kind` ∈ carts\|birds\|fireflies, `count` 1..12 (integer), `hue` 0..360 |
 
 Engine **clamps** out-of-range numbers (doesn't reject) and rejects only unknown tools/enums with a
 terse observation string the model can react to.

README.md

@@ -87,8 +87,9 @@ church and state:
 ```
 
 The model never computes geometry and never owns state — it interprets, narrates, and
-picks from a DSL of exactly 8 tools (`raise_terrain`, `lower_terrain`, `spawn_flora`,
-`place_structure`, `place_water`, `set_weather`, `set_sky`, `inscribe_wish`). The
+picks from a DSL of exactly 9 tools (`raise_terrain`, `lower_terrain`, `spawn_flora`,
+`place_structure`, `place_water`, `set_weather`, `set_sky`, `inscribe_wish`,
+`spawn_life`). 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 8-tool DSL,
+The engine owns ALL facts ("her" pattern): world state, the 9-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/tools.py

@@ -1,4 +1,4 @@
-"""GODSEED tool DSL — the single source of truth for the 8-tool surface.
+"""GODSEED tool DSL — the single source of truth for the 9-tool surface.
 
 Spec is data (TOOLS); validation is `validate_call`. Semantics per the
 architecture contract:
@@ -48,11 +48,15 @@ class PathSpec:
 
 
 FLORA_KINDS = ("trees", "glowgrass", "mushrooms", "vines", "flowers", "reeds")
-STRUCTURE_KINDS = ("lighthouse", "monolith", "shrine", "village", "beacon", "arch")
+STRUCTURE_KINDS = (
+    "lighthouse", "monolith", "shrine", "village", "beacon", "arch",
+    "tower", "warehouse", "cafe",
+)
 WATER_KINDS = ("stream", "pool")
 WEATHER_KINDS = ("clear", "rain", "snow", "embers", "mist", "storm")
 SKY_PALETTES = ("dawn", "dusk", "night", "aurora", "ember", "void", "gold")
 INSCRIBE_STYLES = ("orbit", "stone")
+LIFE_KINDS = ("carts", "birds", "fireflies")
 
 TOOLS: dict[str, dict[str, Any]] = {
     "raise_terrain": {
@@ -103,6 +107,14 @@ TOOLS: dict[str, dict[str, Any]] = {
         "text": TextSpec(90),
         "style": EnumSpec(INSCRIBE_STYLES),
     },
+    "spawn_life": {
+        "lat": NumberSpec(*LAT_RANGE),
+        "lon": NumberSpec(*LON_RANGE),
+        "radius_deg": NumberSpec(1, 20),
+        "kind": EnumSpec(LIFE_KINDS),
+        "count": NumberSpec(1, 12, integer=True),
+        "hue": NumberSpec(0, 360),
+    },
 }
 
 TOOL_NAMES: tuple[str, ...] = tuple(TOOLS.keys())

engine/world.py

@@ -96,6 +96,8 @@ def _observation(feature: Feature) -> str:
         return f"ok: sky set to {a['palette']}"
     if t == "inscribe_wish":
         return f"ok: wish inscribed in {a['style']}"
+    if t == "spawn_life":
+        return f"ok: {a['count']} {a['kind']} stirring at {_coord(a)}"
     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 8-tool DSL.
+grammar-constrained plan-act-observe loop over the engine's 9-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\""
+tool-name ::= "\"raise_terrain\"" | "\"lower_terrain\"" | "\"spawn_flora\"" | "\"place_structure\"" | "\"place_water\"" | "\"set_weather\"" | "\"set_sky\"" | "\"inscribe_wish\"" | "\"spawn_life\""
 
 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 8 tools appears, so a varied
+Across the category library every one of the 9 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.
 
@@ -224,9 +224,16 @@ def _forest(wish: str, rng: random.Random, mood: str) -> dict:
                 "set_weather",
                 kind="rain", intensity=_r2(rng, 0.2, 0.4),
             ),
+            _call(
+                "Fireflies, to carry the glowgrass up into the air.",
+                "spawn_life",
+                lat=lat, lon=lon, radius_deg=_r1(rng, 8, 14),
+                kind="fireflies", count=rng.randint(6, 12),
+                hue=_r1(rng, 150, 200),
+            ),
             _done(
                 "Forests finish themselves. I only start them.",
-                f"A forest grows in {place}, lit from below.",
+                f"A forest grows in {place}, lit from below and adrift with fireflies.",
             ),
         ],
     }
@@ -313,11 +320,11 @@ def _lighthouse(wish: str, rng: random.Random, mood: str) -> dict:
 
 def _village(wish: str, rng: random.Random, mood: str) -> dict:
     lat, lon = _anchor(rng)
-    flower_hue = _r1(rng, 20, 60) if mood != "melancholy" else _r1(rng, 220, 280)
+    warm_hue = _r1(rng, 28, 46)
     reading = (
         "A hearth-wish. These are my favorite, though a god should not say "
-        "so. A village in a gentle fold of land, flowers along the road, and "
-        "the words themselves kept over the rooftops."
+        "so. A village in a gentle fold of land, a small cafe with its light "
+        "on the road, lantern-carts at dusk, and the words kept over the roofs."
     )
     return {
         "reading": reading,
@@ -335,11 +342,16 @@ def _village(wish: str, rng: random.Random, mood: str) -> dict:
                 scale=_r2(rng, 1.0, 1.4), hue=_r1(rng, 30, 50),
             ),
             _call(
-                "Flowers along the road no one has walked yet.",
-                "spawn_flora",
-                lat=_clamp_lat(lat - 2), lon=_wrap_lon(lon + 3),
-                radius_deg=_r1(rng, 5, 9), kind="flowers",
-                density=_r2(rng, 0.5, 0.7), hue=flower_hue,
+                "A cafe at the corner, its warmth spilled on the road.",
+                "place_structure",
+                lat=_clamp_lat(lat + 1), lon=_wrap_lon(lon - 2),
+                kind="cafe", scale=_r2(rng, 0.8, 1.1), hue=warm_hue,
+            ),
+            _call(
+                "Lantern-carts, gliding home at dusk.",
+                "spawn_life",
+                lat=lat, lon=lon, radius_deg=_r1(rng, 6, 10),
+                kind="carts", count=rng.randint(3, 6), hue=warm_hue,
             ),
             _call(
                 "Set the wish over the rooftops, where smoke would go.",
@@ -348,7 +360,57 @@ def _village(wish: str, rng: random.Random, mood: str) -> dict:
             ),
             _done(
                 "Small lights, kept on. There is no greater architecture.",
-                "A village stands with its windows lit, as if expecting someone.",
+                "A village stands with its windows lit, and carts come and go beneath them.",
+            ),
+        ],
+    }
+
+
+def _city(wish: str, rng: random.Random, mood: str) -> dict:
+    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."
+    )
+    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,
+            ),
+            _call(
+                "The tower, slender, its rooftop light slow-pulsing.",
+                "place_structure",
+                lat=lat, lon=lon, 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),
+                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),
+                kind="cafe", scale=_r2(rng, 0.7, 1.0), hue=warm_hue,
+            ),
+            _call(
+                "Carts to thread the streets between them, slow and constant.",
+                "spawn_life",
+                lat=lat, lon=lon, radius_deg=_r1(rng, 8, 14),
+                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.",
             ),
         ],
     }
@@ -452,9 +514,15 @@ def _sky(wish: str, rng: random.Random, mood: str) -> dict:
                 kind="glowgrass", density=_r2(rng, 0.4, 0.7),
                 hue=_r1(rng, 150, 200),
             ),
+            _call(
+                "And a flock to circle beneath the new moons.",
+                "spawn_life",
+                lat=lat, lon=lon, radius_deg=_r1(rng, 10, 16),
+                kind="birds", count=rng.randint(5, 9), hue=_r1(rng, 200, 260),
+            ),
             _done(
                 "Look up, little world. I rewrote you an answer.",
-                f"The night is rewritten: more stars, {moons} moons, one wish in orbit.",
+                f"The night is rewritten: more stars, {moons} moons, a flock, one wish in orbit.",
             ),
         ],
     }
@@ -512,6 +580,7 @@ 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(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(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),

mind/prompts.py

@@ -43,6 +43,7 @@ TOOL_ORDER: tuple[str, ...] = (
     "set_weather",
     "set_sky",
     "inscribe_wish",
+    "spawn_life",
 )
 
 # DEVIATION: vendored copy of the engine/tools.py spec table (mirrors the
@@ -65,7 +66,7 @@ _VENDORED_TOOL_SPECS: dict[str, dict[str, str]] = {
     },
     "place_structure": {
         "lat": "-85..85", "lon": "-180..180",
-        "kind": "lighthouse|monolith|shrine|village|beacon|arch",
+        "kind": "lighthouse|monolith|shrine|village|beacon|arch|tower|warehouse|cafe",
         "scale": "0.5..2.0", "hue": "0..360",
     },
     "place_water": {
@@ -83,6 +84,10 @@ _VENDORED_TOOL_SPECS: dict[str, dict[str, str]] = {
     "inscribe_wish": {
         "text": "<=90 chars (the wish, possibly poeticized)", "style": "orbit|stone",
     },
+    "spawn_life": {
+        "lat": "-85..85", "lon": "-180..180", "radius_deg": "1..20",
+        "kind": "carts|birds|fireflies", "count": "1..12 (integer)", "hue": "0..360",
+    },
 }
 
 
@@ -108,7 +113,7 @@ TOOL_SPECS, TOOL_SPECS_FROM_ENGINE = _load_tool_specs()
 
 
 def tool_names() -> tuple[str, ...]:
-    """The 8 legal tool names, in canonical order."""
+    """The 9 legal tool names, in canonical order."""
     return TOOL_ORDER
 
 
@@ -156,7 +161,7 @@ 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 eight tools exist —
+you see, and act only through the tools below. ONLY these nine 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

tests/test_engine.py

@@ -536,7 +536,7 @@ def test_summary_stays_under_cap_with_many_features():
 # ------------------------------------------------------------------------ misc
 
 
-def test_tool_surface_is_exactly_eight():
+def test_tool_surface_is_exactly_nine():
     assert TOOL_NAMES == (
         "raise_terrain",
         "lower_terrain",
@@ -546,4 +546,81 @@ def test_tool_surface_is_exactly_eight():
         "set_weather",
         "set_sky",
         "inscribe_wish",
+        "spawn_life",
     )
+
+
+# --------------------------------------------------------------------- city update
+
+
+def test_new_structure_kinds_accepted():
+    world = make_world()
+    for kind in ("tower", "warehouse", "cafe"):
+        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_place_structure_still_rejects_unknown_kind():
+    args, err = validate_call(
+        "place_structure",
+        {"lat": 0, "lon": 0, "kind": "castle", "scale": 1.0, "hue": 100},
+    )
+    assert args is None and err == "rejected: unknown kind 'castle'"
+
+
+def test_spawn_life_valid_and_clamped():
+    world = make_world()
+    feature, obs = world.apply(
+        "w_000001",
+        0,
+        {"tool": "spawn_life",
+         "args": {"lat": 200, "lon": -999, "radius_deg": 99, "kind": "CARTS",
+                  "count": 50, "hue": 720}},
+    )
+    assert feature is not None
+    assert feature.args == {
+        "lat": 85.0,
+        "lon": -180.0,
+        "radius_deg": 20.0,   # clamped to spawn_life max
+        "kind": "carts",      # enum lowercased
+        "count": 12,          # clamped to max, integer
+        "hue": 360.0,
+    }
+    assert isinstance(feature.args["count"], int)
+    assert obs == "ok: 12 carts stirring at (85,-180)"
+
+
+def test_spawn_life_count_is_integer_and_low_clamp():
+    args, err = validate_call(
+        "spawn_life",
+        {"lat": 0, "lon": 0, "radius_deg": 0.1, "kind": "fireflies",
+         "count": 0.4, "hue": 200},
+    )
+    assert err is None
+    assert args["radius_deg"] == 1.0   # clamped up to min
+    assert args["count"] == 1          # rounds/clamps up to min, integer
+    assert isinstance(args["count"], int)
+    assert args["kind"] == "fireflies"
+
+
+def test_spawn_life_rejects_unknown_kind():
+    args, err = validate_call(
+        "spawn_life",
+        {"lat": 0, "lon": 0, "radius_deg": 5, "kind": "dragons", "count": 3, "hue": 100},
+    )
+    assert args is None and err == "rejected: unknown kind 'dragons'"
+
+
+def test_spawn_life_missing_arg_rejected():
+    args, err = validate_call(
+        "spawn_life",
+        {"lat": 0, "lon": 0, "radius_deg": 5, "kind": "birds", "hue": 100},
+    )
+    assert args is None and err == "rejected: missing arg 'count'"

tests/test_mind.py

@@ -43,15 +43,15 @@ DIVERSE_WISHES = {
     ),
 }
 
-# Wishes chosen so the union of their mock scripts spans all 8 tools.
+# Wishes chosen so the union of their mock scripts spans all 9 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
-    "an ancient forest full of fireflies",              # flora, weather
+    "a quiet sea under patient stars",                  # lower, water, sky, life(birds)
+    "an ancient forest full of fireflies",              # flora, weather, life(fireflies)
     "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 tiny village where the kettle is always on",     # raise, structure, flora, inscribe
+    "a bright city of towers and warehouses and cafes", # raise, structure(new kinds), life(carts)
     "blorptangle the seventh hum",                      # flora, structure, inscribe
 ]
 
@@ -177,7 +177,7 @@ def test_call_turns_valid(label):
     assert [t["call"] for t in call_turns] == calls
 
 
-def test_all_eight_tools_covered_across_suite():
+def test_all_nine_tools_covered_across_suite():
     used: set[str] = set()
     for wish in COVERAGE_WISHES:
         trace, _events, _calls = run_grant(wish)
@@ -185,6 +185,54 @@ def test_all_eight_tools_covered_across_suite():
     assert used == TOOLS, f"missing tools: {TOOLS - used}"
 
 
+def test_city_script_uses_new_kinds_and_spawn_life():
+    """The city script exercises the new building kinds and the 9th tool, and
+    every call turn re-parses cleanly through parse_turn (grammar's JSON shape)."""
+    trace, _events, _calls = run_grant("a bright city of towers and warehouses and cafes")
+    call_turns = [t for t in trace["turns"] if t["call"] is not None]
+
+    structure_kinds = {
+        t["call"]["args"]["kind"]
+        for t in call_turns
+        if t["call"]["tool"] == "place_structure"
+    }
+    assert {"tower", "warehouse", "cafe"} <= structure_kinds
+
+    life_calls = [t["call"] for t in call_turns if t["call"]["tool"] == "spawn_life"]
+    assert life_calls, "city script should call spawn_life"
+    for call in life_calls:
+        args = call["args"]
+        assert args["kind"] in ("carts", "birds", "fireflies")
+        assert isinstance(args["count"], int) and 1 <= args["count"] <= 12
+        assert set(args) == {"lat", "lon", "radius_deg", "kind", "count", "hue"}
+
+    # 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."""
+    life_kinds: set[str] = set()
+    for wish in (
+        "a bright city of towers and warehouses and cafes",  # carts
+        "an ancient forest full of fireflies",               # fireflies
+        "more stars and another moon over the night sky",    # birds
+    ):
+        trace, _events, _calls = run_grant(wish)
+        for turn in trace["turns"]:
+            call = turn["call"]
+            if call and call["tool"] == "spawn_life":
+                life_kinds.add(call["args"]["kind"])
+                rendered = json.dumps({"thought": turn["thought"], "call": call})
+                obj, err = parse_turn(rendered)
+                assert err is None, f"spawn_life turn failed to parse: {err}"
+    assert life_kinds == {"carts", "birds", "fireflies"}
+
+
 def test_inscriptions_clamped_for_long_wish():
     trace, _events, _calls = run_grant(DIVERSE_WISHES["long"])
     inscriptions = [

web/book.js

@@ -48,17 +48,27 @@ try {
 }
 app.start();
 
+// left-side dark scrim so the log column reads over the bright planet rim +
+// gold trail (sits behind the canvas overlays, above the scene).
+if (!document.querySelector(".ledger-scrim")) {
+  const scrim = document.createElement("div");
+  scrim.className = "ledger-scrim";
+  scrim.setAttribute("aria-hidden", "true");
+  document.body.insertBefore(scrim, document.querySelector(".vignette") || els.ledger);
+}
+
 // ---------------------------------------------------------------- data
 async function loadIndex() {
   if (MOCK) {
     const traces = await fetch("./mock/traces.json").then((r) => r.json());
     const { FEED_WISH } = await import("./mock/feed.js");
-    const list = Object.values(traces).map((t) => ({
+    const list = Object.values(traces).map((t, i) => ({
       wish_id: t.wish_id, text: t.text, epitaph: t.epitaph, ts: t.submitted_at,
+      epoch: i + 1, // grant order mirrors the API's enumerate(start=1)
     }));
     list.push({
       wish_id: FEED_WISH.trace.wish_id, text: FEED_WISH.trace.text,
-      epitaph: FEED_WISH.trace.epitaph, ts: 1718201100,
+      epitaph: FEED_WISH.trace.epitaph, ts: 1718201100, epoch: list.length + 1,
     });
     return { list, traces: { ...traces, [FEED_WISH.trace.wish_id]: FEED_WISH.trace }, feed: FEED_WISH };
   }
@@ -92,6 +102,16 @@ async function loadTrace(ctx, wishId) {
 // ---------------------------------------------------------------- replay
 const runner = new ScriptRunner({});
 let phase = "reading";
+let lastDescentDir = null;
+
+// The direction a feature landed at (descent target). Sky/weather have none.
+function featureDir(feature) {
+  const a = feature?.args || {};
+  if (feature?.tool === "set_sky" || feature?.tool === "set_weather") return null;
+  if (a.path && a.path.length) return latLonToDir(a.path[0][0], a.path[0][1]);
+  if (a.lat != null && a.lon != null) return latLonToDir(a.lat, a.lon);
+  return null;
+}
 
 function replayWish(trace, allFeatures) {
   runner.cancel();
@@ -100,6 +120,7 @@ function replayWish(trace, allFeatures) {
   els.voiceWish.textContent = `“${trace.text}”`;
   els.voiceDot.classList.add("is-live");
   phase = "reading";
+  lastDescentDir = null;
 
   // world at features[0..K)
   const mine = allFeatures.filter((f) => f.wish_id === trace.wish_id);
@@ -129,14 +150,22 @@ function replayWish(trace, allFeatures) {
       const cue = app.world.applyFeature(e.feature, { animate: true, t: app.simTime });
       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);
+      if (dir) lastDescentDir = dir.clone().normalize();
     },
     granted: (e) => {
       els.epitaphText.textContent = e.epitaph;
       els.epitaph.classList.add("is-shown");
       els.voiceDot.classList.remove("is-live");
       app.world.sky.flash(0.3);
-      app.rig.release();
-      setTimeout(() => els.epitaph.classList.remove("is-shown"), 7000);
+      // visit it: after the final delta, swoop down over the wish site, then rise
+      if (lastDescentDir) {
+        app.rig.setTerrain?.(app.world.terrain);
+        app.rig.descend(lastDescentDir.clone().multiplyScalar(PLANET_R));
+      } else {
+        app.rig.release();
+      }
+      setTimeout(() => els.epitaph.classList.remove("is-shown"), 8500);
     },
   };
   runner.start(buildWishScript(trace, features), app.simTime);
@@ -148,11 +177,19 @@ app.onTick((t) => runner.update(t));
 (async () => {
   try {
     const [ctx, state] = await Promise.all([loadIndex(), loadState()]);
-    const list = [...ctx.list].sort((a, b) => (a.ts ?? 0) - (b.ts ?? 0));
-
-    // world as it stands now (zero GPU, gorgeous by default)
+    // newest first — a just-granted wish must appear at the TOP of the log.
+    // epoch is the server's monotonic grant count (start=1); ts can be 0, so
+    // epoch is the primary key, ts the tiebreak.
+    const ord = (w, i) => (w.epoch ?? w.ts ?? i) * 1e6 + (w.ts ?? 0);
+    const list = ctx.list
+      .map((w, i) => ({ ...w, _ord: ord(w, i) }))
+      .sort((a, b) => b._ord - a._ord);
+
+    // 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);
-    els.status.textContent = `epoch ${state.epoch} · ${list.length} wishes inscribed`;
+    const granted = state.epoch ?? list.length;
+    els.status.textContent = `epoch ${granted} · ${granted} ${granted === 1 ? "wish" : "wishes"} granted`;
 
     if (!list.length) {
       const div = document.createElement("div");
@@ -163,11 +200,11 @@ app.onTick((t) => runner.update(t));
     }
 
     const buttons = new Map();
-    list.forEach((w, i) => {
+    list.forEach((w) => {
       const btn = document.createElement("button");
       btn.className = "ledger__entry";
       btn.innerHTML = `
-        <div class="ledger__epoch">epoch ${w.epoch ?? i + 1}</div>
+        <div class="ledger__epoch">epoch ${w.epoch ?? "—"}</div>
         <div class="ledger__wish"></div>
         <div class="ledger__epitaph"></div>`;
       btn.querySelector(".ledger__wish").textContent = `“${w.text}”`;
@@ -200,6 +237,10 @@ app.onTick((t) => runner.update(t));
       pause: (v) => app.pause(v),
       stats: () => app.stats(),
       replay: (id) => buttons.get(id)?.click(),
+      descend: (lat, lon, duration = 13) => {
+        app.rig.setTerrain?.(app.world.terrain);
+        app.rig.descend(latLonToDir(lat, lon).multiplyScalar(PLANET_R), { duration });
+      },
       setCamera: (theta, phi, dist) => {
         Object.assign(app.rig, {
           theta, thetaT: theta, phi, phiT: phi,

web/index.html

@@ -51,6 +51,7 @@
     <div class="epitaph__rule"></div>
     <div class="epitaph__text" id="epitaphText"></div>
     <div class="epitaph__label" id="epitaphLabel">the wish is granted</div>
+    <button class="epitaph__descend" id="epitaphDescend" type="button" hidden>descend&ensp;↓</button>
   </div>
 
   <!-- altar: wish input -->

web/main.js

@@ -20,6 +20,7 @@ const els = {
   epitaph: document.getElementById("epitaph"),
   epitaphText: document.getElementById("epitaphText"),
   epitaphLabel: document.getElementById("epitaphLabel"),
+  epitaphDescend: document.getElementById("epitaphDescend"),
   queueChip: document.getElementById("queueChip"),
   form: document.getElementById("wishForm"),
   input: document.getElementById("wishInput"),
@@ -78,7 +79,11 @@ function showEpitaph(text, label = "the wish is granted") {
   els.epitaphLabel.textContent = label;
   els.epitaph.classList.add("is-shown");
   clearTimeout(epitaphTimer);
-  epitaphTimer = setTimeout(() => els.epitaph.classList.remove("is-shown"), 6500);
+  // hold long enough for the eye to find the "descend ↓" affordance
+  epitaphTimer = setTimeout(() => {
+    els.epitaph.classList.remove("is-shown");
+    if (els.epitaphDescend) els.epitaphDescend.hidden = true;
+  }, 9000);
 }
 
 function setEpoch(epoch, granted = epoch) {
@@ -122,6 +127,27 @@ function callTarget(call) {
   return null;
 }
 
+// The direction on the surface a feature landed at (for the descent target).
+// Sky/weather have no place, so they don't count toward "where to visit".
+function featureDir(feature) {
+  const a = feature?.args || {};
+  if (feature?.tool === "set_sky" || feature?.tool === "set_weather") return null;
+  if (a.path && a.path.length) return latLonToDir(a.path[0][0], a.path[0][1]);
+  if (a.lat != null && a.lon != null) return latLonToDir(a.lat, a.lon);
+  return null;
+}
+
+// "descend ↓" affordance on the epitaph card → swoop down over the wish site.
+function armDescent(dir) {
+  if (!els.epitaphDescend) return;
+  if (dir) {
+    lastDescentDir = dir.clone();
+    els.epitaphDescend.hidden = false;
+  } else if (!lastDescentDir) {
+    els.epitaphDescend.hidden = true;
+  }
+}
+
 // ---------------------------------------------------------------- boot
 let app;
 try {
@@ -132,6 +158,16 @@ try {
   throw err;
 }
 
+// last surface direction a wish landed at — the descent target.
+let lastDescentDir = null;
+if (els.epitaphDescend) {
+  els.epitaphDescend.addEventListener("click", () => {
+    if (!lastDescentDir) return;
+    app.rig.setTerrain?.(app.world.terrain); // clear live terrain analytically
+    app.rig.descend(lastDescentDir.clone().multiplyScalar(PLANET_R));
+  });
+}
+
 const featuresByWish = (features, upto) => {
   if (upto == null) return features;
   const order = [];
@@ -241,6 +277,8 @@ async function bootLive() {
         tickerClear();
         readingPhase = true;
         tickerLive(m.text);
+        lastDescentDir = null;
+        if (els.epitaphDescend) els.epitaphDescend.hidden = true;
         break;
       case "thought_token":
         tickerPush(m.text, readingPhase ? "reading" : "thought");
@@ -255,8 +293,12 @@ async function bootLive() {
         if (m.feature) {
           stateVersion = stateVersion == null ? null : stateVersion + 1;
           const cue = app.world.applyFeature(m.feature, { animate: true, t: app.simTime });
-          if (cue.target) app.rig.gaze(cue.target.clone().multiplyScalar(PLANET_R), { hold: 4.5 });
+          // gaze toward where the world is actually changing — the cue target is
+          // the resolved surface point (refines inscriptions/structures by seed).
+          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);
+          if (dir) lastDescentDir = dir.clone().normalize();
         }
         break;
       }
@@ -264,7 +306,13 @@ async function bootLive() {
         showEpitaph(m.epitaph || "it is made");
         if (m.epoch != null) setEpoch(m.epoch, m.epoch);
         app.world.sky.flash(0.35);
-        app.rig.release();
+        armDescent(lastDescentDir);
+        // hold a beat on the wish site, THEN release to the wide shot
+        if (lastDescentDir && !app.rig.descending) {
+          app.rig.gaze(lastDescentDir.clone().multiplyScalar(PLANET_R), { hold: 3.6 });
+        } else {
+          app.rig.release();
+        }
         tickerIdle();
         els.status.textContent = "live · the god is listening";
         break;
@@ -348,16 +396,23 @@ async function bootMock() {
     },
     delta: (e) => {
       const cue = app.world.applyFeature(e.feature, { animate: true, t: app.simTime });
-      if (cue.target) app.rig.gaze(cue.target.clone().multiplyScalar(PLANET_R), { hold: 4 });
+      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);
+      if (dir) lastDescentDir = dir.clone().normalize();
     },
     granted: (e) => {
       showEpitaph(e.epitaph);
       setEpoch(baseEpoch + 1, baseEpoch + 1);
       app.world.sky.flash(0.35);
-      app.rig.release();
+      armDescent(lastDescentDir);
+      if (lastDescentDir && !app.rig.descending) {
+        app.rig.gaze(lastDescentDir.clone().multiplyScalar(PLANET_R), { hold: 3.6 });
+      } else {
+        app.rig.release();
+      }
       tickerIdle();
-      cooldown = 10; // dwell on the granted world before the loop resets
+      cooldown = 12; // dwell on the granted world (descend affordance) before reset
     },
   });
   let phase = "reading";
@@ -366,6 +421,8 @@ async function bootMock() {
 
   function startFeed(customText) {
     phase = "reading";
+    lastDescentDir = null;
+    if (els.epitaphDescend) els.epitaphDescend.hidden = true;
     const trace = customText ? { ...FEED_WISH.trace, text: customText } : FEED_WISH.trace;
     runner.start(buildWishScript(trace, FEED_WISH.features), app.simTime);
   }
@@ -446,6 +503,16 @@ window.__godseed = {
     app.rig.gaze(latLonToDir(lat, lon).multiplyScalar(PLANET_R), { hold });
   },
   gazeWide: () => app.rig.release(),
+  descend: (lat, lon, duration = 13) => {
+    app.rig.setTerrain?.(app.world.terrain);
+    app.rig.descend(latLonToDir(lat, lon).multiplyScalar(PLANET_R), { duration });
+  },
+  descendLast: (duration = 13) => {
+    if (!lastDescentDir) return false;
+    app.rig.setTerrain?.(app.world.terrain);
+    app.rig.descend(lastDescentDir.clone().multiplyScalar(PLANET_R), { duration });
+    return true;
+  },
   setSky: (p, stars = 0.8, moons = 1) => app.world.sky.set(p, stars, moons, { animate: false }),
   setWeather: (k, i = 0.6) => app.world.weather.set(k, i, { animate: false }),
   setCamera: (theta, phi, dist) => {

web/mock/feed.js

@@ -2,49 +2,65 @@
 // on a loop: reading tokens → tool_calls → world_deltas → granted. The world
 // 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.
 
 export const FEED_WISH = {
   trace: {
-    wish_id: "w_000011",
-    text: "let the storm find its way home",
+    wish_id: "w_000012",
+    text: "raise me a city — a tower, a warehouse, a cafe, and carts at dusk",
     moderation: { allowed: true, category: null },
     reading:
-      "A storm, asked home. Storms are not strays — they are rivers that lost their bed. " +
-      "I will raise high ground in the cold northwest for it to circle, light grass beneath " +
-      "so it can see where it lands, and then I will whistle.",
+      "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.",
     turns: [
       {
-        thought: "First, a place worth striking. Raise the storm-fells: high, broken, proud.",
-        call: { tool: "raise_terrain", args: { lat: 48, lon: -150, radius_deg: 16, height: 0.075, roughness: 0.85 } },
-        observation: "ok: mountains risen at (48,-150)",
+        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: "Grass that glows storm-blue, so the lightning has a mirror.",
-        call: { tool: "spawn_flora", args: { lat: 46, lon: -144, radius_deg: 9, kind: "glowgrass", density: 0.7, hue: 185 } },
-        observation: "ok: flora seeded at (46,-144)",
+        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: "Now the whistle. Come home.",
-        call: { tool: "set_weather", args: { kind: "storm", intensity: 0.8 } },
-        observation: "ok: weather set to storm",
+        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: "And a ring of words above, so it never forgets the way again. No — so it always finds it.",
-        call: { tool: "inscribe_wish", args: { text: "every storm is a wish with thunder in it", style: "orbit" } },
-        observation: "ok: words set in orbit",
+        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: "It rains where I wanted it to rain. That is the whole of godhood.", call: null, observation: "" },
+      {
+        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 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: "" },
     ],
-    epitaph: "The storm came home, and the hills wear it well.",
-    feature_ids: ["f_000028", "f_000029", "f_000030", "f_000031"],
+    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"],
     model: "nemotron-3-nano (mock)",
     backend: "mock",
-    ms_total: 52840,
+    ms_total: 58210,
   },
   features: [
-    { id: "f_000028", wish_id: "w_000011", tool: "raise_terrain", args: { lat: 48, lon: -150, radius_deg: 16, height: 0.075, roughness: 0.85 }, seed: 1011863426, t: 1718201100.0 },
-    { id: "f_000029", wish_id: "w_000011", tool: "spawn_flora", args: { lat: 46, lon: -144, radius_deg: 9, kind: "glowgrass", density: 0.7, hue: 185 }, seed: 1263075092, t: 1718201103.0 },
-    { id: "f_000030", wish_id: "w_000011", tool: "set_weather", args: { kind: "storm", intensity: 0.8 }, seed: 1380036270, t: 1718201106.0 },
-    { id: "f_000031", wish_id: "w_000011", tool: "inscribe_wish", args: { text: "every storm is a wish with thunder in it", style: "orbit" }, seed: 625385016, t: 1718201109.0 },
+    { 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 },
   ],
 };

web/mock/world.json

@@ -1,7 +1,7 @@
 {
   "world": {
-    "version": 28,
-    "epoch": 10,
+    "version": 36,
+    "epoch": 11,
     "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},
@@ -40,11 +40,21 @@
       {"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_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}
     ]
   },
   "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},

web/planet/camera.js

@@ -1,14 +1,24 @@
 // 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.
+// 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.
 import * as THREE from "three";
-import { PLANET_R, clamp, lerp } from "./util.js";
+import { PLANET_R, clamp, lerp, easeInOutCubic } 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;
 
+// 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
+const GLIDE_ARC = 0.42;                // radians swept over the target (~24°)
+const PHI_FLOOR = 0.26;
+const PHI_CEIL = Math.PI - 0.26;
+
 export class CameraRig {
   constructor(camera, dom) {
     this.camera = camera;
@@ -23,13 +33,20 @@ export class CameraRig {
     this.idleSpeed = 0.05;
     this.userHold = 0;   // seconds left of user-control override
     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
     this._bind(dom);
   }
 
+  /** Let the rig clear terrain analytically during descents (set by the app). */
+  setTerrain(terrain) { this._terrain = terrain; }
+
   _bind(dom) {
     if (!dom) return;
     let dragging = false, px = 0, py = 0;
     dom.addEventListener("pointerdown", (e) => {
+      // a deliberate click during a descent is the "take me back" gesture
+      if (this.descent && !dragging) this.cancelDescent();
       dragging = true; px = e.clientX; py = e.clientY;
       dom.setPointerCapture?.(e.pointerId);
       this.userHold = 6;
@@ -47,24 +64,33 @@ export class CameraRig {
     dom.addEventListener("pointercancel", end);
     dom.addEventListener("wheel", (e) => {
       e.preventDefault();
+      if (this.descent) this.cancelDescent();
       this.distT = clamp(this.distT * (1 + e.deltaY * 0.0011), MIN_DIST, MAX_DIST);
       this.userHold = 6;
     }, { passive: false });
+    // ESC returns to orbit (camera liturgy, not a trap)
+    this._onKey = (e) => { if (e.key === "Escape" && this.descent) this.cancelDescent(); };
+    window.addEventListener("keydown", this._onKey);
+  }
+
+  /** Spherical angles (theta, phi) that frame a unit direction off-center. */
+  _anglesFor(dir) {
+    let th = Math.atan2(dir.z, dir.x) + 0.32; // feature sits just off-center
+    const ph = clamp(Math.acos(clamp(dir.y, -1, 1)) - 0.14, 0.3, Math.PI - 0.3);
+    const tau = Math.PI * 2;
+    while (th - this.theta > Math.PI) th -= tau;
+    while (th - this.theta < -Math.PI) th += tau;
+    return { th, ph };
   }
 
   /**
    * Ease toward a world point (the demo money-shot). `point` null ⇒ wide shot.
    */
   gaze(point, { hold = 4.5 } = {}) {
-    if (this.userHold > 0) return; // a human hand is on the camera — don't fight it
+    if (this.userHold > 0 || this.descent) return; // hand on the camera / mid-descent
     if (point) {
       const dir = point.clone().normalize();
-      let th = Math.atan2(dir.z, dir.x) + 0.32; // feature sits just off-center
-      const ph = clamp(Math.acos(clamp(dir.y, -1, 1)) - 0.14, 0.3, Math.PI - 0.3);
-      // unwrap to nearest revolution so we take the short way around
-      const tau = Math.PI * 2;
-      while (th - this.theta > Math.PI) th -= tau;
-      while (th - this.theta < -Math.PI) th += tau;
+      const { th, ph } = this._anglesFor(dir);
       this.thetaT = th;
       this.phiT = ph;
       this.distT = GAZE_DIST;
@@ -78,12 +104,119 @@ export class CameraRig {
 
   /** Drift back to the slow contemplative orbit. */
   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);
+  }
+
+  /**
+   * Cinematic descent: swoop from orbit down to just above the surface over
+   * `targetDir`, glide a slow arc with gentle look-ahead, then rise back to the
+   * orbit framing. `targetDir` is a (not necessarily unit) world direction —
+   * typically a granted wish's last landed feature. Sim-time deterministic.
+   */
+  descend(targetDir, { duration = 13 } = {}) {
+    if (!targetDir) return;
+    const dir = targetDir.clone().normalize();
+    // a tangent basis around the target so the glide sweeps along the surface
+    const up = Math.abs(dir.y) > 0.93 ? new THREE.Vector3(1, 0, 0) : new THREE.Vector3(0, 1, 0);
+    const east = new THREE.Vector3().crossVectors(up, dir).normalize();
+    const north = new THREE.Vector3().crossVectors(dir, east).normalize();
+    // approach from a little "south & up" of the target, glide toward "north"
+    const start = dir.clone()
+      .multiplyScalar(Math.cos(GLIDE_ARC * 0.9))
+      .addScaledVector(north, -Math.sin(GLIDE_ARC * 0.9))
+      .normalize();
+    const end = dir.clone()
+      .multiplyScalar(Math.cos(GLIDE_ARC * 1.1))
+      .addScaledVector(north, Math.sin(GLIDE_ARC * 1.1))
+      .normalize();
+    this.descent = {
+      dir, north, start, end,
+      t: 0,
+      duration,
+      // phase fractions: dive → glide → rise
+      dive: 0.34, glide: 0.40,
+    };
     this.gazeHold = 0;
+    this.userHold = 0;
+  }
+
+  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;
+    this.gazeHold = 0.6;
+  }
+
+  get descending() { return !!this.descent; }
+
+  /** Eye distance that keeps us safely above any terrain along the descent dir. */
+  _groundClear(dir) {
+    let h = 0;
+    if (this._terrain?.heightAt) {
+      try { h = this._terrain.heightAt(dir) || 0; } catch { h = 0; }
+    }
+    // ride a hair above the highest plausible relief beneath us
+    return Math.max(DESCENT_DIST, PLANET_R + h + 0.10 * PLANET_R);
+  }
+
+  _updateDescent(dt) {
+    const d = this.descent;
+    d.t += dt;
+    const u = clamp(d.t / d.duration, 0, 1);
+    // three eased phases sharing one progress value
+    let dist, lookDir, lookR;
+    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);
+      lookDir = d.start.clone();
+      lookR = lerp(PLANET_R * 0.5, 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;
+      const dir = slerp(d.start, d.end, k);
+      dist = this._groundClear(dir);
+      const ahead = slerp(d.start, d.end, Math.min(1, k + 0.16)); // gentle look-ahead
+      lookDir = ahead;
+      lookR = DESCENT_CLEAR;
+    } else {
+      // rise back to orbit, re-acquiring 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);
+      lookDir = dir;
+      lookR = lerp(DESCENT_CLEAR, 0, k);
+    }
+    // place the eye directly (no spherical-lerp; the descent is the authority)
+    const eye = lookDir.clone();
+    // keep the eye slightly behind the look target so we look forward/down
+    const phi = clamp(Math.acos(clamp(eye.y, -1, 1)), PHI_FLOOR, PHI_CEIL);
+    const theta = Math.atan2(eye.z, eye.x);
+    this.theta = theta; this.thetaT = theta;
+    this.phi = phi; this.phiT = phi;
+    this.dist = dist; this.distT = dist;
+    const sp = Math.sin(phi);
+    this.camera.position.set(
+      dist * sp * Math.cos(theta),
+      dist * Math.cos(phi),
+      dist * sp * Math.sin(theta)
+    );
+    this.look.copy(lookDir).multiplyScalar(lookR);
+    this.lookT.copy(this.look);
+    this.camera.lookAt(this.look);
+    if (u >= 1) this.cancelDescent();
   }
 
   update(dt) {
+    if (this.descent) { this._updateDescent(dt); return; }
+
     if (this.userHold > 0) this.userHold -= dt;
     if (this.gazeHold > 0) {
       this.gazeHold -= dt;
@@ -108,3 +241,27 @@ export class CameraRig {
     this.camera.lookAt(this.look);
   }
 }
+
+// --- local helpers (sim-time pure) ------------------------------------------
+
+/** Spherical interpolation between two unit vectors (short way). */
+function slerp(a, b, t) {
+  const dot = clamp(a.dot(b), -1, 1);
+  const omega = Math.acos(dot);
+  if (omega < 1e-4) return a.clone();
+  const so = Math.sin(omega);
+  return a.clone().multiplyScalar(Math.sin((1 - t) * omega) / so)
+    .addScaledVector(b, Math.sin(t * omega) / so)
+    .normalize();
+}
+
+/**
+ * On the rise, pull the eye up and away from the surface dir toward a higher
+ * latitude so we re-frame the whole planet, not the ground we just skimmed.
+ */
+function slerpToOrbit(surfaceDir, k) {
+  const up = new THREE.Vector3(0, 1, 0);
+  // a vantage offset from the surface dir, lifted toward the pole for the wide
+  const high = surfaceDir.clone().lerp(up, 0.34).normalize();
+  return slerp(surfaceDir, high, easeInOutCubic(k));
+}

web/planet/life.js

@@ -0,0 +1,305 @@
+// GODSEED — life. Moving inhabitants for the spawn_life tool (#9): carts that
+// glide along the nearest stream, birds that circuit low over the land, and
+// fireflies that drift near the ground. Every flock is an InstancedMesh driven
+// by a deterministic seeded path sampled at tick(simTime) — no rAF, no Date,
+// no per-frame accumulation — so replay and headless capture are byte-stable.
+import * as THREE from "three";
+import { mulberry32 } from "./rng.js";
+import {
+  PLANET_R, DEG, clamp, easeOutCubic, randomDirInCap, slerpDirs, hsl, angleBetween,
+} from "./util.js";
+
+const REVEAL = 1.6; // fade-in of a fresh flock
+
+// A closed great-circle-ish loop of unit directions around `center`, used as
+// the fallback path for carts and the flight path for birds. Deterministic.
+function seededLoop(center, radiusRad, rng, n = 48, wobble = 0.35) {
+  const t1 = new THREE.Vector3(0, 1, 0);
+  if (Math.abs(center.y) > 0.93) t1.set(1, 0, 0);
+  const t2 = new THREE.Vector3().crossVectors(center, t1).normalize();
+  t1.crossVectors(t2, center).normalize();
+  const rad = radiusRad * (0.45 + rng() * 0.3);
+  const phase = rng() * Math.PI * 2;
+  const lobe = 1 + Math.floor(rng() * 2); // 1 or 2 lobes → oval / peanut loops
+  const dir = new THREE.Vector3();
+  const pts = [];
+  for (let i = 0; i < n; i++) {
+    const a = (i / n) * Math.PI * 2;
+    const r = rad * (1 + wobble * Math.sin(a * (lobe + 1) + phase) * 0.5);
+    dir.copy(center).multiplyScalar(Math.cos(r))
+      .addScaledVector(t2, Math.sin(r) * Math.cos(a + phase))
+      .addScaledVector(t1, Math.sin(r) * Math.sin(a + phase))
+      .normalize();
+    pts.push(dir.clone());
+  }
+  return pts;
+}
+
+// Resample a polyline of unit dirs into an arc-length-even closed loop so motion
+// reads at constant speed regardless of how the waypoints were spaced.
+function evenLoop(points, samples = 80) {
+  if (points.length < 2) return points.slice();
+  const segLen = [];
+  let total = 0;
+  for (let i = 0; i < points.length; i++) {
+    const a = points[i], b = points[(i + 1) % points.length];
+    const l = Math.max(1e-5, angleBetween(a, b));
+    segLen.push(l);
+    total += l;
+  }
+  const out = [];
+  const step = total / samples;
+  let seg = 0, acc = 0, target = 0;
+  const tmp = new THREE.Vector3();
+  for (let s = 0; s < samples; s++) {
+    while (acc + segLen[seg] < target && seg < points.length - 1) { acc += segLen[seg]; seg++; }
+    const local = clamp((target - acc) / segLen[seg], 0, 1);
+    slerpDirs(points[seg], points[(seg + 1) % points.length], local, tmp);
+    out.push(tmp.clone());
+    target += step;
+  }
+  return out;
+}
+
+class Flock {
+  constructor(scene, terrain, water, f, t0, animate) {
+    const a = f.args;
+    this.f = f;
+    this.t0 = t0;
+    this.animate = animate;
+    this.terrain = terrain;
+    this.kind = ["carts", "birds", "fireflies"].includes(a.kind) ? a.kind : "fireflies";
+    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, 1, 20) * DEG;
+    this.count = clamp(Math.round(a.count ?? 6), 1, 12);
+    this.hue = a.hue ?? 40;
+    const rng = mulberry32(f.seed);
+    this.rng = rng;
+    this.group = new THREE.Group();
+    scene.add(this.group);
+    this.scene = scene;
+
+    if (this.kind === "carts") this._buildCarts(rng, water);
+    else if (this.kind === "birds") this._buildBirds(rng);
+    else this._buildFireflies(rng);
+  }
+
+  // ---- carts: lantern sprites gliding along the nearest stream ------------
+  _buildCarts(rng, water) {
+    let path = water && water.streamPathNear
+      ? water.streamPathNear(this.center, this.radiusRad + 6 * DEG)
+      : null;
+    if (path && path.length >= 2) {
+      // an open stream → close it into a there-and-back loop so carts glide the
+      // length of the river and return, instead of teleporting end-to-start.
+      const back = path.slice(1, -1).reverse().map((d) => d.clone());
+      path = path.concat(back);
+    } else {
+      path = seededLoop(this.center, this.radiusRad, rng, 48, 0.25);
+    }
+    this.path = evenLoop(path, 96);
+    const color = hsl(this.hue, 0.85, 0.62);
+    const geo = new THREE.SphereGeometry(0.013, 7, 6);
+    this.mat = new THREE.MeshBasicMaterial({ color: color.clone().multiplyScalar(1.9) });
+    this.mesh = new THREE.InstancedMesh(geo, this.mat, this.count);
+    this.mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+    this.mesh.frustumCulled = false;
+    this.group.add(this.mesh);
+    this.agents = [];
+    for (let i = 0; i < this.count; i++) {
+      this.agents.push({
+        offset: i / this.count + (rng() - 0.5) * 0.01, // spaced along the path
+        speed: 0.018 + rng() * 0.008,                  // loops/sec along the path
+        dir2: rng() < 0.5 ? 1 : -1,                    // some carts travel each way
+        bob: rng() * 6.28,
+        size: 0.8 + rng() * 0.5,
+      });
+    }
+  }
+
+  // ---- birds: a small flock circuiting low over the land -----------------
+  _buildBirds(rng) {
+    this.path = evenLoop(seededLoop(this.center, this.radiusRad, rng, 56, 0.4), 96);
+    this.altitude = 0.05 + rng() * 0.04; // world units above the surface
+    const color = hsl(this.hue, 0.55, 0.66);
+    // a tiny shallow chevron — flat double triangle reads as a bird at distance
+    const geo = new THREE.ConeGeometry(0.009, 0.02, 3);
+    geo.rotateX(Math.PI / 2);
+    geo.scale(1, 0.35, 1);
+    this.mat = new THREE.MeshBasicMaterial({ color: color.clone().multiplyScalar(1.5) });
+    this.mesh = new THREE.InstancedMesh(geo, this.mat, this.count);
+    this.mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+    this.mesh.frustumCulled = false;
+    this.group.add(this.mesh);
+    this.agents = [];
+    for (let i = 0; i < this.count; i++) {
+      this.agents.push({
+        offset: i / this.count * 0.18 + (rng() - 0.5) * 0.03, // tight V, slight spread
+        speed: 0.05 + rng() * 0.02,
+        bob: rng() * 6.28,
+        bobAmp: 0.012 + rng() * 0.01,
+        lateral: (rng() - 0.5) * 0.03,
+        size: 0.85 + rng() * 0.4,
+      });
+    }
+  }
+
+  // ---- fireflies: drifting glow points near the ground -------------------
+  _buildFireflies(rng) {
+    const n = this.count * 3; // a small drifting cloud of discrete lamps
+    const color = hsl(this.hue, 0.9, 0.62);
+    const geo = new THREE.SphereGeometry(0.0042, 6, 5);
+    this.mat = new THREE.MeshBasicMaterial({
+      color: color.clone().multiplyScalar(2.0), transparent: true, opacity: 1,
+      blending: THREE.AdditiveBlending, depthWrite: false,
+    });
+    this.mesh = new THREE.InstancedMesh(geo, this.mat, n);
+    this.mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+    this.mesh.instanceColor = null;
+    this.mesh.frustumCulled = false;
+    this.group.add(this.mesh);
+    this.agents = [];
+    for (let i = 0; i < n; i++) {
+      const home = randomDirInCap(this.center, this.radiusRad, rng, new THREE.Vector3());
+      this.agents.push({
+        home,
+        // each firefly hovers in a small slow Lissajous around its home dir
+        ax: 0.004 + rng() * 0.006, az: 0.004 + rng() * 0.006,
+        fx: 0.18 + rng() * 0.3, fz: 0.18 + rng() * 0.3,
+        px: rng() * 6.28, pz: rng() * 6.28,
+        lift: 0.02 + rng() * 0.05,
+        blink: rng() * 6.28, blinkSpeed: 1.2 + rng() * 2.0,
+        size: 0.8 + rng() * 0.7,
+      });
+    }
+  }
+
+  // tangent basis cached lazily for cheap lateral offsets along a path
+  _basisAt(dir, out1, out2) {
+    out1.set(0, 1, 0);
+    if (Math.abs(dir.y) > 0.93) out1.set(1, 0, 0);
+    out2.crossVectors(dir, out1).normalize();
+    out1.crossVectors(out2, dir).normalize();
+  }
+
+  _pathPoint(u, out) {
+    const n = this.path.length;
+    const f = ((u % 1) + 1) % 1 * n;
+    const i = Math.floor(f);
+    slerpDirs(this.path[i], this.path[(i + 1) % n], f - i, out);
+    return out.normalize();
+  }
+
+  update(dt, t) {
+    const reveal = this.animate ? easeOutCubic((t - this.t0) / REVEAL) : 1;
+    if (this.kind === "fireflies") this._updateFireflies(t, reveal);
+    else this._updatePath(t, reveal);
+  }
+
+  _updatePath(t, reveal) {
+    const m = new THREE.Matrix4(), p = new THREE.Vector3(), q = new THREE.Quaternion();
+    const fwd = new THREE.Vector3(), nextDir = new THREE.Vector3(), curDir = new THREE.Vector3();
+    const up = new THREE.Vector3(), s = new THREE.Vector3();
+    const t1 = new THREE.Vector3(), t2 = new THREE.Vector3();
+    const isBird = this.kind === "birds";
+    for (let i = 0; i < this.agents.length; i++) {
+      const ag = this.agents[i];
+      const u = ag.offset + t * ag.speed * (ag.dir2 ?? 1);
+      this._pathPoint(u, curDir);
+      this._pathPoint(u + 0.012 * (ag.dir2 ?? 1), nextDir);
+      // lateral spread off the path centreline (birds spread into a flock)
+      if (ag.lateral) {
+        this._basisAt(curDir, t1, t2);
+        curDir.addScaledVector(t2, ag.lateral).normalize();
+      }
+      const ground = this.terrain.heightAt(curDir);
+      const bob = isBird ? Math.sin(t * 2.2 + ag.bob) * ag.bobAmp : Math.sin(t * 1.4 + ag.bob) * 0.004;
+      const alt = isBird ? this.altitude + bob : ground + 0.012 + bob;
+      p.copy(curDir).multiplyScalar(PLANET_R + (isBird ? ground + alt : alt));
+      // orient along travel, with local up = surface normal
+      up.copy(curDir);
+      fwd.copy(nextDir).sub(curDir).normalize();
+      if (fwd.lengthSq() < 1e-8) fwd.crossVectors(up, new THREE.Vector3(1, 0, 0)).normalize();
+      const right = t1.crossVectors(fwd, up).normalize();
+      fwd.crossVectors(up, right).normalize();
+      const basis = new THREE.Matrix4().makeBasis(right, up, fwd);
+      q.setFromRotationMatrix(basis);
+      const sc = Math.max(0.0001, ag.size * reveal);
+      s.setScalar(sc);
+      m.compose(p, q, s);
+      this.mesh.setMatrixAt(i, m);
+    }
+    this.mesh.instanceMatrix.needsUpdate = true;
+  }
+
+  _updateFireflies(t, reveal) {
+    const m = new THREE.Matrix4(), p = new THREE.Vector3(), dir = new THREE.Vector3();
+    const q = new THREE.Quaternion();
+    const t1 = new THREE.Vector3(), t2 = new THREE.Vector3();
+    const s = new THREE.Vector3();
+    for (let i = 0; i < this.agents.length; i++) {
+      const ag = this.agents[i];
+      this._basisAt(ag.home, t1, t2);
+      const ox = Math.sin(t * ag.fx + ag.px) * ag.ax;
+      const oz = Math.cos(t * ag.fz + ag.pz) * ag.az;
+      dir.copy(ag.home).addScaledVector(t1, ox).addScaledVector(t2, oz).normalize();
+      const ground = this.terrain.heightAt(dir);
+      const lift = ag.lift + Math.sin(t * 0.6 + ag.px) * 0.01;
+      p.copy(dir).multiplyScalar(PLANET_R + ground + lift);
+      // blink: sharp pulse so most fireflies are dark at any instant → twinkle
+      const pulse = Math.max(0, Math.sin(t * ag.blinkSpeed + ag.blink));
+      const blink = 0.12 + 0.88 * pulse * pulse;
+      const sc = Math.max(0.0001, ag.size * blink * reveal);
+      s.setScalar(sc);
+      m.compose(p, q, s);
+      this.mesh.setMatrixAt(i, m);
+    }
+    this.mesh.instanceMatrix.needsUpdate = true;
+  }
+
+  // re-seat fireflies / re-evaluate paths when terrain under them shifts.
+  reseat() {
+    // paths are sampled against heightAt() every frame, so motion already
+    // follows the moving terrain; nothing to rebuild. (Hook kept for symmetry.)
+  }
+
+  dispose() {
+    this.group.removeFromParent();
+    this.mesh.geometry.dispose();
+    this.mat.dispose();
+    this.mesh.dispose();
+  }
+}
+
+export class Life {
+  constructor(scene, terrain, water) {
+    this.scene = scene;
+    this.terrain = terrain;
+    this.water = water;
+    this.flocks = [];
+  }
+
+  /** Apply a spawn_life feature. @returns the anchor direction (camera target). */
+  addFeature(f, { animate = true, t = 0 } = {}) {
+    const flock = new Flock(this.scene, this.terrain, this.water, f, t, animate);
+    this.flocks.push(flock);
+    return flock.center;
+  }
+
+  update(dt, t) {
+    for (const fl of this.flocks) fl.update(dt, t);
+  }
+
+  reseat(center, radiusRad) {
+    for (const fl of this.flocks) {
+      if (angleBetween(fl.center, center) < fl.radiusRad + radiusRad + 0.12) fl.reseat();
+    }
+  }
+
+  dispose() {
+    for (const fl of this.flocks) fl.dispose();
+    this.flocks = [];
+  }
+}

web/planet/structures.js

@@ -249,6 +249,212 @@ function buildArch(rng, color) {
   };
 }
 
+// ---------------------------------------------------------------- city kit
+// tower | warehouse | cafe — the "building games" set. Same diorama soul:
+// low-poly stone/wood bodies, emissive lit windows, seeded variation, the
+// window planes instanced per-structure where there are many of them.
+
+function litWindowMesh(rng, color, rects, bright = 1.9) {
+  // one InstancedMesh of unit window planes; rects = [{x,y,z,ry,w,h,phase,speed}]
+  const geo = new THREE.PlaneGeometry(1, 1);
+  const mat = glow(color, bright);
+  const mesh = new THREE.InstancedMesh(geo, mat, rects.length);
+  mesh.frustumCulled = false;
+  const m = new THREE.Matrix4(), p = new THREE.Vector3(), q = new THREE.Quaternion();
+  const e = new THREE.Euler(), s = new THREE.Vector3();
+  rects.forEach((r, i) => {
+    e.set(0, r.ry, 0);
+    q.setFromEuler(e);
+    p.set(r.x, r.y, r.z);
+    s.set(r.w, r.h, 1);
+    m.compose(p, q, s);
+    mesh.setMatrixAt(i, m);
+  });
+  mesh.instanceMatrix.needsUpdate = true;
+  return { mesh, mat, rects, _ownGeo: geo };
+}
+
+function buildTower(rng, color, ctx) {
+  const g = new THREE.Group();
+  const tiers = 3 + Math.floor(rng() * 2);     // 3-4 stepped tiers
+  const baseW = 0.05 + rng() * 0.014;
+  const tierH = 0.072 + rng() * 0.02;
+  let y = 0, w = baseW;
+  const rects = [];
+  for (let tr = 0; tr < tiers; tr++) {
+    const d = w * (0.82 + rng() * 0.12);
+    const body = new THREE.Mesh(new THREE.BoxGeometry(w, tierH, d), tr % 2 ? STONE : STONE_DARK);
+    body.position.y = y + tierH / 2;
+    body.rotation.y = tr === 0 ? rng() * 0.4 : 0;
+    g.add(body);
+    // dense lit windows on all four faces, gridded by tier
+    const cols = 3, rows = 3;
+    for (const [nx, nz, ry, half] of [[0, 1, 0, d], [0, -1, Math.PI, d], [1, 0, Math.PI / 2, w], [-1, 0, -Math.PI / 2, w]]) {
+      for (let c = 0; c < cols; c++) {
+        for (let rr = 0; rr < rows; rr++) {
+          if (rng() < 0.18) continue; // a few dark windows
+          const u = (c + 0.5) / cols - 0.5;
+          const wx = nx !== 0 ? nx * (w / 2 + 0.0007) : u * w * 0.82;
+          const wz = nz !== 0 ? nz * (d / 2 + 0.0007) : u * d * 0.82;
+          rects.push({
+            x: wx, y: y + (rr + 0.5) / rows * tierH, z: wz, ry,
+            w: 0.0078, h: 0.011, phase: rng() * 6.28, speed: 2 + rng() * 5,
+          });
+        }
+      }
+    }
+    y += tierH;
+    w *= 0.74 + rng() * 0.08;
+  }
+  // crown + slow-pulsing rooftop light (the "big building" signature)
+  const capMat = glow(color, 1.6);
+  const cap = new THREE.Mesh(new THREE.CylinderGeometry(w * 0.32, w * 0.42, 0.012, 6), STONE_DARK);
+  cap.position.y = y + 0.006;
+  g.add(cap);
+  const beaconMat = glow(color, 2.0);
+  const beacon = new THREE.Mesh(new THREE.OctahedronGeometry(0.011, 0), beaconMat);
+  beacon.position.y = y + 0.026;
+  g.add(beacon);
+  const light = new THREE.PointLight(color.getHex(), 0.6, 1.0, 1.9);
+  light.position.y = y + 0.026;
+  g.add(light);
+  const wins = litWindowMesh(rng, color, rects, 1.85);
+  g.add(wins.mesh);
+  g.add(groundHalo(color, 0.07, 0.16));
+  const phase = rng() * 6.28;
+  return {
+    group: g,
+    accents: [capMat, beaconMat, wins.mat],
+    ownGeo: [wins._ownGeo],
+    update: (dt, t) => {
+      const pulse = 1.5 + Math.sin(t * 1.1 + phase) * 0.5;
+      beaconMat.color.copy(color).multiplyScalar(pulse);
+      light.intensity = 0.4 + Math.sin(t * 1.1 + phase) * 0.22;
+      // gentle flicker of the window block as a whole (cheap: tint the shared mat)
+      wins.mat.color.copy(color).multiplyScalar(1.55 + Math.sin(t * 2.3 + phase) * 0.22);
+    },
+  };
+}
+
+function buildWarehouse(rng, color, ctx) {
+  const g = new THREE.Group();
+  const len = 0.12 + rng() * 0.05;
+  const wide = 0.05 + rng() * 0.014;
+  const wallH = 0.03 + rng() * 0.008;
+  const yaw = rng() * Math.PI;
+  const hall = new THREE.Group();
+  hall.rotation.y = yaw;
+  // long low body
+  const body = new THREE.Mesh(new THREE.BoxGeometry(len, wallH, wide), WOOD);
+  body.position.y = wallH / 2;
+  hall.add(body);
+  // gabled roof — a long triangular prism via a scaled, rotated box pair
+  const roofH = 0.022 + rng() * 0.006;
+  for (const s of [1, -1]) {
+    const slope = new THREE.Mesh(new THREE.BoxGeometry(len, 0.003, wide * 0.62), ROOF);
+    slope.position.set(0, wallH + roofH / 2, s * wide * 0.25);
+    slope.rotation.x = s * Math.atan2(roofH, wide * 0.5);
+    hall.add(slope);
+  }
+  const ridge = new THREE.Mesh(new THREE.BoxGeometry(len, 0.004, 0.004), STONE_DARK);
+  ridge.position.y = wallH + roofH;
+  hall.add(ridge);
+  // one big glowing door on a gable end
+  const doorMat = glow(color, 1.7);
+  const door = new THREE.Mesh(new THREE.PlaneGeometry(wide * 0.5, wallH * 0.78), doorMat);
+  door.position.set(len / 2 + 0.0008, wallH * 0.39, 0);
+  door.rotation.y = Math.PI / 2;
+  hall.add(door);
+  const doorLight = new THREE.PointLight(color.getHex(), 0.5, 0.5, 2.0);
+  doorLight.position.set(len / 2 + 0.02, wallH * 0.4, 0);
+  hall.add(doorLight);
+  // sparse small windows down the long sides
+  const rects = [];
+  const n = 3 + Math.floor(rng() * 3);
+  for (let i = 0; i < n; i++) {
+    const side = i % 2 ? 1 : -1;
+    const u = ((i + 0.5) / n - 0.5);
+    rects.push({
+      x: u * len * 0.82, y: wallH * 0.6, z: side * (wide / 2 + 0.0007),
+      ry: side > 0 ? 0 : Math.PI, w: 0.009, h: 0.009, phase: rng() * 6.28, speed: 2 + rng() * 3,
+    });
+  }
+  const wins = litWindowMesh(rng, color, rects, 1.5);
+  hall.add(wins.mesh);
+  g.add(hall);
+  g.add(groundHalo(color, 0.075, 0.14));
+  const phase = rng() * 6.28;
+  return {
+    group: g,
+    accents: [doorMat, wins.mat],
+    ownGeo: [wins._ownGeo],
+    update: (dt, t) => {
+      doorMat.color.copy(color).multiplyScalar(1.45 + Math.sin(t * 1.6 + phase) * 0.28);
+      doorLight.intensity = 0.4 + Math.sin(t * 1.6 + phase) * 0.16;
+      wins.mat.color.copy(color).multiplyScalar(1.3 + Math.sin(t * 3.4 + phase) * 0.2);
+    },
+  };
+}
+
+function buildCafe(rng, color, ctx) {
+  const g = new THREE.Group();
+  const w = 0.04 + rng() * 0.01, d = 0.034 + rng() * 0.01, h = 0.026 + rng() * 0.006;
+  const yaw = rng() * Math.PI * 2;
+  const box = new THREE.Group();
+  box.rotation.y = yaw;
+  const body = new THREE.Mesh(new THREE.BoxGeometry(w, h, d), WOOD);
+  body.position.y = h / 2;
+  box.add(body);
+  const roof = new THREE.Mesh(new THREE.BoxGeometry(w * 1.05, 0.004, d * 1.05), ROOF);
+  roof.position.y = h + 0.002;
+  box.add(roof);
+  // warm front window + door, hue-tinted glow
+  const warm = color.clone().lerp(new THREE.Color("#ffcf8a"), 0.45);
+  const glassMat = glow(warm, 1.7);
+  const glass = new THREE.Mesh(new THREE.PlaneGeometry(w * 0.66, h * 0.5), glassMat);
+  glass.position.set(0, h * 0.5, d / 2 + 0.0008);
+  box.add(glass);
+  // striped awning plane jutting over the front
+  const awningMat = new THREE.MeshStandardMaterial({ color: warm.clone().multiplyScalar(0.6), roughness: 0.8, side: THREE.DoubleSide });
+  const awning = new THREE.Mesh(new THREE.PlaneGeometry(w * 1.04, d * 0.5), awningMat);
+  awning.position.set(0, h * 0.86, d / 2 + d * 0.22);
+  awning.rotation.x = -Math.PI / 2 + 0.5;
+  box.add(awning);
+  // spill of warm light on the ground in front of the door
+  const spill = new THREE.Mesh(new THREE.CircleGeometry(0.05, 20), beamMat(warm, 0.4));
+  spill.rotation.x = -Math.PI / 2;
+  spill.position.set(0, 0.004, d * 0.55);
+  spill.scale.set(1, 1.5, 1); // stretch the pool of light outward from the door
+  box.add(spill);
+  const spillLight = new THREE.PointLight(warm.getHex(), 0.55, 0.45, 1.9);
+  spillLight.position.set(0, 0.02, d * 0.5);
+  box.add(spillLight);
+  // 2-3 tiny table dots outside under the awning
+  const tableMat = glow(warm, 1.3);
+  const tables = [];
+  const nt = 2 + Math.floor(rng() * 2);
+  for (let i = 0; i < nt; i++) {
+    const tx = (rng() - 0.5) * w * 0.9;
+    const tz = d * 0.55 + rng() * 0.018;
+    const table = new THREE.Mesh(new THREE.CylinderGeometry(0.0035, 0.0035, 0.008, 6), tableMat);
+    table.position.set(tx, 0.004, tz);
+    box.add(table);
+    tables.push(table);
+  }
+  g.add(box);
+  const phase = rng() * 6.28;
+  return {
+    group: g,
+    accents: [glassMat],
+    update: (dt, t) => {
+      const flick = 1.4 + Math.sin(t * 2.6 + phase) * 0.18 + Math.sin(t * 7.3 + phase) * 0.06;
+      glassMat.color.copy(warm).multiplyScalar(flick);
+      spillLight.intensity = 0.46 + Math.sin(t * 2.6 + phase) * 0.12;
+      spill.material.opacity = 0.32 + Math.sin(t * 2.6 + phase) * 0.08;
+    },
+  };
+}
+
 const BUILDERS = {
   lighthouse: buildLighthouse,
   monolith: buildMonolith,
@@ -256,6 +462,9 @@ const BUILDERS = {
   village: buildVillage,
   beacon: buildBeacon,
   arch: buildArch,
+  tower: buildTower,
+  warehouse: buildWarehouse,
+  cafe: buildCafe,
 };
 
 // ---------------------------------------------------------------- manager
@@ -276,8 +485,12 @@ class Structure {
     this.built = builder(rng, color, { terrain, center: this.center });
     this.yaw = rng() * Math.PI * 2;
     this.group = this.built.group;
+    this.color = color;
     scene.add(this.group);
     this.growing = animate;
+    // emissive "spawn pop": flash the structure's glow accents on placement so a
+    // new building is unmistakable the instant it lands (verify-fleet visibility).
+    this.flash = animate && this.built.accents ? 1 : 0;
     this.seat();
   }
 
@@ -305,6 +518,12 @@ class Structure {
       if (t - this.t0 > 1.0) { this.growing = false; this.group.scale.setScalar(this.scaleArg); }
     }
     this.built.update?.(dt, t);
+    // spawn pop: a fast emissive bloom on the glow accents, eased out over ~1.1s
+    if (this.flash > 0 && this.built.accents) {
+      this.flash = Math.max(0, this.flash - dt / 1.1);
+      const boost = 1 + this.flash * this.flash * 2.4;
+      for (const mat of this.built.accents) mat.color.multiplyScalar(boost);
+    }
   }
 
   dispose() {

web/planet/terrain.js

@@ -3,10 +3,15 @@
 // New features lerp in over ~2s so the land visibly rises out of the dark.
 import * as THREE from "three";
 import { fbm3 } from "./rng.js";
-import { PLANET_R, DEG, clamp, easeInOutCubic, hsl, angleBetween } from "./util.js";
+import { PLANET_R, DEG, clamp, easeInOutCubic, easeOutCubic, hsl, angleBetween } from "./util.js";
 
 const RISE_SECONDS = 2.2;
 const GLOBAL_RELIEF = 0.012; // faint seeded micro-relief so genesis isn't a billiard ball
+// Delta "landing bloom": a transient emissive cap that floods the new ground in
+// biome light so wishes read at GIF scale (verify-fleet: deltas were invisible).
+const BLOOM_MIN_RAD = 0.085;  // never smaller than ~8% of the planet — always obvious
+const BLOOM_SECONDS = 2.6;    // ramp through the rise, then settle to a faint stain glow
+const RAISE_HUE = 38, LOWER_HUE = 205; // warm uplift / cool basin — biome-coloured
 
 // ---------------------------------------------------------------- icosphere
 function makeIcosphere(detail) {
@@ -47,6 +52,42 @@ function makeIcosphere(detail) {
   return { dirs, index, count: verts.length };
 }
 
+// ---------------------------------------------------------------- delta bloom
+// Additive emissive spherical-cap that hugs the surface over the delta site.
+// uReveal grows the lit disc; uGlow ramps its brightness during the landing.
+function deltaBloomMat(color) {
+  return new THREE.ShaderMaterial({
+    transparent: true,
+    depthWrite: false,
+    blending: THREE.AdditiveBlending,
+    side: THREE.DoubleSide,
+    uniforms: {
+      uTime: { value: 0 },
+      uReveal: { value: 0 },
+      uGlow: { value: 0 },
+      uColor: { value: color },
+    },
+    vertexShader: /* glsl */ `
+      varying vec2 vUv;
+      void main(){ vUv = uv; gl_Position = projectionMatrix*modelViewMatrix*vec4(position,1.0); }`,
+    fragmentShader: /* glsl */ `
+      varying vec2 vUv;
+      uniform float uTime, uReveal, uGlow;
+      uniform vec3 uColor;
+      void main(){
+        float r = length(vUv - 0.5) * 2.0;
+        if (r > uReveal) discard;
+        // bright shockwave ring at the leading edge, soft core inside
+        float ring = smoothstep(uReveal, uReveal - 0.16, r);
+        float core = smoothstep(1.0, 0.0, r);
+        float pulse = 0.78 + 0.22 * sin(uTime * 3.2 - r * 7.0);
+        float a = (0.30 * core + 0.95 * (1.0 - ring)) * uGlow * pulse;
+        vec3 c = uColor * (1.1 + 1.7 * (1.0 - ring));
+        gl_FragColor = vec4(c, a);
+      }`,
+  });
+}
+
 // ---------------------------------------------------------------- terrain
 export class Terrain {
   /**
@@ -61,6 +102,8 @@ export class Terrain {
     this.features = [];                       // {f, sign, center, radiusRad, h, rough, k}
     this.anims = [];                          // {rec, idx, val, t}
     this.tints = [];                          // flora tint sources {center, radiusRad, color, w}
+    this.blooms = [];                         // transient landing-bloom caps {mesh, mat, t, dur}
+    this._scene = scene;
     this._colorsDirty = true;
 
     // genesis micro-relief
@@ -153,6 +196,7 @@ export class Terrain {
     const sparse = { rec, idx: Uint32Array.from(idx), val: Float32Array.from(val), t: 0 };
     if (animate) {
       this.anims.push(sparse);
+      this._spawnDeltaBloom(rec);
     } else {
       this._fold(sparse);
     }
@@ -173,11 +217,74 @@ export class Terrain {
     this._colorsDirty = true;
   }
 
+  /**
+   * Spawn a transient emissive cap over a landing terrain delta so the wish is
+   * unmistakable at GIF scale: a biome-coloured shockwave that floods the new
+   * ground, ramps bright through the rise (~2.6s), then fades to nothing while
+   * a faint permanent biome stain stays folded into the vertex colours.
+   */
+  _spawnDeltaBloom(rec) {
+    const radiusRad = Math.max(rec.radiusRad * 1.25, BLOOM_MIN_RAD);
+    const hue = rec.sign > 0 ? RAISE_HUE : LOWER_HUE;
+    const mat = deltaBloomMat(hsl(hue, 0.8, 0.6));
+    const mesh = new THREE.Mesh(this._capGeo(rec.center, radiusRad, 0.018), mat);
+    mesh.frustumCulled = false;
+    this._scene.add(mesh);
+    this.blooms.push({ mesh, mat, t: 0, dur: BLOOM_SECONDS, center: rec.center, radiusRad });
+    // a soft, lasting biome stain so the raised land never reads as flat obsidian
+    this.tints.push({ center: rec.center, radiusRad: rec.radiusRad, color: hsl(hue, 0.42, 0.21), w: 0.55 });
+    this._colorsDirty = true;
+  }
+
+  /** Spherical-cap disc grid hugging the planet, lifted `lift` above the surface. */
+  _capGeo(center, radiusRad, lift) {
+    const rings = 16, segs = 40;
+    const positions = [], uvs = [], index = [];
+    const dir = new THREE.Vector3(), t1 = new THREE.Vector3(), t2 = new THREE.Vector3();
+    t1.set(0, 1, 0);
+    if (Math.abs(center.y) > 0.93) t1.set(1, 0, 0);
+    t2.crossVectors(center, t1).normalize();
+    t1.crossVectors(t2, center).normalize();
+    for (let r = 0; r <= rings; r++) {
+      const ang = (r / rings) * radiusRad;
+      const n = r === 0 ? 1 : segs;
+      for (let s = 0; s < n; s++) {
+        const rot = (s / n) * Math.PI * 2;
+        dir.copy(center).multiplyScalar(Math.cos(ang))
+          .addScaledVector(t2, Math.sin(ang) * Math.cos(rot))
+          .addScaledVector(t1, Math.sin(ang) * Math.sin(rot))
+          .normalize();
+        const h = this.heightAt(dir);
+        const level = PLANET_R + h + lift;
+        positions.push(dir.x * level, dir.y * level, dir.z * level);
+        uvs.push(0.5 + (r / rings) * 0.5 * Math.cos(rot), 0.5 + (r / rings) * 0.5 * Math.sin(rot));
+      }
+    }
+    const ringStart = (r) => (r === 0 ? 0 : 1 + (r - 1) * segs);
+    for (let r = 0; r < rings; r++) {
+      for (let s = 0; s < segs; s++) {
+        const sn = (s + 1) % segs;
+        const a = r === 0 ? 0 : ringStart(r) + s;
+        const a2 = r === 0 ? 0 : ringStart(r) + sn;
+        const b = ringStart(r + 1) + s;
+        const b2 = ringStart(r + 1) + sn;
+        if (r === 0) index.push(0, b, b2);
+        else index.push(a, b, b2, a, b2, a2);
+      }
+    }
+    const geo = new THREE.BufferGeometry();
+    geo.setAttribute("position", new THREE.Float32BufferAttribute(positions, 3));
+    geo.setAttribute("uv", new THREE.Float32BufferAttribute(uvs, 2));
+    geo.setIndex(index);
+    return geo;
+  }
+
   get animating() { return this.anims.length > 0; }
 
   /** @returns list of {center, radiusRad} that changed this frame (for reseating). */
   update(dt) {
     const changed = [];
+    if (this.blooms.length) this._updateBlooms(dt);
     if (this.anims.length) {
       const done = [];
       for (const a of this.anims) {
@@ -199,6 +306,26 @@ export class Terrain {
     return changed;
   }
 
+  _updateBlooms(dt) {
+    this._bloomClock = (this._bloomClock ?? 0) + dt;
+    const done = [];
+    for (const b of this.blooms) {
+      b.t += dt;
+      const k = clamp(b.t / b.dur, 0, 1);
+      // reveal sweeps out fast, brightness ramps with the rise then fades out
+      b.mat.uniforms.uReveal.value = easeOutCubic(b.t / (b.dur * 0.42));
+      b.mat.uniforms.uGlow.value = Math.sin(Math.min(k, 1) * Math.PI) * 1.0;
+      b.mat.uniforms.uTime.value = this._bloomClock;
+      if (b.t >= b.dur) done.push(b);
+    }
+    for (const b of done) {
+      this.blooms.splice(this.blooms.indexOf(b), 1);
+      b.mesh.removeFromParent();
+      b.mesh.geometry.dispose();
+      b.mat.dispose();
+    }
+  }
+
   _writeAll() {
     const pos = this.geometry.attributes.position.array;
     const d = this.dirs;
@@ -276,6 +403,12 @@ export class Terrain {
   }
 
   dispose() {
+    for (const b of this.blooms) {
+      b.mesh.removeFromParent();
+      b.mesh.geometry.dispose();
+      b.mat.dispose();
+    }
+    this.blooms = [];
     this.mesh.removeFromParent();
     this.geometry.dispose();
     this.material.dispose();

web/planet/water.js

@@ -234,6 +234,31 @@ export class Water {
     for (const w of this.items) w.update(dt, t);
   }
 
+  /**
+   * Read-only: unit-dir waypoints of the nearest stream whose body comes within
+   * `maxRad` of `center`, else null. Used by life.js carts to glide along an
+   * existing river before falling back to a seeded loop. Deterministic.
+   */
+  streamPathNear(center, maxRad) {
+    let best = null, bestAng = Infinity;
+    for (const w of this.items) {
+      if (!(w instanceof Stream)) continue;
+      const ang = angleBetween(w.center, center);
+      if (ang - w.reachRad < maxRad && ang < bestAng) { bestAng = ang; best = w; }
+    }
+    if (!best) return null;
+    // densify the great-circle path between waypoints into a smooth dir list
+    const dirs = [];
+    for (let i = 0; i < best.waypoints.length - 1; i++) {
+      const a = best.waypoints[i], b = best.waypoints[i + 1];
+      const steps = Math.max(4, Math.ceil(angleBetween(a, b) / (3 * DEG)));
+      for (let s = i === 0 ? 0 : 1; s <= steps; s++) {
+        dirs.push(slerpDirs(a, b, s / steps, new THREE.Vector3()).clone());
+      }
+    }
+    return dirs.length >= 2 ? dirs : null;
+  }
+
   reseat(center, radiusRad) {
     for (const w of this.items) {
       if (angleBetween(w.center, center) < w.reachRad + radiusRad) w.reseat();

web/planet/world.js

@@ -6,6 +6,7 @@ import { Terrain } from "./terrain.js";
 import { Flora } from "./flora.js";
 import { Structures } from "./structures.js";
 import { Water } from "./water.js";
+import { Life } from "./life.js";
 import { Weather } from "./weather.js";
 import { Sky } from "./sky.js";
 import { Inscriptions } from "./inscriptions.js";
@@ -27,6 +28,7 @@ export class World {
     this.flora = new Flora(this.scene, this.terrain, this.quality);
     this.structures = new Structures(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);
     if (this._px) this.setPxScale(this._px);
   }
@@ -60,6 +62,9 @@ export class World {
       case "place_water":
         target = this.water.addFeature(f, { animate, t });
         break;
+      case "spawn_life":
+        target = this.life.addFeature(f, { animate, t });
+        break;
       case "set_weather":
         this.weather.set(f.args.kind, clamp(f.args.intensity ?? 0.5, 0, 1), { animate });
         wide = true;
@@ -85,6 +90,7 @@ export class World {
     this.flora.dispose();
     this.structures.dispose();
     this.water.dispose();
+    this.life.dispose();
     this.inscriptions.dispose();
     this.terrain.dispose();
     this.features = [];
@@ -104,11 +110,13 @@ export class World {
       this.flora.reseat(c.center, c.radiusRad);
       this.structures.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.water.update(dt, t);
+    this.life.update(dt, t);
     this.weather.update(dt, t);
     this.sky.update(dt, t);
     this.inscriptions.update(dt, t);

web/style.css

@@ -110,10 +110,16 @@ html, body {
 /* ---------- the god speaks ---------- */
 .voice {
   position: fixed; left: 42px; bottom: 42px; z-index: 10;
-  width: min(390px, calc(100vw - 84px));
+  width: min(440px, calc(100vw - 84px));
   border-left: 1px solid var(--hairline);
-  padding-left: 20px;
+  padding: 16px 20px 16px 20px;
   pointer-events: none;
+  /* a subtle dark scrim so the god's voice reads over the bright planet rim —
+     the ticker is the second-largest text while granting and must not wash out */
+  background: linear-gradient(105deg, rgba(4, 5, 9, 0.72), rgba(4, 5, 9, 0.32) 72%, transparent);
+  border-radius: 2px;
+  -webkit-backdrop-filter: blur(3px);
+  backdrop-filter: blur(3px);
 }
 .voice__head {
   display: flex; align-items: baseline; gap: 10px;
@@ -138,26 +144,29 @@ html, body {
 }
 .voice__stream {
   font-family: var(--mono);
-  font-size: 12.5px;
-  line-height: 1.75;
-  color: var(--ivory-dim);
-  max-height: 168px;
+  /* second-largest text while granting — readable on the live screenshots */
+  font-size: 18px;
+  line-height: 1.62;
+  letter-spacing: 0.01em;
+  color: rgba(236, 229, 216, 0.78);
+  max-height: 232px;
   overflow: hidden;
   display: flex;
   flex-direction: column;
   justify-content: flex-end;
   white-space: pre-wrap;
   word-break: break-word;
+  text-shadow: 0 1px 10px rgba(2, 3, 6, 0.65);
   mask-image: linear-gradient(to bottom, transparent, black 28%);
   -webkit-mask-image: linear-gradient(to bottom, transparent, black 28%);
 }
 .voice__innertext { display: inline-block; white-space: pre-wrap; }
 .voice__stream .tone-reading { color: var(--ivory); }
-.voice__stream .tone-call { color: var(--gold); }
-.voice__stream .tone-obs { color: var(--violet); opacity: 0.85; }
+.voice__stream .tone-call { color: var(--gold-bright); font-weight: 400; }
+.voice__stream .tone-obs { color: var(--violet); opacity: 0.92; }
 .voice__caret {
-  display: inline-block; width: 7px; height: 13px;
-  background: var(--gold); vertical-align: -2px; margin-left: 2px;
+  display: inline-block; width: 8px; height: 17px;
+  background: var(--gold); vertical-align: -3px; margin-left: 2px;
   animation: caret 1.1s steps(2) infinite;
 }
 @keyframes caret { 50% { opacity: 0; } }
@@ -191,6 +200,31 @@ html, body {
   font-size: 10px; letter-spacing: 0.34em; text-transform: uppercase;
   color: var(--gold);
 }
+.epitaph__descend[hidden] { display: none; }
+.epitaph__descend {
+  display: inline-block;
+  margin-top: 20px;
+  padding: 8px 22px;
+  font-family: var(--serif);
+  font-style: italic;
+  font-size: 17px;
+  letter-spacing: 0.05em;
+  color: var(--gold);
+  background: rgba(7, 8, 14, 0.5);
+  border: 1px solid var(--hairline);
+  border-radius: 999px;
+  cursor: pointer;
+  pointer-events: auto;
+  -webkit-backdrop-filter: blur(6px);
+  backdrop-filter: blur(6px);
+  transition: color 0.25s, border-color 0.25s, box-shadow 0.25s, transform 0.25s;
+}
+.epitaph__descend:hover {
+  color: var(--gold-bright);
+  border-color: var(--gold);
+  box-shadow: 0 0 28px rgba(217, 179, 108, 0.18);
+  transform: translateY(-1px);
+}
 
 /* ---------- altar (wish input) ---------- */
 .altar {
@@ -289,6 +323,19 @@ html, body {
   color: var(--ivory-faint);
 }
 
+/* a left-side dark gradient scrim so the log column reads over the bright
+   planet rim + gold trail — sits behind the entries, fades to clear on the
+   right so the planet still breathes. */
+.ledger-scrim {
+  position: fixed; left: 0; top: 0; bottom: 0; z-index: 9;
+  width: min(560px, 56vw);
+  pointer-events: none;
+  background: linear-gradient(to right,
+    rgba(3, 4, 8, 0.82) 0%,
+    rgba(3, 4, 8, 0.66) 34%,
+    rgba(3, 4, 8, 0.34) 62%,
+    transparent 100%);
+}
 .ledger {
   position: fixed; top: 168px; bottom: 36px; left: 42px; z-index: 10;
   width: min(360px, calc(100vw - 64px));
@@ -353,7 +400,8 @@ html, body {
 @media (max-width: 760px) {
   .almanac { right: 20px; top: 28px; }
   .voice { left: 20px; bottom: 130px; width: calc(100vw - 40px); max-width: none; }
-  .voice__stream { max-height: 96px; font-size: 11.5px; }
+  .voice__stream { max-height: 118px; font-size: 15px; line-height: 1.5; }
+  .ledger-scrim { width: 100vw; }
   .altar { bottom: 18px; }
   .status { display: none; }
   .brand { top: 22px; }