Cut database egress 189x by deferring the prompt snapshot

The free-tier 5 GB/month network transfer allowance ran out, which blocks
connections outright. The database is only ~55 MB, so 5 GB meant the whole
thing was being pulled roughly 90 times over.

Cause: actions is 39 MB of that 55 MB -- 541 rows at ~74 KB each, almost
entirely context_snapshot, which stores the whole assembled prompt for a
turn. Every adventure load and every turn fetched all of it in order to
read two small things out of it: the world-change chips under an AI
message (Action.world_changes) and the emit block re-attached when
replaying history to the model (_history_text). The Insights viewer is
the only consumer that wants the whole snapshot, and it asks for one
action at a time.

Lifts that slice into its own small actions.world_delta column
(migration 36) and marks context_snapshot, state_before and
world_state_before deferred, so they load only when something touches
the attribute -- Insights, undo and retry, all single-action paths.
The backfill runs server-side, dialect-specific (json_extract on SQLite,
#> on Postgres), because pulling 39 MB of snapshots into Python to
rewrite a slice of each would defeat the purpose.

Measured at production shape (541 actions, 72 KB snapshots), one
adventure load goes from 38.46 MB to 0.20 MB. The traffic that consumed
5 GB would now be about 27 MB.

Deliberately not included: limiting the history query to recent actions,
and removing the redundant db.refresh(adventure) calls. Both were sized
against the old numbers; against a 0.20 MB load they would take ~27 MB a
month down to ~10 MB, which is not worth the complexity.

tests/test_egress.py hooks before_cursor_execute and asserts the emitted
SQL never names the deferred columns during a bulk load, so this cannot
regress silently. 123 tests pass.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UeQVy5bEjLhfgWNc27Efet

backend/app/routers/adventures.py

@@ -333,6 +333,22 @@ def snapshot_world_state(adventure: models.Adventure) -> dict:
 VARIANT_SNAPSHOT_KEYS = ("world_state", "script", "raw_output")
 
 
+def world_delta_of(snapshot: dict | None) -> dict | None:
+    """The bulk-read slice of a context snapshot, for Action.world_delta.
+
+    context_snapshot is deferred (it holds the whole assembled prompt), so the
+    two things that ARE needed for every action — the world-change chips and
+    the emit block replayed into history — get their own small column. Keep
+    this in step with the snapshot wherever one is written."""
+    ws = (snapshot or {}).get("world_state")
+    if not isinstance(ws, dict):
+        return None
+    return {
+        "delta": ws.get("delta") or {},
+        "applied": (ws.get("report") or {}).get("applied") or [],
+    }
+
+
 def variant_of(action: models.Action, adventure: models.Adventure) -> dict:
     """Freeze an action's *current* content as a variant entry.
 
@@ -365,6 +381,7 @@ def apply_variant(action: models.Action, adventure: models.Adventure, index: int
         else:
             snapshot.pop(key, None)
     action.context_snapshot = snapshot
+    action.world_delta = world_delta_of(snapshot)
     action.variant_index = index
     if isinstance(entry.get("script_state"), dict):
         adventure.script_state = copy.deepcopy(entry["script_state"])
@@ -637,6 +654,7 @@ async def _generate_turn(
             text=text,
             reasoning=reasoning,
             context_snapshot=snapshot,
+            world_delta=world_delta_of(snapshot),
             state_before=state_before,
             world_state_before=world_state_before,
         )