Read one story, and know which one

Every read of an action now goes through a single module. `context/lineage.py`
turns a branch's stored lineage into the OR-of-ranges that is "this story", and
history, paging, the newest-action lookups, the index screen and the scripting
history API all select through it. A forgotten clause does not raise — it
quietly assembles a page, or a prompt, out of two different stories — so the
clause lives in one place rather than in a convention.

The read that mattered most was the shortcut: `_from_memory` sliced
`adventure.actions`, which is every branch's actions, not the path. It now cuts
the loaded collection down with the same predicate the SQL uses. Same trap one
layer up, and user-visible: `pipeline._history()` hands user scripts the story,
and was handing them the collection.

Tail reads window the lineage as well as the rows: the newest few entries cover
the context budget, so a story forked twenty times reads its tail with one
clause and costs 1.07x what an unforked story of the same length costs. The
estimate is depth arithmetic, and where a deleted action leaves a gap the read
notices it came up short and widens to the whole ancestry.

Ordering moves from `index` to `depth`, with `id` breaking ties. The two hold
the same numbers until retry stops mutating rows in SP4, but only one of them
is a position along a path.

One thing SP1 did not anticipate: wiring the writers was not enough. From here
a row without a branch is a row no read can see, and "every writer remembers"
has to hold for every fixture, script and test ever written — including the
SP0 baseline, which writes its actions straight to the database and must pass
unmodified. So the session enforces it: `tree.place_new_nodes` runs from
before_flush and places anything unplaced. The call sites keep their explicit
calls, because a node placed at the call site is placed before the code around
it reads it back.

316 tests green: the 297 from SP1, plus 19 in test_branch_clause.py.

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

backend/app/scripting/pipeline.py

@@ -4,6 +4,7 @@ state and story-card mutations back to the database after each hook."""
 from sqlalchemy.orm import Session
 
 from .. import models
+from ..context import history as context_history
 from .engine import run_hook
 
 MAX_STORY_CARDS = 5000  # AI Dungeon's per-adventure sanity cap
@@ -23,9 +24,13 @@ class ScriptPipeline:
         return msg if isinstance(msg, str) and msg.strip() else None
 
     def _history(self) -> list[dict]:
+        # The path, not `adventure.actions` — that collection is every branch's
+        # actions, and this is the documented history API a user script reads.
+        # Handing a script the siblings of the turn it is running on would be
+        # the same bug as building a prompt from them, only user-visible.
         return [
             {"text": a.text, "rawText": a.text, "type": a.type}
-            for a in self.adventure.actions
+            for a in context_history.story_actions(self.adventure)
         ]
 
     def _cards(self) -> list[dict]:
@@ -36,7 +41,7 @@ class ScriptPipeline:
 
     def _info(self) -> dict:
         return {
-            "actionCount": len(self.adventure.actions),
+            "actionCount": context_history.count(self.adventure),
             "characterNames": [],
             "memoryLength": len(self.adventure.memory),
             "maxChars": 0,