JesseMarkowitzandClaude Opus 5
903fa7a74f
Undo deleted. It removed the trailing AI action and the player action in front of it, pruned the memories covering them, and let the tip fall back to whatever survived. That made it the one operation in the application that destroyed accepted story, and it was why there was no Redo: the turns to move forward into no longer existed. Phase 0B demonstrated the head-cursor alternative in a disposable spike; this is that concept as production code. backend/app/head.py is the whole of it. Three questions that used to be one — where the story is being read, how far it is retained, and where it opens — are now three functions, and every caller that moves the head or asks about it goes through this module. The spike put the fork check in the write path and left Retry and Add-take on the old one; sharing the rules is what stops that divergence coming back. lineage.Path now caps every entry at the head, so hiding the retained future costs nothing at the call sites: the transcript, the context builder, attempts.preceding and memory retrieval already funnelled through path_of and narrow together. Path.uncapped() is the deliberate exception, and only Redo and the fork check may use it. The memory bank needs no pruning for the same reason — a memory carries the coordinate of the node its block ends on, so one derived past the head falls outside the capped clause and becomes retrievable again on Redo without having been deleted and re-embedded. Undo alone does not fork. Moving the head is not a decision to abandon anything, since the user may be reading or about to Redo; the first write below the head is where the story states which continuation it means. A head already at the tip forks nothing, so a story that is never undone forks exactly as often as it did before and the branch table does not fill up with one branch per turn. Redo follows the lineage rather than choosing among branches, which is what invalidates it after a divergence with no flag to set or clear. Migrations 78 and 79 give a branch superseded_at and superseded_depth. Nothing reads them to decide behaviour — Redo is decided by the lineage, so a stale or hand-edited value here cannot make the story wrong. They exist so the cleanup and discarded-history features left to a later version have something to select on, and so a divergence is observable in a test. Deleting an action no longer drags a moved-back head forward to the recomputed tip, which would have silently redone the story. can_undo and can_redo ride on AdventureOut and ActionPage because the client can work out neither for itself: the campaign opening may be off the top of the loaded window, and the retained future is never sent to it. This is a checkpoint, not the finished milestone. 601 backend tests pass. Five still assert the destructive contract — they count rows after an undo and expect the story to be shorter — and need rewriting against the new one; the world-state assertions inside them already pass. Export and import do not yet carry the head coordinate, so a bundle still reopens at the deepest node and can silently redo an undone story, which is the Phase 0B finding this milestone exists to close. The browser has no Redo control yet. None of the M3 acceptance coverage (D01-D10, E01-E04, I01-I03, I07, L01-L02) is written. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01QF5TcoB86QADgjHz1GZe8u
114 lines
4.7 KiB
Python
114 lines
4.7 KiB
Python
"""Reading, editing, and deleting individual actions.
|
|
|
|
`list_actions` pages through the current branch. The edit and delete endpoints
|
|
change one node, and deleting one removes the whole attempt group at its
|
|
coordinate through `nodes.delete_turn`.
|
|
"""
|
|
|
|
from fastapi import Depends, HTTPException
|
|
from sqlalchemy.orm import Session
|
|
|
|
from ... import attempts, models, schemas, tree
|
|
from ...database import get_db
|
|
|
|
from . import turns
|
|
from .deps import CurrentUser, current_adventure, router
|
|
from .nodes import db_tip, delete_turn
|
|
from .paging import ACTION_PAGE, action_window, annotate_takes
|
|
|
|
|
|
@router.get("/{adventure_id}/actions", response_model=schemas.ActionPage)
|
|
def list_actions(
|
|
before_id: int | None = None,
|
|
limit: int = ACTION_PAGE,
|
|
db: Session = Depends(get_db),
|
|
adventure: models.Adventure = Depends(current_adventure),
|
|
):
|
|
"""Returns a page of the story, working backwards from the newest action.
|
|
|
|
`before_id` is the oldest action the caller already holds, so scrolling up
|
|
asks for what comes before it. Omit `before_id` for the newest window. See
|
|
`action_window` for why this anchors on a row rather than an offset.
|
|
"""
|
|
limit = max(1, min(limit, ACTION_PAGE * 4))
|
|
actions, total, has_more = action_window(
|
|
db, adventure, before_id=before_id, limit=limit
|
|
)
|
|
return schemas.ActionPage(
|
|
actions=[
|
|
schemas.ActionOut.model_validate(a)
|
|
for a in annotate_takes(db, adventure.id, actions)
|
|
],
|
|
total=total,
|
|
has_more=has_more,
|
|
)
|
|
|
|
|
|
@router.patch("/{adventure_id}/actions/{action_id}", response_model=schemas.ActionOut)
|
|
def update_action(
|
|
adventure_id: int,
|
|
action_id: int,
|
|
payload: schemas.ActionUpdate,
|
|
db: Session = Depends(get_db),
|
|
adventure: models.Adventure = Depends(current_adventure),
|
|
):
|
|
action = db.get(models.Action, action_id)
|
|
if action is None or action.adventure_id != adventure_id:
|
|
raise HTTPException(404, "Action not found")
|
|
# One row holds one text. Nothing mirrors it now, so nothing else has to be
|
|
# updated. The edit used to have to be written into the live variant entry
|
|
# as well, or paging away and back reverted it.
|
|
action.text = payload.text
|
|
db.commit()
|
|
return action
|
|
|
|
|
|
@router.delete("/{adventure_id}/actions/{action_id}", status_code=204)
|
|
def delete_action(
|
|
adventure_id: int,
|
|
action_id: int,
|
|
db: Session = Depends(get_db),
|
|
adventure: models.Adventure = Depends(current_adventure),
|
|
):
|
|
action = db.get(models.Action, action_id)
|
|
if action is None or action.adventure_id != adventure_id:
|
|
raise HTTPException(404, "Action not found")
|
|
# The lock is held for the same reason undo holds it: this endpoint puts
|
|
# the shared state back, and a turn that is still generating is about to
|
|
# write it.
|
|
turns.acquire_turn_lock(adventure_id)
|
|
try:
|
|
# This works like undo. The turn is deleted with all of its attempts,
|
|
# and whatever it produced is withdrawn. The marks are depths, and a
|
|
# depth does not move when an action before it is deleted.
|
|
was_at = adventure.head_depth
|
|
delete_turn(db, adventure, action)
|
|
db.flush()
|
|
db.expire(adventure, ["actions"])
|
|
# Deleting the newest action moves the tip. Deleting an action in the
|
|
# middle leaves a gap in the depths, which is intended. See
|
|
# `_backfill_tree`.
|
|
tree.refresh_head(db, adventure)
|
|
# `refresh_head` recomputes the tip, which since M3 is not the head. A
|
|
# story sitting behind its retained tip must not be dragged forward to
|
|
# the tip by an unrelated delete — that would silently Redo it. Keep the
|
|
# head where the reader left it, unless the delete took the ground out
|
|
# from under it, in which case the new tip is as far as it can stay.
|
|
if was_at < adventure.head_depth:
|
|
adventure.head_depth = was_at
|
|
# The script state and the world state belong to the adventure, not to
|
|
# the node, so deleting the node does not take back what it did to
|
|
# them. Put them back to what the story now ends with, which is the
|
|
# same restore a branch switch does.
|
|
#
|
|
# The world state carries the cooldown clock in `_meta.last_changed`,
|
|
# and that clock is a depth. Leaving it set marked the deleted turn's
|
|
# changes as having happened at the depth the next turn is played at,
|
|
# so the referee refused them as changed too recently — on a turn the
|
|
# story no longer contains. Deleting a middle action restores the tip's
|
|
# own outcome, which is the state the adventure is already in.
|
|
attempts.restore_state(adventure, db_tip(db, adventure))
|
|
db.commit()
|
|
finally:
|
|
turns._active_turns.discard(adventure_id)
|