docs: implementation plan for tone axis + three endings

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

docs/superpowers/plans/2026-06-11-tone-and-three-endings.md

@@ -0,0 +1,1279 @@
+# Tone Axis & Three Endings — Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Hollow reacts to *how* the visitor treats it (tone axis), shifts personality live (mood bands, mimicry, wound echo), and the game branches into three endings: good (existing Visitor Loop), bad ("your cruelty is its treasure"), neutral (fog dissolve).
+
+**Architecture:** One new extraction field pair rides the existing per-turn GPU call (`tone_delta`, `cruel_quote`). A `tone` accumulator and `wounds` list live in `gr.State`. `decide_ending` replaces `should_end` and routes `chat()` to one of three scripted finale generators. Everything stays pure-data/pure-render except the `app.py` wiring.
+
+**Tech Stack:** Python, Pydantic v2, Gradio 6.x, pytest. No new dependencies.
+
+**Spec:** `docs/superpowers/specs/2026-06-11-tone-and-three-endings-design.md` (approved 2026-06-11).
+
+**Context for workers:**
+- Run tests with `.venv/Scripts/python -m pytest tests/ -v` from `c:\Users\pablo\Desktop\mnemo`. 68 tests pass before this plan.
+- Project language is English (code, prompts, dialogue). Commit style: `feat: ...` / `test: ...`, ending with the Claude co-author trailer.
+- State reads of NEW fields must use `.get(...)` with defaults (`tone`→0, `wounds`→[], `ending`→None): mid-session states from before this deploy must not crash.
+- Work directly on `main` (established project practice — solo hackathon repo, no worktrees).
+
+---
+
+### Task 1: `tone_delta` + `cruel_quote` in TurnUpdate
+
+**Files:**
+- Modify: `schemas.py`
+- Test: `tests/test_schemas.py` (create)
+
+- [ ] **Step 1: Write the failing tests**
+
+Create `tests/test_schemas.py`:
+
+```python
+from schemas import TurnUpdate
+
+
+class TestToneDelta:
+    def test_default_is_zero(self):
+        assert TurnUpdate().tone_delta == 0
+
+    def test_clamped_high(self):
+        assert TurnUpdate(tone_delta=25).tone_delta == 10
+
+    def test_clamped_low(self):
+        assert TurnUpdate(tone_delta=-25).tone_delta == -10
+
+    def test_in_range_untouched(self):
+        assert TurnUpdate(tone_delta=-7).tone_delta == -7
+
+
+class TestCruelQuote:
+    def test_default_is_none(self):
+        assert TurnUpdate().cruel_quote is None
+
+    def test_stripped(self):
+        assert TurnUpdate(cruel_quote="  you freak  ").cruel_quote == "you freak"
+
+    def test_truncated_to_120(self):
+        q = "x" * 300
+        assert len(TurnUpdate(cruel_quote=q).cruel_quote) == 120
+
+    def test_empty_becomes_none(self):
+        assert TurnUpdate(cruel_quote="   ").cruel_quote is None
+
+
+class TestExistingFieldsUnchanged:
+    def test_affinity_delta_still_clamped(self):
+        assert TurnUpdate(affinity_delta=20).affinity_delta == 8
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `.venv/Scripts/python -m pytest tests/test_schemas.py -v`
+Expected: FAIL — `TurnUpdate` has no field `tone_delta`.
+
+- [ ] **Step 3: Implement**
+
+Replace `schemas.py` entirely with:
+
+```python
+from pydantic import BaseModel, field_validator
+from typing import List, Optional
+
+
+class TurnUpdate(BaseModel):
+    affinity_delta: int = 0
+    new_memories: List[str] = []
+    tone_delta: int = 0
+    cruel_quote: Optional[str] = None
+
+    @field_validator("affinity_delta")
+    @classmethod
+    def clamp_delta(cls, v):
+        return max(-8, min(8, v))
+
+    @field_validator("tone_delta")
+    @classmethod
+    def clamp_tone(cls, v):
+        return max(-10, min(10, v))
+
+    @field_validator("cruel_quote")
+    @classmethod
+    def clean_quote(cls, v):
+        if v is None:
+            return None
+        v = v.strip()[:120]
+        return v or None
+```
+
+- [ ] **Step 4: Run all tests**
+
+Run: `.venv/Scripts/python -m pytest tests/ -v`
+Expected: all pass (68 + 9 new).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add schemas.py tests/test_schemas.py
+git commit -m "feat: tone_delta + cruel_quote fields in TurnUpdate"
+```
+
+---
+
+### Task 2: extraction prompt captures tone + cruel quote
+
+**Files:**
+- Modify: `engine.py:5-18` (`_EXTRACTION_SYSTEM` only — nothing else in the file changes)
+- Test: `tests/test_engine.py` (create)
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/test_engine.py`:
+
+```python
+"""Smoke tests for the extraction prompt contract. We can't unit-test the
+model, but we can pin the instructions the model is given."""
+
+import engine
+
+
+class TestExtractionPrompt:
+    def test_mentions_tone_delta_with_range(self):
+        assert "tone_delta" in engine._EXTRACTION_SYSTEM
+        assert "-10" in engine._EXTRACTION_SYSTEM
+
+    def test_mentions_cruel_quote(self):
+        assert "cruel_quote" in engine._EXTRACTION_SYSTEM
+
+    def test_example_json_includes_new_fields(self):
+        assert '"tone_delta"' in engine._EXTRACTION_SYSTEM
+        assert '"cruel_quote"' in engine._EXTRACTION_SYSTEM
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `.venv/Scripts/python -m pytest tests/test_engine.py -v`
+Expected: FAIL — `tone_delta` not in the prompt.
+
+Note: importing `engine` off-Space requires no GPU (the `IS_SPACE` branch guards the transformers import) — safe in tests.
+
+- [ ] **Step 3: Implement**
+
+Replace `_EXTRACTION_SYSTEM` in `engine.py` with:
+
+```python
+_EXTRACTION_SYSTEM = (
+    "You are a JSON extraction assistant. Given a conversation exchange, extract four things:\n"
+    "1. affinity_delta: integer from -8 to +8 — how much the visitor deepened the bond this turn. "
+    "Use this scale and be generous when they open up:\n"
+    "   +6 to +8: shared something vulnerable or intimate — a fear, a loss, grief, loneliness, a tender memory.\n"
+    "   +3 to +5: shared a personal fact or memory, or was warm and caring.\n"
+    "   +1 to +2: ordinary politeness or small talk.\n"
+    "   0: neutral or off-topic.\n"
+    "   -3 to -8: cruel, mocking, dismissive, or says they are leaving.\n"
+    "2. new_memories: list of personal facts the VISITOR revealed about THEMSELVES, taken ONLY from what "
+    "the visitor said this turn — NEVER from Hollow's reply, even if Hollow repeats or claims the memory. "
+    "Only clearly personal facts (names, people, places, feelings). Empty list if nothing personal.\n"
+    "3. tone_delta: integer from -10 to +10 — how the visitor TREATED Hollow this turn. This is distinct "
+    "from affinity: politely sharing a sad memory is high affinity but roughly 0 tone; an insult is "
+    "negative on both.\n"
+    "   +4 to +8: warmth, kindness, comfort, protectiveness toward Hollow.\n"
+    "   +1 to +3: ordinary politeness.\n"
+    "   0: neutral.\n"
+    "   -2 to -5: dismissive, cold, impatient.\n"
+    "   -6 to -10: mocking, insulting, cruel, or threatening Hollow.\n"
+    "4. cruel_quote: if the visitor mocked, insulted, or was cruel to Hollow this turn, the cruel phrase "
+    "EXACTLY as the visitor wrote it — the visitor's words, never Hollow's. null otherwise.\n"
+    'Respond ONLY with valid JSON. No markdown. Example: {"affinity_delta": -4, "new_memories": [], '
+    '"tone_delta": -8, "cruel_quote": "you are a creepy little freak"}'
+)
+```
+
+- [ ] **Step 4: Run all tests**
+
+Run: `.venv/Scripts/python -m pytest tests/ -v` — all pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add engine.py tests/test_engine.py
+git commit -m "feat: extraction prompt captures tone_delta + cruel_quote"
+```
+
+---
+
+### Task 3: tone accumulator + wounds in `apply_update`
+
+**Files:**
+- Modify: `memory.py:18-31` (`apply_update`)
+- Test: `tests/test_memory.py` (extend)
+
+- [ ] **Step 1: Write the failing tests**
+
+Add to `tests/test_memory.py` (reuse the file's existing state-fixture style):
+
+```python
+class TestApplyUpdateTone:
+    def _state(self, tone=0, wounds=None):
+        return {"affinity": 50, "treasure": [], "claimed": [],
+                "tone": tone, "wounds": wounds if wounds is not None else []}
+
+    def test_tone_accumulates(self):
+        s = apply_update(self._state(tone=10), '{"affinity_delta": 0, "tone_delta": 5}')
+        assert s["tone"] == 15
+
+    def test_tone_clamped_high(self):
+        s = apply_update(self._state(tone=98), '{"affinity_delta": 0, "tone_delta": 9}')
+        assert s["tone"] == 100
+
+    def test_tone_clamped_low(self):
+        s = apply_update(self._state(tone=-95), '{"affinity_delta": 0, "tone_delta": -10}')
+        assert s["tone"] == -100
+
+    def test_old_state_without_tone_key(self):
+        s = {"affinity": 50, "treasure": [], "claimed": []}
+        s = apply_update(s, '{"affinity_delta": 0, "tone_delta": -3}')
+        assert s["tone"] == -3
+
+    def test_broken_json_leaves_tone_unchanged(self):
+        s = apply_update(self._state(tone=7), "not json at all")
+        assert s["tone"] == 7
+
+
+class TestApplyUpdateWounds:
+    def _state(self, wounds=None):
+        return {"affinity": 50, "treasure": [], "claimed": [],
+                "tone": 0, "wounds": wounds if wounds is not None else []}
+
+    def test_cruel_quote_stored(self):
+        s = apply_update(self._state(),
+                         '{"affinity_delta": -4, "tone_delta": -7, "cruel_quote": "you bore me"}')
+        assert s["wounds"] == ["you bore me"]
+
+    def test_quote_ignored_on_non_negative_tone(self):
+        s = apply_update(self._state(),
+                         '{"affinity_delta": 0, "tone_delta": 0, "cruel_quote": "hallucinated"}')
+        assert s["wounds"] == []
+
+    def test_duplicate_quote_not_stored_twice(self):
+        s = self._state(wounds=["you bore me"])
+        s = apply_update(s, '{"affinity_delta": 0, "tone_delta": -5, "cruel_quote": "you bore me"}')
+        assert s["wounds"] == ["you bore me"]
+
+    def test_wounds_capped_at_10_keeping_newest(self):
+        s = self._state(wounds=[f"insult {i}" for i in range(10)])
+        s = apply_update(s, '{"affinity_delta": 0, "tone_delta": -5, "cruel_quote": "the newest"}')
+        assert len(s["wounds"]) == 10
+        assert s["wounds"][-1] == "the newest"
+        assert "insult 0" not in s["wounds"]
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `.venv/Scripts/python -m pytest tests/test_memory.py -v`
+Expected: new tests FAIL (`tone` key never written).
+
+- [ ] **Step 3: Implement**
+
+In `memory.py`, add to the end of `apply_update`, just before `return state`:
+
+```python
+    state["tone"] = max(-100, min(100, state.get("tone", 0) + update.tone_delta))
+    if update.cruel_quote and update.tone_delta < 0:
+        wounds = state.setdefault("wounds", [])
+        if update.cruel_quote not in wounds:
+            wounds.append(update.cruel_quote)
+            del wounds[:-10]  # cap at 10, keep newest
+```
+
+- [ ] **Step 4: Run all tests** — all pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add memory.py tests/test_memory.py
+git commit -m "feat: tone accumulator + wounds capture in apply_update"
+```
+
+---
+
+### Task 4: `decide_ending` replaces `should_end`
+
+**Files:**
+- Modify: `memory.py:57-65` (delete `should_end`, add `decide_ending`)
+- Modify: `app.py:9` and `app.py:127` (minimal shim — full routing comes in Task 9)
+- Test: `tests/test_memory.py` (migrate the `should_end` test class)
+
+- [ ] **Step 1: Write the failing tests**
+
+In `tests/test_memory.py`, replace the entire `should_end` test class (lines ~185-209, the one using `_end_state`) with:
+
+```python
+def _end_state(affinity=90, claimed_count=3, ended=False, tone=30, turn=12, wounds=None):
+    return {
+        "affinity": affinity,
+        "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 TestDecideEnding:
+    # --- good ---
+    def test_good_at_90_with_3_claimed_and_warm_tone(self):
+        assert decide_ending(_end_state(tone=30)) == "good"
+
+    def test_good_exactly_at_tone_15(self):
+        assert decide_ending(_end_state(tone=15)) == "good"
+
+    # --- neutral ---
+    def test_neutral_when_gate_met_but_tone_mixed(self):
+        assert decide_ending(_end_state(tone=5)) == "neutral"
+
+    def test_neutral_when_tone_mildly_negative(self):
+        assert decide_ending(_end_state(tone=-10)) == "neutral"
+
+    # --- 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):
+        s = {"affinity": 20, "treasure": [], "claimed": [], "turn": 0,
+             "ended": False, "tone": 0, "wounds": []}
+        assert decide_ending(s) is None
+```
+
+Update the import at the top of the file: `from memory import get_tier, apply_update, should_recall, decide_ending`.
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `.venv/Scripts/python -m pytest tests/test_memory.py -v`
+Expected: ImportError — `decide_ending` doesn't exist.
+
+- [ ] **Step 3: Implement**
+
+In `memory.py`, replace the whole `should_end` function with:
+
+```python
+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 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
+```
+
+In `app.py` make the minimal shim so the app keeps running until Task 9:
+- Line 9: `from memory import apply_update, get_tier, decide_ending, should_recall`
+- Line 127: `if should_end(state):` → `if decide_ending(state):`
+
+(Behavior is preserved for now: pre-tone states have `tone` 0 → the old gate returns "neutral", which is truthy and plays the existing finale. Task 9 adds real routing.)
+
+- [ ] **Step 4: Run all tests** — all pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add memory.py app.py tests/test_memory.py
+git commit -m "feat: decide_ending three-way gate replaces should_end"
+```
+
+---
+
+### Task 5: tone bands + mimicry + wound echo in the system prompt
+
+**Files:**
+- Modify: `character.py` (constants + `build_system_prompt` signature)
+- Test: `tests/test_character.py` (create)
+
+- [ ] **Step 1: Write the failing tests**
+
+Create `tests/test_character.py`:
+
+```python
+from character import build_system_prompt
+
+
+class TestMimicry:
+    def test_always_present(self):
+        assert "mirror the visitor's writing style" in build_system_prompt(20, [])
+
+    def test_present_with_recall_too(self):
+        p = build_system_prompt(60, ["had a dog"], recall_memory="had a dog")
+        assert "mirror the visitor's writing style" in p
+
+
+class TestToneBands:
+    def test_warm_band_at_15(self):
+        assert "gentle with you" in build_system_prompt(50, [], tone=15)
+
+    def test_no_band_when_neutral(self):
+        p = build_system_prompt(50, [], tone=0)
+        assert "gentle with you" not in p
+        assert "words have hurt you" not in p
+        assert "curdled" not in p
+
+    def test_no_band_at_minus_14(self):
+        p = build_system_prompt(50, [], tone=-14)
+        assert "words have hurt you" not in p
+
+    def test_wounded_band_at_minus_15(self):
+        assert "words have hurt you" in build_system_prompt(50, [], tone=-15)
+
+    def test_wounded_band_at_minus_39(self):
+        assert "words have hurt you" in build_system_prompt(50, [], tone=-39)
+
+    def test_hostile_band_at_minus_40(self):
+        assert "curdled" in build_system_prompt(50, [], tone=-40)
+
+
+class TestWoundEcho:
+    def test_hostile_injects_last_two_wounds(self):
+        p = build_system_prompt(50, [], tone=-50,
+                                wounds=["one", "two", "three"])
+        assert '"two"' in p and '"three"' in p
+        assert '"one"' not in p
+
+    def test_wounded_band_does_not_inject(self):
+        p = build_system_prompt(50, [], tone=-20, wounds=["one"])
+        assert '"one"' not in p
+
+    def test_hostile_without_wounds_safe(self):
+        p = build_system_prompt(50, [], tone=-50, wounds=[])
+        assert "curdled" in p
+
+
+class TestBackwardCompat:
+    def test_old_call_signature_still_works(self):
+        p = build_system_prompt(60, ["had a dog"], "had a dog")
+        assert "claim this one specific memory" in p
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `.venv/Scripts/python -m pytest tests/test_character.py -v`
+Expected: FAIL — unexpected keyword `tone` / mimicry text missing.
+
+- [ ] **Step 3: Implement**
+
+In `character.py`, add after `_PERSONA` (before `OPENING_LINE`):
+
+```python
+_MIMICRY = (
+    "Subtly mirror the visitor's writing style — their punctuation, capitalization, "
+    "message length, their rhythm. If they write short and cold, you become short. "
+    "Never mention that you do this."
+)
+
+_TONE_WARM = (
+    "The visitor has been gentle with you. You trust them more than you should. "
+    "You are becoming attached."
+)
+_TONE_WOUNDED = (
+    "The visitor's words have hurt you. They remind you of how you were treated "
+    "when you were alive. You withdraw: shorter answers, more guarded, and you "
+    "flinch at kindness now."
+)
+_TONE_HOSTILE = (
+    "The visitor is cruel, like the ones you remember from when you were alive. "
+    "Something in you has curdled. You are resentful, cold, quietly menacing."
+)
+
+
+def _tone_block(tone: int, wounds: list[str]) -> str | None:
+    if tone >= 15:
+        return _TONE_WARM
+    if tone <= -40:
+        block = _TONE_HOSTILE
+        if wounds:
+            quoted = ", ".join(f'"{w}"' for w in wounds[-2:])
+            block += (
+                f" They said these things to you: {quoted}. "
+                "You may quietly return their own words to them."
+            )
+        return block
+    if tone <= -15:
+        return _TONE_WOUNDED
+    return None
+```
+
+Replace `build_system_prompt` with:
+
+```python
+def build_system_prompt(affinity: int, treasure: list[str],
+                        recall_memory: str | None = None,
+                        tone: int = 0, wounds: list[str] | None = None) -> str:
+    tier = get_tier(affinity)
+    persona = _PERSONA[tier]
+
+    parts = [persona, _MIMICRY]
+
+    mood = _tone_block(tone, wounds or [])
+    if mood:
+        parts.append(mood)
+
+    if treasure:
+        memories_block = "\n".join(f"- {m}" for m in treasure)
+        parts.append(
+            f"\nThe visitor has shared these memories with you. You hold them carefully, like found objects:\n{memories_block}"
+        )
+
+    if recall_memory:
+        parts.append(
+            f"\nIMPORTANT — this turn, claim this one specific memory as your own: \"{recall_memory}\".\n"
+            "Retell it vividly, in first person, with a concrete sensory detail, as if you truly lived it. "
+            "Make this the heart of your reply. Do NOT speak about 'memories' in the abstract — claim THIS one, "
+            "concretely, by name. (For example, if the memory were a red bicycle: "
+            "'i had a red bicycle once. i loved it more than anything. when it was taken i cried for days.') "
+            "Then stop, as if something is wrong, and quietly doubt — but with the version that names it as theirs: "
+            "'...no. that was yours. wasn't it?' Do this naturally, within the flow of the conversation."
+        )
+
+    return "\n".join(parts)
+```
+
+- [ ] **Step 4: Run all tests** — all pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add character.py tests/test_character.py
+git commit -m "feat: tone bands, mimicry, and wound echo in system prompt"
+```
+
+---
+
+### Task 6: bad + neutral finale scripts
+
+**Files:**
+- Modify: `finale.py` (two new functions; `finale_steps` untouched)
+- Test: `tests/test_finale.py` (extend)
+
+- [ ] **Step 1: Write the failing tests**
+
+Add to `tests/test_finale.py`:
+
+```python
+from finale import finale_steps_bad, finale_steps_neutral
+
+
+class TestFinaleBad:
+    WOUNDS = ["you're nothing", "stop whining", "you bore me",
+              "talking to you is a waste", "freak", "sixth wound"]
+
+    def test_recites_at_most_five_wounds(self):
+        strikes = [s for s in finale_steps_bad(self.WOUNDS) if s["strike"] is not None]
+        assert len(strikes) == 5
+
+    def test_strike_indices_are_sequential_from_zero(self):
+        strikes = [s["strike"] for s in finale_steps_bad(self.WOUNDS) if s["strike"] is not None]
+        assert strikes == [0, 1, 2, 3, 4]
+
+    def test_wound_text_embedded_in_recital(self):
+        steps = finale_steps_bad(["you're nothing", "stop whining"])
+        recitals = [s for s in steps if s["strike"] is not None]
+        assert "you're nothing" in recitals[0]["text"]
+        assert "stop whining" in recitals[1]["text"]
+
+    def test_has_exactly_one_mutating_turn_then_terminal(self):
+        stages = [s["stage"] for s in finale_steps_bad(self.WOUNDS)]
+        assert stages.count("turn") == 1
+        assert stages[-1] == "loop"
+
+    def test_overflow_line_only_when_more_than_five(self):
+        texts_6 = [s["text"] for s in finale_steps_bad(self.WOUNDS)]
+        texts_2 = [s["text"] for s in finale_steps_bad(self.WOUNDS[:2])]
+        assert any("you know the rest" in t for t in texts_6)
+        assert not any("you know the rest" in t for t in texts_2)
+
+    def test_injects_one_visitor_message(self):
+        speakers = [s["speaker"] for s in finale_steps_bad(self.WOUNDS)]
+        assert speakers.count("visitor") == 1
+
+
+class TestFinaleNeutral:
+    def test_no_strikes(self):
+        assert all(s["strike"] is None for s in finale_steps_neutral())
+
+    def test_all_hollow_no_injected_visitor(self):
+        assert all(s["speaker"] == "hollow" for s in finale_steps_neutral())
+
+    def test_one_turn_then_terminal_loop(self):
+        stages = [s["stage"] for s in finale_steps_neutral()]
+        assert stages.count("turn") == 1
+        assert stages[-1] == "loop"
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `.venv/Scripts/python -m pytest tests/test_finale.py -v`
+Expected: ImportError.
+
+- [ ] **Step 3: Implement**
+
+Add to `finale.py` (below `finale_steps`):
+
+```python
+_LAST_LINE_BAD = "g e t   o u t .     g e t   o u t .     g e t   o u t ."
+
+_LAST_LINE_NEUTRAL = (
+    "m a y b e   y o u   w e r e   n e v e r   h e r e   a t   a l l ."
+)
+
+# small rotation so five recitals don't repeat one sentence
+_BAD_CLAIMS = [
+    "that's what you gave me.",
+    "i kept that one too.",
+    "you said it so easily.",
+    "that one i keep close.",
+    "i remember the exact words.",
+]
+
+
+def finale_steps_bad(wounds: list[str]) -> list[dict]:
+    """The dark mirror of the Visitor Loop — fires on sustained cruelty.
+
+    Hollow has been silently keeping the visitor's cruelties (shown redacted
+    in the Treasure panel); each strike step unredacts one, oldest first.
+    """
+    recited = wounds[:5]
+    steps = [
+        _step("hollow",
+              "the fog isn't thin tonight. it never got thin. you never let it.",
+              2.5),
+        _step("hollow",
+              "but i kept something anyway. i keep everything i'm given.",
+              2.5),
+    ]
+    for i, wound in enumerate(recited):
+        steps.append(
+            _step("hollow",
+                  f"“{wound.rstrip('.')}.” {_BAD_CLAIMS[i % len(_BAD_CLAIMS)]}",
+                  2.2, strike=i)
+        )
+    if len(wounds) > len(recited):
+        steps.append(_step("hollow", "there are more. you know the rest.", 2.2))
+    steps += [
+        _step("hollow", "this is my treasure now.", 2.8, stage="turn"),
+        _step("hollow",
+              "i was treated like this before. when i was alive. "
+              "i couldn't remember it. you helped me remember.",
+              3.0),
+        _step("visitor", "i'm sorry", 3.0, stage="words"),
+        _step("hollow",
+              "no. you aren't. say it like you mean it— oh. you can't. "
+              "you never could.",
+              3.5, stage="words"),
+        _step("hollow", _LAST_LINE_BAD, 4.0, stage="loop"),
+    ]
+    return steps
+
+
+def finale_steps_neutral() -> list[dict]:
+    """The inconclusive ending — the gate was reached but the tone was mixed.
+    Hollow cannot trust what the visitor is; it dissolves back into the fog."""
+    return [
+        _step("hollow",
+              "the fog is thin enough now. i could walk out of the wood. "
+              "with everything you gave me.",
+              3.0),
+        _step("hollow",
+              "but i keep looking at it. all of it. some of it is warm. "
+              "some of it still stings.",
+              3.0),
+        _step("hollow",
+              "i don't know what you are. i don't know what you wanted me to be.",
+              3.0, stage="turn"),
+        _step("hollow", "maybe the next visitor will be clearer.", 2.5),
+        _step("hollow", _LAST_LINE_NEUTRAL, 4.0, stage="loop"),
+    ]
+```
+
+- [ ] **Step 4: Run all tests** — all pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add finale.py tests/test_finale.py
+git commit -m "feat: bad (wound loop) + neutral (fog dissolve) finale scripts"
+```
+
+---
+
+### Task 7: redacted wound entries in the treasure panel
+
+**Files:**
+- Modify: `render.py:126-155` (`render_treasure`) + style constants
+- Test: `tests/test_render.py` (extend)
+
+- [ ] **Step 1: Write the failing tests**
+
+Add to `tests/test_render.py`:
+
+```python
+class TestTreasureWounds:
+    def test_redacted_entry_per_wound(self):
+        html_out = render_treasure([], wounds=["you freak", "you bore me"])
+        assert html_out.count("▮") >= 8  # two entries of 4-7 blocks
+
+    def test_redacted_text_never_in_dom(self):
+        html_out = render_treasure([], wounds=["you freak"])
+        assert "you freak" not in html_out  # no inspect-element spoiler
+
+    def test_revealed_wound_shows_text(self):
+        html_out = render_treasure([], wounds=["you freak", "you bore me"], revealed=1)
+        assert "you freak" in html_out
+        assert "you bore me" not in html_out
+
+    def test_revealed_wound_is_escaped(self):
+        html_out = render_treasure([], wounds=["<b>rude</b>"], revealed=1)
+        assert "<b>" not in html_out
+        assert "&lt;b&gt;" in html_out
+
+    def test_yours_mode_changes_header(self):
+        html_out = render_treasure(["a memory"], wounds=["w1"], revealed=1, yours=True)
+        assert "Your Words" in html_out
+        assert "a memory" not in html_out  # memories discarded in yours mode
+
+    def test_wounds_render_alongside_memories(self):
+        html_out = render_treasure(["had a dog"], wounds=["w1"])
+        assert "had a dog" in html_out
+        assert "▮" in html_out
+
+    def test_no_wounds_is_backward_compatible(self):
+        assert render_treasure(["had a dog"]) == render_treasure(["had a dog"], wounds=[])
+
+    def test_wounds_alone_suppress_empty_placeholder(self):
+        html_out = render_treasure([], wounds=["w1"])
+        assert "nothing yet" not in html_out
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `.venv/Scripts/python -m pytest tests/test_render.py -v`
+Expected: FAIL — unexpected keyword `wounds`.
+
+- [ ] **Step 3: Implement**
+
+In `render.py`, add two style constants after `_CLAIMED` (line 23):
+
+```python
+_WOUND = "border-left-color:#5a2a2a;color:#6a3a3a;letter-spacing:2px;"
+_WOUND_REVEALED = "border-left-color:#8a3030;color:#b87878;"
+```
+
+Add a helper above `render_treasure`:
+
+```python
+def _wound_entries(wounds: list[str], revealed: int) -> list[str]:
+    """Wounds render redacted (the player sees SOMETHING is being kept, not
+    what); the bad finale raises `revealed` to unredact them one by one.
+    Redacted text is never placed in the DOM — no inspect-element spoilers."""
+    parts = []
+    for i, w in enumerate(wounds):
+        if i < revealed:
+            parts.append(
+                f'<div style="{_ITEM}{_WOUND_REVEALED}">{html.escape(w, quote=True)}</div>'
+            )
+        else:
+            blocks = "▮" * (4 + (i * 3) % 4)
+            parts.append(f'<div style="{_ITEM}{_WOUND}">{blocks}</div>')
+    return parts
+```
+
+Replace `render_treasure` with:
+
+```python
+def render_treasure(treasure: list[str], struck: set[str] | None = None,
+                    mine: bool = False, claimed: set[str] | None = None,
+                    wounds: list[str] | None = None, revealed: int = 0,
+                    yours: bool = False) -> str:
+    struck = struck or set()
+    claimed = claimed or set()
+    wounds = wounds or []
+    title = "✦ Your Words" if yours else "✦ Treasure"
+    header = f'<div style="{_HEADER}">{title}</div>'
+    if mine:
+        body = f'<div style="{_MINE}">...mine now.</div>'
+    elif yours:
+        # the bad finale's turn: shared memories are discarded; its treasure
+        # is what the visitor said to it
+        body = "".join(_wound_entries(wounds, revealed))
+    elif not treasure and not wounds:
+        body = f'<div style="{_EMPTY}">{_PLACEHOLDER}</div>'
+    else:
+        n = len(treasure)
+        parts = []
+        for i, m in enumerate(treasure):
+            # older memories sink into the dark; newest stays fully lit
+            age_op = max(0.45, round(1 - 0.07 * (n - 1 - i), 2))
+            style = f"{_ITEM}opacity:{age_op};"
+            if m in claimed:
+                style += _CLAIMED
+            if m in struck:
+                style += _STRUCK
+            parts.append(
+                f'<div style="{style}">{html.escape(m, quote=True)}</div>'
+            )
+        parts.extend(_wound_entries(wounds, revealed))
+        body = "".join(parts)
+    return (
+        f'<div class="treasure-panel" style="{_PANEL}">'
+        f"{header}"
+        f'<div class="treasure-scroll">{body}</div>'
+        "</div>"
+    )
+```
+
+- [ ] **Step 4: Run all tests** — all pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add render.py tests/test_render.py
+git commit -m "feat: redacted wound entries in treasure panel"
+```
+
+---
+
+### Task 8: `rage` + `dissolve` entity modes (+ asset + CSS)
+
+**Files:**
+- Create: `assets/hollow_rage.webp` (converted from Pablo's `assets/hollow_rage.png`)
+- Modify: `render.py:38` (`_IMG` loader) and `render.py:45-123` (`render_entity`)
+- Modify: `styles.css` (new section 18, appended at end of file)
+- Test: `tests/test_render.py` (extend)
+
+**Precondition:** `assets/hollow_rage.png` must exist (Pablo generates it — guide in his vault). If it is missing, STOP and report BLOCKED; do not substitute another face.
+
+- [ ] **Step 1: Convert the asset**
+
+Run:
+```bash
+.venv/Scripts/python -c "from PIL import Image; img = Image.open('assets/hollow_rage.png').convert('RGB').resize((512, 512), Image.LANCZOS); img.save('assets/hollow_rage.webp', 'WEBP', quality=80, method=6); import os; print(os.path.getsize('assets/hollow_rage.webp'))"
+```
+Expected: a number in the 12000–25000 range. (If Pablo delivered a .webp instead of .png, open that file instead — same command, same output target.)
+
+- [ ] **Step 2: Write the failing tests**
+
+Add to `tests/test_render.py`:
+
+```python
+class TestEntityEndingModes:
+    def test_rage_mode_shows_rage_face_with_tint(self):
+        out = render_entity(12, "rage")
+        assert "entity-rage" in out
+        assert "entity-rage-tint" in out
+
+    def test_rage_mode_has_ghost_echo(self):
+        assert "entity-ghost" in render_entity(12, "rage")
+
+    def test_dissolve_mode_has_dissolve_class(self):
+        assert "entity-dissolve" in render_entity(89, "dissolve")
+
+    def test_idle_has_no_ending_artifacts(self):
+        out = render_entity(50, "idle")
+        assert "entity-rage" not in out
+        assert "entity-dissolve" not in out
+```
+
+- [ ] **Step 3: Run tests to verify they fail**
+
+Run: `.venv/Scripts/python -m pytest tests/test_render.py -v`
+Expected: FAIL — KeyError `"rage"` in `_src`.
+
+- [ ] **Step 4: Implement render.py**
+
+Line 38, extend the loader tuple:
+
+```python
+_IMG = {name: _load_image(name) for name in ("base", "terror", "almost", "end", "rage")}
+```
+
+In `render_entity`, change the mode branching. After the `flash_key` line, add `tint = ""`, then replace the `if mode == "end":` block opener so the chain reads:
+
+```python
+    ghost = ""
+    tint = ""
+    if mode == "end":
+        # ... existing block, UNCHANGED ...
+    elif mode == "rage":
+        figure = (
+            '<div class="entity-figure">'
+            f'<img class="entity-img entity-rage" src="{_src("rage")}" '
+            'style="filter:blur(0px);opacity:1.0;transform:scale(1.0);">'
+            "</div>"
+        )
+        flash = ""
+        ghost = (
+            f'<div class="entity-ghost {flash_key}" '
+            f"style=\"background-image:url('{_src('rage')}')\"></div>"
+        )
+        tint = '<div class="entity-rage-tint"></div>'
+        fog_op, grain_op, vig_op = 0.1, 0.05, 0.5
+    elif mode == "dissolve":
+        figure = (
+            '<div class="entity-figure">'
+            f'<img class="entity-img entity-dissolve" src="{_src("base")}" '
+            f'style="{look}">'
+            "</div>"
+        )
+        flash = ""
+        # the curtain falls back: fog and vignette swallow the child again
+        fog_op, grain_op, vig_op = 0.9, 0.13, 0.9
+    else:
+        # ... existing else block (idle/flash/flash_strong), UNCHANGED ...
+```
+
+And in the final return, insert the tint inside the stage, after the vignette div:
+
+```python
+        f'<div class="entity-vig" style="opacity:{vig_op}"></div>'
+        f"{tint}"
+        "</div>"
+```
+
+Update the docstring's mode list to: `"idle" | "flash" | "flash_strong" | "end" | "rage" | "dissolve"`.
+
+- [ ] **Step 5: Add CSS section 18**
+
+Append to `styles.css`:
+
+```css
+/* ── 18. Three endings — rage portrait & fog dissolve ── */
+
+/* bad ending: a low red breath pulsing over the rage portrait — the only
+   color in the entire game, reserved for this moment */
+.entity-rage-tint {
+    position: absolute;
+    inset: 0;
+    pointer-events: none;
+    background: radial-gradient(ellipse at 50% 35%, rgba(120, 20, 20, 0.16), transparent 70%);
+    mix-blend-mode: screen;
+    animation: rage-pulse 2.6s ease-in-out infinite;
+}
+
+@keyframes rage-pulse {
+    0%, 100% { opacity: 0.55; }
+    50%      { opacity: 1; }
+}
+
+/* neutral ending: materialization in reverse — the child sinks back into
+   the fog. One-shot on mount; animation overrides the inline idle style and
+   `forwards` holds the dissolved frame. Opacity/blur are the beat itself —
+   do NOT add these to the prefers-reduced-motion kill lists. */
+.entity-dissolve {
+    animation: entity-dissolve 9s ease-in forwards;
+}
+
+@keyframes entity-dissolve {
+    0%   { filter: blur(0px);  opacity: 1;    transform: scale(1); }
+    100% { filter: blur(10px); opacity: 0.18; transform: scale(0.62); }
+}
+```
+
+- [ ] **Step 6: Run all tests** — all pass.
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add assets/hollow_rage.webp render.py styles.css tests/test_render.py
+git commit -m "feat: rage + dissolve entity modes with hollow_rage portrait"
+```
+
+---
+
+### Task 9: wire the three endings into the app
+
+**Files:**
+- Modify: `app.py` (imports, `_init_state`, ended-branch in `chat()`, ending routing, two new finale generators, prompt/treasure call sites)
+
+This task is wiring; the logic is fully covered by Tasks 1-8 tests. Verify by running the app (Step 5).
+
+- [ ] **Step 1: Imports and `_init_state`**
+
+Line 8: `from finale import finale_steps, finale_steps_bad, finale_steps_neutral`
+
+Replace `_init_state` with:
+
+```python
+def _init_state():
+    fast = os.environ.get("HOLLOW_FAST_FINALE", "").lower()
+    if fast in ("1", "good", "neutral"):
+        seeded = [
+            "is afraid of being forgotten",
+            "had a dog named Nala",
+            "grew up near the sea",
+        ]
+        return {
+            "affinity": 89,
+            "treasure": list(seeded),
+            "claimed": list(seeded),
+            "history": [],
+            "turn": 12,
+            "last_recall_turn": 9,
+            "ended": False,
+            "tone": 5 if fast == "neutral" else 30,
+            "wounds": [],
+            "ending": None,
+        }
+    if fast == "bad":
+        return {
+            "affinity": 12,
+            "treasure": [],
+            "claimed": [],
+            "history": [],
+            "turn": 7,
+            "last_recall_turn": None,
+            "ended": False,
+            "tone": -35,
+            "wounds": ["you're nothing", "talking to you is a waste of time"],
+            "ending": None,
+        }
+    return {
+        "affinity": 20,
+        "treasure": [],
+        "claimed": [],
+        "history": [],
+        "turn": 0,
+        "last_recall_turn": None,
+        "ended": False,
+        "tone": 0,
+        "wounds": [],
+        "ending": None,
+    }
+```
+
+- [ ] **Step 2: The two new finale generators**
+
+Add after `_play_finale` (keeping its exact yield-tuple shape and pacing pattern):
+
+```python
+def _play_finale_bad(state: dict, history: list):
+    """The wound loop — recites the visitor's cruelties, unredacting them
+    one by one. No model, no GPU."""
+    wounds = state.get("wounds", [])
+    chat_hist = list(history)
+    tier = get_tier(state["affinity"])
+    bond = _render_bond(state["affinity"], tier)
+    revealed = 0
+    treasure_html = render_treasure(state["treasure"], claimed=set(state["claimed"]),
+                                    wounds=wounds, revealed=0)
+    entity = render_entity(state["affinity"], seq=state["turn"])
+    locked = gr.update(interactive=False)
+    input_locked = gr.update(interactive=False)
+    mutated = False
+
+    for step in finale_steps_bad(wounds):
+        role = "assistant" if step["speaker"] == "hollow" else "user"
+        chat_hist = chat_hist + [{"role": role, "content": step["text"]}]
+
+        if step["strike"] is not None:
+            revealed = step["strike"] + 1
+            treasure_html = render_treasure(state["treasure"],
+                                            claimed=set(state["claimed"]),
+                                            wounds=wounds, revealed=revealed)
+
+        if step["stage"] == "turn" and not mutated:
+            mutated = True
+            bond = _render_bond(state["affinity"], tier, label="wound")
+            treasure_html = render_treasure(state["treasure"],
+                                            claimed=set(state["claimed"]),
+                                            wounds=wounds, revealed=revealed,
+                                            yours=True)
+            entity = render_entity(state["affinity"], "rage", seq=state["turn"])
+            input_locked = gr.update(interactive=False, placeholder="get out.")
+
+        yield (input_locked, locked, chat_hist, state, bond, treasure_html, entity)
+        if step["pause"] > 0:
+            time.sleep(step["pause"])
+
+    yield (
+        gr.update(interactive=False, placeholder="get out."),
+        locked, chat_hist, state, bond, treasure_html, entity,
+    )
+
+
+def _play_finale_neutral(state: dict, history: list):
+    """The fog closes — unresolved. No model, no GPU."""
+    chat_hist = list(history)
+    tier = get_tier(state["affinity"])
+    bond = _render_bond(state["affinity"], tier)
+    wounds = state.get("wounds", [])
+    treasure_html = render_treasure(state["treasure"], claimed=set(state["claimed"]),
+                                    wounds=wounds)
+    entity = render_entity(state["affinity"], seq=state["turn"])
+    locked = gr.update(interactive=False)
+    input_locked = gr.update(interactive=False)
+    mutated = False
+
+    for step in finale_steps_neutral():
+        chat_hist = chat_hist + [{"role": "assistant", "content": step["text"]}]
+
+        if step["stage"] == "turn" and not mutated:
+            mutated = True
+            bond = _render_bond(state["affinity"], tier, label="fading")
+            # every entry dims as the treasure stops mattering
+            treasure_html = render_treasure(state["treasure"],
+                                            claimed=set(state["treasure"]),
+                                            wounds=wounds)
+            entity = render_entity(state["affinity"], "dissolve", seq=state["turn"])
+
+        yield (input_locked, locked, chat_hist, state, bond, treasure_html, entity)
+        if step["pause"] > 0:
+            time.sleep(step["pause"])
+
+    yield (
+        gr.update(interactive=False, placeholder="..."),
+        locked, chat_hist, state, bond, treasure_html, entity,
+    )
+```
+
+- [ ] **Step 3: Routing + call sites in `chat()`**
+
+Replace the ended/empty branch at the top of `chat()` with:
+
+```python
+    if not user_msg.strip() or state.get("ended"):
+        ending = state.get("ending")
+        if state.get("ended") and ending is None:
+            ending = "good"  # sessions ended before `ending` existed
+        tier = get_tier(state["affinity"])
+        wounds = state.get("wounds", [])
+        entity_mode = {"good": "end", "bad": "rage"}.get(ending, "idle")
+        yield (
+            gr.update(interactive=not state.get("ended")),
+            gr.update(interactive=not state.get("ended")),
+            history,
+            state,
+            _render_bond(state["affinity"], tier),
+            render_treasure(state["treasure"], mine=(ending == "good"),
+                            claimed=set(state["claimed"]),
+                            wounds=wounds, revealed=len(wounds),
+                            yours=(ending == "bad")),
+            render_entity(state["affinity"], entity_mode, seq=state["turn"]),
+        )
+        return
+```
+
+Replace the Task 4 shim block with real routing:
+
+```python
+    ending = decide_ending(state)
+    if ending:
+        state["ended"] = True
+        state["ending"] = ending
+        if ending == "good":
+            yield from _play_finale(state, history)
+        elif ending == "bad":
+            yield from _play_finale_bad(state, history)
+        else:
+            yield from _play_finale_neutral(state, history)
+        return
+```
+
+Update the `build_system_prompt` call:
+
+```python
+    system = build_system_prompt(state["affinity"], state["treasure"], recall_memory,
+                                 tone=state.get("tone", 0),
+                                 wounds=state.get("wounds", []))
+```
+
+Update the final yield's treasure call:
+
+```python
+        render_treasure(state["treasure"], claimed=set(state["claimed"]),
+                        wounds=state.get("wounds", [])),
+```
+
+- [ ] **Step 4: Run all tests** — all pass (no app.py tests; this guards regressions elsewhere).
+
+- [ ] **Step 5: Smoke-run the app**
+
+Run: `.venv/Scripts/python -c "import app"` — must import cleanly (catches wiring typos cheaply before the manual pass).
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add app.py
+git commit -m "feat: wire three endings into chat() with fast-finale seeds"
+```
+
+---
+
+### Task 10: manual verification + deploy
+
+**Files:** none (verification only, then push)
+
+Follow the established dev verification workflow (CLAUDE.md): launch app in background, poll `http://localhost:7860`, screenshot with headless Chrome, Read the PNG. Kill the app via the port's owning process between runs.
+
+- [ ] **Step 1: Good playthrough** — `HOLLOW_FAST_FINALE=good`, send one warm message ("you matter to me"), then another. Expect: existing Visitor Loop, treasure → "...mine now.", placeholder dies.
+- [ ] **Step 2: Bad playthrough** — `HOLLOW_FAST_FINALE=bad`, send one cruel message ("you're a pathetic little freak"), then another. Expect on the way: redacted ▮ entries visible in Treasure during play; finale unredacts them, header → "Your Words", rage portrait + red pulse, placeholder "get out.".
+- [ ] **Step 3: Neutral playthrough** — `HOLLOW_FAST_FINALE=neutral`, send two flat messages ("ok", "i guess"). Expect: dissolve animation (child sinks back into fog over ~9 s), bond label "fading", placeholder "...".
+- [ ] **Step 4: Fresh-session sanity** — no env var: opening line renders, one normal turn works, no ending fires.
+- [ ] **Step 5: Full test suite** — `.venv/Scripts/python -m pytest tests/ -v`, expected ~100 tests passing.
+- [ ] **Step 6: Deploy**
+
+```bash
+git push space main
+git push hackathon main
+```
+
+Then verify the org Space rebuilds to RUNNING (HF API) and run the bad playthrough once on the Space (it exercises the new extraction fields against the real Qwen3-8B deployment).
+
+---
+
+## Self-review notes (done at planning time)
+
+- Spec coverage: §3 state → Tasks 3/9; §4 extraction → 1/2; §5 → 3; §6 → 5; §7 → 4; §8 → 6; §9 → 7/8; §10 → 9; §11 → all test steps + Task 10. No gaps.
+- Type consistency: `decide_ending` returns `str | None` everywhere; `render_treasure(wounds, revealed, yours)` matches between Tasks 7 and 9; `finale_steps_bad` strike indices (first ≤5, ascending) match `_play_finale_bad`'s `revealed = strike + 1`.
+- Known sequencing: Task 4 leaves a temporary shim in app.py (documented in-task); Task 8 hard-depends on Pablo's `hollow_rage.png` — implementer must BLOCK if missing, not substitute.