feat: decide_ending three-way gate replaces should_end

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

app.py

@@ -6,7 +6,7 @@ import gradio as gr
 from character import build_system_prompt, OPENING_LINE
 from engine import run_turn
 from finale import finale_steps
-from memory import apply_update, get_tier, should_end, should_recall
+from memory import apply_update, get_tier, decide_ending, should_recall
 from render import render_entity, render_treasure
 
 
@@ -124,7 +124,7 @@ def chat(user_msg: str, state: dict, history: list):
         )
         return
 
-    if should_end(state):
+    if decide_ending(state):
         state["ended"] = True
         yield from _play_finale(state, history)
         return

memory.py

@@ -60,12 +60,21 @@ def should_recall(state: dict) -> tuple[bool, str | None]:
     return False, None
 
 
-def should_end(state: dict) -> bool:
-    """The Visitor Loop fires once: high bond, enough stolen memories.
-
-    Checked at turn start, before the model runs. The finale turn is fully
-    scripted — no model call, no GPU.
+def decide_ending(state: dict) -> str | None:
+    """Which finale fires this turn, if any. Checked at turn start, before the
+    model runs — the finale turn is fully scripted, no model call, no GPU.
+
+    bad: sustained cruelty (tone accumulator), a minimum game length, and at
+         least 2 captured wounds (the finale recites them; if extraction
+         missed the quotes, the game simply continues).
+    good/neutral: the original Visitor Loop gate, branched by tone — warm
+         play earns the Loop; ambivalent play earns the fog.
     """
     if state.get("ended"):
-        return False
-    return state["affinity"] >= 90 and len(state["claimed"]) >= 3
+        return None
+    tone = state.get("tone", 0)
+    if tone <= -40 and state["turn"] >= 6 and len(state.get("wounds", [])) >= 2:
+        return "bad"
+    if state["affinity"] >= 90 and len(state["claimed"]) >= 3:
+        return "good" if tone >= 15 else "neutral"
+    return None

tests/test_memory.py

@@ -1,5 +1,5 @@
 import pytest
-from memory import get_tier, apply_update, should_recall, should_end
+from memory import get_tier, apply_update, should_recall, decide_ending
 
 
 class TestGetTier:
@@ -172,41 +172,75 @@ class TestShouldRecall:
         assert mem is None
 
 
-def _end_state(affinity=90, claimed_count=3, ended=False):
-    claimed = [f"memory {i}" for i in range(claimed_count)]
+def _end_state(affinity=90, claimed_count=3, ended=False, tone=30, turn=12, wounds=None):
     return {
         "affinity": affinity,
-        "treasure": claimed + ["unclaimed extra"],
-        "claimed": claimed,
-        "history": [],
-        "turn": 20,
-        "last_recall_turn": 17,
+        "treasure": [f"memory {i}" for i in range(claimed_count)],
+        "claimed": [f"memory {i}" for i in range(claimed_count)],
+        "turn": turn,
         "ended": ended,
+        "tone": tone,
+        "wounds": wounds if wounds is not None else [],
     }
 
 
-class TestShouldEnd:
-    def test_fires_at_90_with_3_claimed(self):
-        assert should_end(_end_state(affinity=90, claimed_count=3)) is True
+class TestDecideEnding:
+    # --- good ---
+    def test_good_at_90_with_3_claimed_and_warm_tone(self):
+        assert decide_ending(_end_state(tone=30)) == "good"
 
-    def test_does_not_fire_below_90(self):
-        assert should_end(_end_state(affinity=89, claimed_count=5)) is False
+    def test_good_exactly_at_tone_15(self):
+        assert decide_ending(_end_state(tone=15)) == "good"
 
-    def test_does_not_fire_with_fewer_than_3_claimed(self):
-        assert should_end(_end_state(affinity=95, claimed_count=2)) is False
+    # --- neutral ---
+    def test_neutral_when_gate_met_but_tone_mixed(self):
+        assert decide_ending(_end_state(tone=5)) == "neutral"
 
-    def test_does_not_fire_twice(self):
-        assert should_end(_end_state(ended=True)) is False
+    def test_neutral_when_tone_mildly_negative(self):
+        assert decide_ending(_end_state(tone=-10)) == "neutral"
 
-    def test_backward_compat_state_without_ended_key(self):
-        state = _end_state()
-        del state["ended"]
-        assert should_end(state) is True
+    # --- bad ---
+    def test_bad_on_sustained_cruelty(self):
+        s = _end_state(affinity=12, claimed_count=0, tone=-45, turn=8,
+                       wounds=["w1", "w2"])
+        assert decide_ending(s) == "bad"
+
+    def test_bad_needs_minimum_turns(self):
+        s = _end_state(affinity=12, claimed_count=0, tone=-60, turn=5,
+                       wounds=["w1", "w2"])
+        assert decide_ending(s) is None
+
+    def test_bad_needs_two_wounds(self):
+        s = _end_state(affinity=12, claimed_count=0, tone=-60, turn=8,
+                       wounds=["w1"])
+        assert decide_ending(s) is None
+
+    def test_bad_wins_over_good_gate(self):
+        # pathological but defined: cruelty fires first
+        s = _end_state(affinity=95, claimed_count=3, tone=-50, turn=10,
+                       wounds=["w1", "w2"])
+        assert decide_ending(s) == "bad"
+
+    # --- none ---
+    def test_none_below_90(self):
+        assert decide_ending(_end_state(affinity=89, claimed_count=5)) is None
+
+    def test_none_with_fewer_than_3_claimed(self):
+        assert decide_ending(_end_state(affinity=95, claimed_count=2)) is None
+
+    def test_none_when_already_ended(self):
+        assert decide_ending(_end_state(ended=True)) is None
+
+    def test_old_state_without_tone_key_is_neutral(self):
+        s = _end_state()
+        del s["tone"]
+        del s["wounds"]
+        assert decide_ending(s) == "neutral"
 
     def test_fresh_session_does_not_fire(self):
-        state = {"affinity": 20, "treasure": [], "claimed": [],
-                 "history": [], "turn": 0, "last_recall_turn": None}
-        assert should_end(state) is False
+        s = {"affinity": 20, "treasure": [], "claimed": [], "turn": 0,
+             "ended": False, "tone": 0, "wounds": []}
+        assert decide_ending(s) is None
 
 
 class TestApplyUpdateTone: