Read a window of the story per turn instead of all of it

Two reads still grew without bound after the snapshot fix.

`Action.variants` holds every discarded retry attempt, but a list response
only needs how many there are — so each retry permanently added ~5 KB to
every later load of that adventure. Defer the column and keep the count
beside it (migration 37, backfilled server-side), with set_variants() as the
one write path that keeps the two in step.

`story_actions()` walked adventure.actions, then every caller threw almost
all of it away: the builder concatenates the story and immediately cuts it
back to the token budget, the NPC check looks at the last 6, retrieval at the
last 4, the cursor clamp only wants a count. A turn on a 200-action adventure
read 839 KB to use ~70 KB, and grew with every turn played. app/context/
history.py serves those shapes from SQL; window_covering() measures the
actions it fetched and projects how many more it needs, fetching only the
part it does not already hold. Memorybank cursors move to position_of_index()
and settled_count()/settled_slice() — same arithmetic, no full list.

The scripting pipeline still receives the whole history per AI Dungeon's API,
and every helper reuses adventure.actions when it is already loaded, so a
scripted adventure pays what it always did and never twice.

Measured at production shape: retry tax 5.1 KB -> 0; turn 200 839 KB -> 129 KB
and flat from ~turn 50; a 200-turn playthrough 84.5 MB -> 23.0 MB; a delete
115 KB -> 5 KB.

Verified the window builds a byte-identical prompt to the full story across
budgets from 1K to 100K tokens, with and without the retry exclusion - this
is a cost change and nothing else. Cursor helpers checked against the old list
arithmetic, including after deleting a middle action. Counts are real
SELECT count(...): Query.count() wraps the entity select in a subquery, so the
SQL named every deferred column and the egress guard could not tell it apart
from a bulk fetch. 139 tests pass; the four new guards verified by sabotage.

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

backend/tests/test_egress.py

@@ -22,6 +22,7 @@ from fastapi.testclient import TestClient
 from sqlalchemy import event, text
 
 from app import auth, limits, migrations, models
+from app.context import history
 from app.database import Base, SessionLocal, engine, get_db
 from app.main import app
 
@@ -37,6 +38,14 @@ BIG_SNAPSHOT = {
     },
 }
 
+# Retry history: each discarded attempt keeps its full narration, so an action
+# retried a few times carries several KB that a list response only ever counts.
+BIG_VARIANTS = [
+    {"text": "z" * 4_000, "reasoning": None, "script_state": {},
+     "created_at": "2026-01-01T00:00:00"}
+    for _ in range(3)
+]
+
 
 @pytest.fixture()
 def sql_log():
@@ -71,6 +80,10 @@ def client(monkeypatch):
             context_snapshot=BIG_SNAPSHOT,
             world_delta={"delta": {"player.hp": -15},
                          "applied": [{"path": "player.hp", "old": 100, "new": 85}]},
+            # Every AI action has been retried twice, so `variants` is carrying
+            # weight the list response must not pay for.
+            variants=BIG_VARIANTS if i % 2 else None,
+            variant_count=len(BIG_VARIANTS) if i % 2 else 0,
         ))
     setup.commit()
     adv_id, user_id = adventure.id, user.id
@@ -129,6 +142,48 @@ def test_world_changes_still_works_without_the_snapshot(client):
     ]
 
 
+def test_loading_an_adventure_does_not_fetch_variants(client, sql_log):
+    """Same failure as context_snapshot, one size down: the payload carries
+    only `variant_count`, but loading the column to compute it made every retry
+    a permanent tax on every later load of that adventure."""
+    r = client.get(f"/api/adventures/{client.adv_id}")
+    assert r.status_code == 200, r.text
+
+    selects = action_selects(sql_log)
+    assert selects, "expected at least one SELECT against actions"
+    offenders = [s for s in selects if "variants" in s]
+    assert offenders == [], f"variants was fetched in bulk:\n{offenders[0][:400]}"
+
+
+def test_variant_count_survives_variants_being_deferred(client):
+    """The pager reads this number; it has to be right without the column."""
+    r = client.get(f"/api/adventures/{client.adv_id}")
+    by_type = {}
+    for action in r.json()["actions"]:
+        by_type.setdefault(action["type"], []).append(action)
+    assert all(a["variant_count"] == len(BIG_VARIANTS) for a in by_type["ai"])
+    assert all(a["variant_count"] == 0 for a in by_type["do"])
+
+
+def test_counting_actions_does_not_name_the_deferred_columns(client, sql_log):
+    """A count that wraps the entity select in a subquery names every column in
+    the emitted SQL — no bytes come back, but the database still reads them and
+    the guard above cannot tell it apart from a real bulk fetch."""
+    db = SessionLocal()
+    try:
+        adventure = db.get(models.Adventure, client.adv_id)
+        sql_log.clear()
+        assert history.count(adventure) == 12
+        counts = [s for s in sql_log if "count" in s.lower()]
+        assert counts, "expected a COUNT to be emitted"
+        for column in ("context_snapshot", "state_before", "world_state_before", "variants"):
+            assert not any(column in s for s in counts), (
+                f"{column} is named by the count query:\n{counts[0][:400]}"
+            )
+    finally:
+        db.close()
+
+
 def test_snapshot_is_still_reachable_on_demand(client):
     """Deferred means lazy, not gone — Insights still gets the full thing."""
     r = client.get(f"/api/adventures/{client.adv_id}")
@@ -163,6 +218,27 @@ def test_backfill_populates_world_delta_from_existing_snapshots(client):
         db.close()
 
 
+def test_backfill_populates_variant_count_from_existing_variants(client):
+    """Migration 37 counts the lists server-side — reading them into Python to
+    count them would mean pulling the column across the wire once to stop
+    pulling it across forever."""
+    db = SessionLocal()
+    try:
+        db.execute(text("UPDATE actions SET variant_count = 0"))
+        db.commit()
+
+        with engine.begin() as conn:
+            migrations._backfill_variant_count(conn)
+
+        db.expire_all()
+        actions = db.query(models.Action).order_by(models.Action.index).all()
+        for action in actions:
+            expected = len(BIG_VARIANTS) if action.type == "ai" else 0
+            assert action.variant_count == expected, f"action {action.index}"
+    finally:
+        db.close()
+
+
 def test_backfill_leaves_actions_without_world_state_alone(client):
     db = SessionLocal()
     try: