Make a retry a node, not a rewrite

Every attempt at a turn is now its own row at the same (branch, depth),
with `live` naming the one the story tells. The JSON repeating group on
`actions.variants` is read one last time, by a migration that writes it
out as the sibling rows it always described, and then goes unread.

The snapshots turn around with it: an action carries the state it left
behind rather than the state it started from, because attempts at one
turn share a starting position and differ exactly in their outcome.
Rolling back is "what the node in front left behind", one lookup on the
path, and it is what undo and retry now both read.

And the memory holdback goes. It existed because retry rewrote a row
under a mark that had already moved past it; a retry writes a sibling
now, and replacing what a coordinate says withdraws what was derived
from it — the same repair undo and delete already made.

The assembled prompt is still stored once per turn: it moves with the
live flag, so a superseded attempt keeps only the few hundred bytes that
were its own. Measured on the 600-action fixture: 700 rows for the same
600-turn story, prompt archive byte-identical at 0.50 MB, index 1.8 kB
and page load 62.7 kB unmoved.

347 tests green. `tests/test_story_tree_baseline.py` and
`tests/test_retry_variants.py` pass unmodified — SP4 was allowed to move
the baseline for the variant-count semantics and did not need to.

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

backend/app/context/history.py

@@ -28,12 +28,12 @@ Three rules hold everything together:
   SQL does. This is the line that would silently assemble a prompt out of two
   different stories, which is why `lineage.Path` owns both halves of it.
 
-Ordering is by `depth` now, not `index`. The two hold the same numbers until
-retry stops mutating rows (SP4), but only one of them is a position along a
-path.
+Ordering is by `depth` now, not `index`. Since SP4 the two can hold the same
+number on *different rows* — attempts at one turn share both — so only `depth`
+plus the branch clause's `live` test says which of them the story is.
 
 SP3 added the reads that count *from a node* rather than from the start —
-`count_after`, `after`, `newest_settled`. The memory bank used to ask for
+`count_after`, `after`, `newest`. The memory bank used to ask for
 "positions 12 to 18 of the story", which is a question whose answer moves when
 an action is deleted from in front of it. It now asks for "the six actions
 after depth 41", which is the same question a fork has to answer anyway.
@@ -202,8 +202,9 @@ def story_actions(
     or `count` anywhere the caller only needs part of it.
 
     `exclude_action_id` drops one action from the story — used by retry, where
-    the row being regenerated is still attached to the adventure (it holds the
-    variant history) but must not appear in the context assembled to replace it.
+    the attempt being replaced is still the live node of its turn (it stays
+    live until a replacement exists) but must not appear in the context
+    assembled to replace it.
     """
     in_memory = _from_memory(adventure, exclude_action_id)
     if in_memory is not None:
@@ -387,15 +388,20 @@ def after(
     )
 
 
-def newest_settled(adventure: models.Adventure) -> models.Action | None:
-    """The newest story action that is not the newest one — see
-    `memorybank.settled_story_actions` for why one is always held back.
+def newest(adventure: models.Adventure) -> models.Action | None:
+    """The newest story action, or None on an empty story.
 
-    Two rows, not a count and an offset: this is the node an anchor moves to
-    when derived work catches up with the settled end of the story.
+    A row, not a count and an offset: this is the node an anchor moves to when
+    derived work catches up with the end of the story.
+
+    It used to be the *second* newest — the memory bank held one action back
+    because retry rewrote a row, so a memory covering the newest action could
+    end up describing narration the player had retried away. Since SP4 a retry
+    writes a sibling instead, and the coordinate's derived work is withdrawn
+    when the story at it changes, so there is nothing left to hold back.
     """
-    rows = tail(adventure, 2)
-    return rows[0] if len(rows) == 2 else None
+    rows = tail(adventure, 1)
+    return rows[0] if rows else None
 
 
 def max_action_index(adventure: models.Adventure) -> int:

backend/app/context/lineage.py

@@ -102,6 +102,12 @@ class Path:
         after it was typed. An action with no depth is a pre-tree row that no
         read should see, so actions never pass this.
 
+        Actions also have to be *live* (SP4). A coordinate can hold several
+        attempts at the same turn, and the story tells one of them; the losing
+        siblings sit at the same branch and depth and are excluded here, once,
+        so that no read of the story has to know that retries exist. Only
+        `app/attempts.py` looks past this.
+
         An empty path yields `false`, not "no filter": an adventure whose nodes
         carry no branch has no story, and the loud version of that is an empty
         page, not every branch at once.
@@ -109,7 +115,10 @@ class Path:
         entries = self.entries if count is None else self.entries[:count]
         if not entries:
             return false()
-        return or_(*[self._entry_clause(model, b, d, unanchored) for b, d in entries])
+        on_path = or_(*[self._entry_clause(model, b, d, unanchored) for b, d in entries])
+        if model is models.Action:
+            return and_(on_path, models.Action.live.is_(True))
+        return on_path
 
     @staticmethod
     def _entry_clause(model, branch_id: int, max_depth: int | None, unanchored=False):
@@ -128,7 +137,12 @@ class Path:
         Used where the rows are already in memory (the scripting pipeline hands
         user scripts the whole history), so an already-loaded collection can be
         cut down to the path without a second read.
+
+        `live` is checked first, and only on rows that have the attribute:
+        memories have no siblings to lose to.
         """
+        if getattr(node, "live", True) is False:
+            return False
         for branch_id, max_depth in self.entries:
             if node.branch_id != branch_id:
                 continue