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

README.md

@@ -32,8 +32,10 @@ that isn't the live one starts a new branch.
 ## Features
 
 - **The full play loop.** Do / Say / Story / Continue actions, streamed AI responses (SSE),
-  retry, undo, redo, and edit. Reasoning models are supported: "thinking" streams into a collapsible
-  💭 panel with its own token budget.
+  retry, undo, redo, and edit. Correcting narrator prose does not overwrite it: the correction
+  becomes a new continuation carrying the state it implies, and the original narration keeps its
+  own future as retained history. Reasoning models are supported: "thinking" streams into a
+  collapsible 💭 panel with its own token budget.
 - **A branching story tree.** The story is a tree, not a list. Any turn can hold more than one
   **take**, and `‹ 2/4 ›` steps between them. Stepping is free: the story below simply empties,
   and the server is told nothing. Writing below a take that isn't the live one is what makes a
@@ -42,13 +44,17 @@ that isn't the live one starts a new branch.
   line's world state, script state, and cooldown clocks. A branch panel switches, renames, and
   deletes; **⌗ See the tree** draws every line against the story's own clock
   (`backend/app/tree.py`, `backend/app/context/lineage.py`).
-- **An RPG world-state engine.** A scenario can declare stats, flags, milestones, and a named
-  cast; the adventure carries their live values. The AI proposes deltas, and a Python engine
-  referees them: it clamps values to range, enforces per-turn caps and cooldowns, keeps counters
-  monotonic and milestones sticky, then strips the machine-readable block out of the prose
-  (`backend/app/worldstate/`: `apply.py` clamps, `parse.py` reads the block back).
-  Word-labeled bands (`40–60: minor damage`) make the
-  model reliable at it. No dice and no scripting are required.
+- **Authoritative narrative state, and the application owns it.** The story tracks who exists,
+  where they are, what they hold, what is true, how they are tied to each other, and what is
+  still open — as generic entities, facts, relationships and threads, with no genre baked in.
+  The same schema holds a silver key in an abbey and a data crystal on an orbital station.
+  The AI proposes **typed events with absolute values** (`set_possession`, `add_fact`,
+  `set_current_location` …), and a Python validator decides what is accepted: unknown event
+  types are refused, references must resolve, campaign canon outranks the narration, and the
+  machine-readable block never reaches the reader (`backend/app/narrative/`). Every accepted
+  change is recorded with what it was before and which turn caused it, so the Story State panel
+  can show what changed and why. You can correct it by hand, and your correction outranks the
+  story.
 - **AI Dungeon-compatible context engine.** Memory, author's note, and story cards (world
   info) are triggered by keywords in recent story text, then assembled under a token budget
   (`backend/app/context/builder.py`).
@@ -212,7 +218,8 @@ frontend/   React + Vite SPA  ──HTTP/SSE──►  backend/  FastAPI
                                               ├─ checkpoints   Save Points: durable names for positions, in routers/adventures/
                                               ├─ attempts.py   the takes of one turn, grouped by parent
                                               ├─ context/      prompt assembly under a token budget + lineage/history windowing
-                                              ├─ worldstate/   the stat engine: clamps, cooldowns, bands, milestones
+                                              ├─ narrative/    the authoritative state: typed events, validation, snapshots
+                                              ├─ worldstate/   the inherited RPG stat engine — legacy, no longer authoritative
                                               ├─ memorybank.py auto-summarization + embedding retrieval
                                               ├─ bundle.py     the export/import formats, v2 (tree) and a v1 reader
                                               ├─ providers/    OpenAI-compatible adapter, streaming
@@ -224,7 +231,7 @@ development, Vite proxies `/api` to FastAPI.
 
 ## Tests
 
-698 backend tests: unit tests plus full HTTP integration through the real turn engine, with
+756 backend tests: unit tests plus full HTTP integration through the real turn engine, with
 the model provider mocked. They run with no route to the Internet, which is a requirement
 rather than a convenience — an offline claim proved on a machine that has been online once
 proves nothing.