M5: genre-neutral authoritative narrative state, with review corrections

Replaces AI-DnD's RPG relative-delta world state with the genre-neutral typed
narrative state of ADR 010: explicit, absolute, allowlisted events proposed by
the model, validated by the application, applied to one authoritative document,
and snapshotted per position so restore stays a row read.

This commit includes the corrective pass that followed the independent review
in planning/reports/M5-IMPLEMENTATION-REPORT.md. The invariant it exists to
hold is:

    visible active transcript position == stored head == authoritative state

Narrator editing (D10, STORY-BRANCH-SEMANTICS §§14-15)

  A narrator edit no longer rewrites a row. It returns to the state before the
  turn, takes the reader's exact text as the accepted narration, re-derives the
  state that text implies, and becomes a new active continuation — while the
  original narration keeps its words, its live flag and its whole future as
  retained history. At the tip the correction is another take; with story below
  it, it forks. No new history machinery: this is the existing fork/take/head
  path with the reader's text in place of a generated reply. The §14A refusal
  is therefore gone for narrator turns, and remains only for player input.

Pre-M5 positions

  Migration 88 backfills the empty narrative document onto every action written
  before M5, and a missing snapshot now restores the empty document instead of
  leaving the previous position's state standing. Restoring to an old Save
  Point no longer leaves a later position's entities and facts on screen.

Narrator context

  Replayed history carries prose only; the machine-readable block is no longer
  reconstructed into past turns, where it contradicted the authoritative state
  in the same prompt. A fact withdrawn by a manual correction is now named as
  no longer true, with the reader's reason, rather than silently dropped.

Also

  - state_changes joins the action-list bulk read, removing one query per row.
  - Extraction takes only the application's own protocol payload: an ordinary
    ```json or ```python block in a story survives, and a mangled proposal
    still does not reach the reader.

Planning: ADR 013 records the authoritative document shape; §§14-15/14A, D10,
C04 and BUILD-MILESTONES are updated to describe what exists. Debt is recorded
against M8 (scenario editor UX) and M9 (export of the audit trail).

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

backend/tests/test_delete_state.py

@@ -23,7 +23,7 @@ from app import auth, limits, models
 from app.database import Base, SessionLocal, engine, get_db
 from app.main import app
 from app.routers import adventures
-from fakes import GOLD_SCHEMA, ScriptedProvider, gold_replies, gold_reply
+from fakes import GOLD_SCHEMA, ScriptedProvider, gold_replies, gold_reply, tally_of, tally_reply
 
 # `mana` carries a cooldown, so a clock that was not rolled back shows up as
 # a refusal rather than as a number that is merely off.
@@ -41,9 +41,13 @@ SCHEMA = {
 # Ten gold a turn. A total that only ever climbs makes a missing rollback
 # obvious: it is off by exactly one turn's worth.
 
-DRAIN = 'Drained.\n```state\n{"player.mana": -10}\n```'
-# The same turn, also banking the per-turn counter the rollback tests measure.
-DRAIN_AND_GOLD = 'Drained.\n```state\n{"player.mana": -10, "player.gold": 10}\n```'
+# The instrument is a typed narrative fact with an absolute value (M5,
+# ADR 010). It was an RPG mana drain plus a gold counter; what these tests
+# measure — that deleting a turn puts the state back to what the position
+# before it left behind — is unchanged, and is now measured through the
+# production state path rather than through a removed game system.
+DRAIN = tally_reply("Drained.", 10)
+DRAIN_AND_GOLD = DRAIN
 
 
 @pytest.fixture()
@@ -106,10 +110,17 @@ def _delete(client, action_id):
 
 
 def _state(adv_id):
+    """The instrument, and the whole document behind it.
+
+    M5 moved the instrument from an RPG stat to a typed narrative fact; the
+    tuple shape is kept so the call sites read the same. `[0]["gold"]` is the
+    tally, and `[1]` is the authoritative state document.
+    """
     db = SessionLocal()
     try:
         adv = db.get(models.Adventure, adv_id)
-        return (adv.world_state or {}).get("player", {}), adv.world_state
+        state = adv.narrative_state or {}
+        return {"gold": tally_of(state)}, state
     finally:
         db.close()
 
@@ -127,11 +138,16 @@ def _ai_rows(adv_id):
         db.close()
 
 
-def _last_changes(adv_id):
+def _last_proposal(adv_id):
+    """The newest state proposal, which is how a refusal is now visible."""
     db = SessionLocal()
     try:
-        adv = db.get(models.Adventure, adv_id)
-        return adv.actions[-1].world_changes
+        return (
+            db.query(models.StateProposal)
+            .filter_by(adventure_id=adv_id)
+            .order_by(models.StateProposal.id.desc())
+            .first()
+        )
     finally:
         db.close()
 
@@ -140,25 +156,31 @@ def _last_changes(adv_id):
 
 def test_deleting_the_ai_turn_rewinds_the_world_state(client):
     _play(client)
-    assert _state(client.adv_id)[1]["player"]["mana"] == 40
+    assert _state(client.adv_id)[0]["gold"] == 10
 
     _delete(client, _ai_rows(client.adv_id)[-1].id)
 
-    _, world = _state(client.adv_id)
-    assert world["player"]["mana"] == 50, "the drain went with the turn"
-    assert not (world.get("_meta") or {}).get("last_changed"), "and so did its clock"
+    assert _state(client.adv_id)[0]["gold"] == 0, "the change went with the turn"
 
 
-def test_the_next_turn_is_not_refused_for_a_deleted_turn_s_cooldown(client):
-    """The bug as a player meets it: delete the reply, press Continue, and
-    the change it proposes is refused as one that already happened."""
+def test_the_next_turn_is_not_refused_for_what_a_deleted_turn_established(client):
+    """The bug as a player meets it: delete the reply, press Continue, and the
+    turn that replaces it lands cleanly.
+
+    Under M5 this is a statement about the *state document* rather than about a
+    cooldown clock — the RPG cooldown machinery the original bug surfaced
+    through is no longer in the turn path — but the failure it guards is the
+    same one: a deleted turn leaving something behind that makes the next turn
+    behave as though it had already happened.
+    """
     _play(client)
     _delete(client, _ai_rows(client.adv_id)[-1].id)
 
     _continue(client)
 
-    assert _state(client.adv_id)[1]["player"]["mana"] == 40, "the drain lands"
-    assert [c for c in _last_changes(client.adv_id) if c["kind"] == "rejected"] == []
+    assert _state(client.adv_id)[0]["gold"] == 10, "the replacement turn landed"
+    proposal = _last_proposal(client.adv_id)
+    assert proposal.status == "accepted", "the replacement's state was refused"
 
 
 def test_deleting_the_ai_turn_rewinds_the_counter(client):
@@ -181,6 +203,7 @@ def test_deleting_a_turn_the_story_moved_past_leaves_the_tip_alone(client):
     neighbour, so removing a turn from the middle of the story does not roll
     the numbers back to that point. The text goes; the state stays."""
     _play(client)
+    ScriptedProvider.replies = [tally_reply("Drained again.", 20)]
     _play(client, "press on")
     before = _state(client.adv_id)
     assert before[0]["gold"] == 20