Per-case visuals, incident vignettes, guided play, no-repeat dealing, four new crime kinds

COMPLIANCE.md

@@ -72,7 +72,8 @@ Every model is open-weights and self-run. **No third-party AI service is ever ca
 
 ## Content scope
 
-Cases span **homicide, theft, fraud, blackmail, arson, and missing-person** mysteries.
+Cases span **homicide, theft, fraud, blackmail, arson, missing-person, confidence-game,
+poisoning, ransom, and sabotage** mysteries.
 Generation is structurally constrained (case-file language, physical evidence, no graphic
 description) and a deterministic scrubber sanitizes model output. Sexual violence is
 deliberately **not** a case type, keeping the Space comfortably inside the

scripts/check_exhibits.py

@@ -0,0 +1,54 @@
+"""Read-only check: project every prebaked case to its public view and report which
+rich payload each clue gets. Fails (exit 1) if any case ends up all-paper."""
+
+from __future__ import annotations
+
+import sys
+from collections import Counter
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from case_zero.api.case_adapter import casefile_to_public  # noqa: E402
+from case_zero.persistence.case_store import load_case  # noqa: E402
+from case_zero.persistence.paths import prebaked_cases_dir  # noqa: E402
+
+
+def payload_kind(ev) -> str:
+    if ev.thread:
+        return "thread"
+    if ev.transcript:
+        return "voicemail"
+    if ev.rows:
+        return "keycard"
+    if ev.type == "IMAGE":
+        return "cctv" if ev.icon == "cctv" else "photo"
+    return "paper"
+
+
+def main() -> int:
+    hist: Counter[str] = Counter()
+    all_paper: list[str] = []
+    for path in sorted(prebaked_cases_dir().glob("*.json")):
+        case = load_case(path)
+        public = casefile_to_public(case)
+        kinds = []
+        for ev in public.evidence:
+            kind = payload_kind(ev)
+            kinds.append(kind)
+            hist[kind] += 1
+            print(f"{case.case_id} | {ev.id:10s} | {ev.icon:12s} | {kind:9s} | {ev.name[:52]}")
+        if all(k == "paper" for k in kinds):
+            all_paper.append(case.case_id)
+    print("\n--- payload histogram:")
+    for kind, n in hist.most_common():
+        print(f"{kind:9s} {n}")
+    if all_paper:
+        print(f"\nFAIL: all-paper cases: {all_paper}")
+        return 1
+    print("\nOK: every case has at least one rich exhibit")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/prebake_cases.py

@@ -1,161 +1,163 @@
-"""Pre-bake a pool of full, model-authored cases for instant New Case serving.
-
-Generation on a 2-vCPU Space takes ~1-2 minutes, so the player would otherwise stare at a
-loading screen. This script runs the SAME in-process llama.cpp generator offline, keeps only
-solvable, well-formed, "exciting" cases (distinct human suspects, a real motive, no
-detective/officer suspects, a gender mix), assigns each a stable Case ID, and writes the full
-sealed CaseFile JSON to ``cases/prebaked/``. The Space ships these and serves one instantly on
-New Case while still running every interrogation live (and generating fresh cases when the
-hardware allows). The pre-baked cases are authored by the local model - no cloud, still
-Off-the-Grid.
-
-New cases are APPENDED after the existing pool (existing Case IDs keep working as share
-links) and cycle through the crime kinds so the pool is not all murders.
-
-    python scripts/prebake_cases.py [target_count] [start_seed]
-"""
-
-from __future__ import annotations
-
-import re
-import sys
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(ROOT / "src"))
-
-from case_zero.config import get_settings  # noqa: E402
-from case_zero.generator.pipeline import generate_case  # noqa: E402
-from case_zero.llm.backend import make_backend  # noqa: E402
-from case_zero.persistence.case_store import save_case  # noqa: E402
-from case_zero.persistence.paths import prebaked_cases_dir  # noqa: E402
-from case_zero.schemas.case import CaseFile, GenerationKnobs  # noqa: E402
-from case_zero.schemas.enums import CrimeKind  # noqa: E402
-
-# The existing pool is homicide-heavy, so new bakes lean into the other kinds first.
-_KIND_PLAN: tuple[CrimeKind, ...] = (
-    CrimeKind.THEFT, CrimeKind.BLACKMAIL, CrimeKind.ARSON, CrimeKind.MISSING,
-    CrimeKind.FRAUD, CrimeKind.THEFT, CrimeKind.HOMICIDE, CrimeKind.MISSING,
-    CrimeKind.ARSON, CrimeKind.FRAUD, CrimeKind.HOMICIDE, CrimeKind.BLACKMAIL,
-)
-
-_SMALL = {"a", "an", "and", "at", "but", "by", "for", "in", "of", "on", "or", "the", "to"}
-
-
-def _titlecase(raw: str) -> str:
-    words = (raw or "").strip().split()
-    out = []
-    for i, w in enumerate(words):
-        lw = w.lower()
-        out.append(lw if (i not in (0, len(words) - 1) and lw in _SMALL) else lw.capitalize())
-    return " ".join(out)
-
-_BAD_ROLE = re.compile(
-    r"\b(detective|officer|investigator|police|inspector|sergeant|constable|cop|agent)\b",
-    re.IGNORECASE,
-)
-# Filler names a small model reaches for - they read as obviously fake and kill the mood.
-_PLACEHOLDER_NAMES = {
-    "john doe", "jane doe", "john smith", "jane smith", "joe bloggs", "richard roe",
-    "mary major", "john q public", "tom johnson", "tom smith", "jack smith", "jane roe",
-    "john brown", "bob smith", "foo bar", "first last", "name surname",
-}
-# A "name" that is really a role description ("Rival Curator", "Business Partner").
-_ROLE_AS_NAME = re.compile(
-    r"\b(rival|partner|business|curator|servant|butler|maid|cousin|nephew|niece|heir|"
-    r"the\s|guest|stranger|visitor|neighbou?r|colleague|assistant|clerk|owner|manager)\b",
-    re.IGNORECASE,
-)
-
-
-def _name_malformed(n: str) -> bool:
-    # The model sometimes bakes a gender/age/label into the name: "John Smith, Male",
-    # "Lara White, 45" - or hands back a role instead of a name ("Rival Curator").
-    return bool("," in n or any(c.isdigit() for c in n)
-                or re.search(r"\b(male|female)\b", n, re.I) or _ROLE_AS_NAME.search(n))
-
-
-def _name_prefix(n: str) -> str:
-    return " ".join(n.lower().replace(",", " ").split()[:2])
-
-
-def _is_exciting(case: CaseFile) -> tuple[bool, str]:
-    """Reject bland or malformed cases; keep ones that will read well to a judge."""
-    title = (case.title or "").strip()
-    if len(title) < 5:
-        return False, "weak title"
-    vname = case.victim.name.strip()
-    if not vname or " " not in vname or _name_malformed(vname):
-        return False, f"victim needs a clean full name: '{vname}'"
-    names = [s.name.strip() for s in case.suspects]
-    low = [n.lower() for n in names]
-    if len(set(low)) != len(names):
-        return False, "duplicate suspect names"
-    if any(len(n) < 3 or " " not in n for n in names):
-        return False, "suspect needs a full name"
-    if any(_name_malformed(n) for n in names):
-        return False, f"malformed name (comma/digit/gender): {names}"
-    if any(_name_prefix(n) in _PLACEHOLDER_NAMES for n in names):
-        return False, f"placeholder name: {names}"
-    roles = [s.role.strip().lower() for s in case.suspects]
-    if len(set(roles)) < len(roles):
-        return False, "duplicate suspect roles"
-    for s in case.suspects:
-        if _BAD_ROLE.search(s.role) or _BAD_ROLE.search(s.name):
-            return False, f"detective-like suspect: {s.name} ({s.role})"
-    if not any((s.visual.gender or "").lower().startswith("f") for s in case.suspects):
-        return False, "no female suspect"
-    if not any((s.visual.gender or "").lower().startswith("m") for s in case.suspects):
-        return False, "no male suspect"
-    # A real culprit with a written motive and method makes the mystery land.
-    if not (case.culprit.method_narrative or "").strip():
-        return False, "no method narrative"
-    return True, "ok"
-
-
-def main() -> int:
-    target = int(sys.argv[1]) if len(sys.argv) > 1 else 8
-    start_seed = int(sys.argv[2]) if len(sys.argv) > 2 else 51000
-    max_attempts = target * 4 + 8
-
-    backend = make_backend(get_settings())
-    out_dir = prebaked_cases_dir()
-    out_dir.mkdir(parents=True, exist_ok=True)
-    existing = len(list(out_dir.glob("CASE-*.json")))
-    print(f"pool has {existing} cases; appending {target} new ones across crime kinds")
-
-    kept: list[CaseFile] = []
-    seed = start_seed
-    attempts = 0
-    while len(kept) < target and attempts < max_attempts:
-        attempts += 1
-        kind = _KIND_PLAN[len(kept) % len(_KIND_PLAN)]
-        try:
-            result = generate_case(backend, seed=seed,
-                                   knobs=GenerationKnobs(crime_kind=kind))
-        except Exception as exc:  # generation hiccup - skip this seed
-            print(f"[seed {seed}] generation error: {exc}")
-            seed += 1
-            continue
-        seed += 1
-        if not result.report.ok:
-            print(f"[seed {seed - 1}] unsolvable, skipped")
-            continue
-        ok, why = _is_exciting(result.case)
-        if not ok:
-            print(f"[seed {seed - 1}] rejected: {why} -- '{result.case.title}'")
-            continue
-        case_id = f"CASE-{existing + len(kept) + 1:04d}"
-        case = result.case.model_copy(update={"case_id": case_id,
-                                              "title": _titlecase(result.case.title)})
-        save_case(case, out_dir / f"{case_id}.json")
-        kept.append(case)
-        cast = ", ".join(f"{s.name} ({s.visual.gender[:1].upper()})" for s in case.suspects)
-        print(f"[KEEP {case_id}] ({kind.value}) '{case.title}' - victim {case.victim.name} | {cast}")
-
-    print(f"\nDONE: kept {len(kept)}/{target} in {attempts} attempts -> {out_dir}")
-    return 0 if kept else 1
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
+"""Pre-bake a pool of full, model-authored cases for instant New Case serving.
+
+Generation on a 2-vCPU Space takes ~1-2 minutes, so the player would otherwise stare at a
+loading screen. This script runs the SAME in-process llama.cpp generator offline, keeps only
+solvable, well-formed, "exciting" cases (distinct human suspects, a real motive, no
+detective/officer suspects, a gender mix), assigns each a stable Case ID, and writes the full
+sealed CaseFile JSON to ``cases/prebaked/``. The Space ships these and serves one instantly on
+New Case while still running every interrogation live (and generating fresh cases when the
+hardware allows). The pre-baked cases are authored by the local model - no cloud, still
+Off-the-Grid.
+
+New cases are APPENDED after the existing pool (existing Case IDs keep working as share
+links) and cycle through the crime kinds so the pool is not all murders.
+
+    python scripts/prebake_cases.py [target_count] [start_seed]
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "src"))
+
+from case_zero.config import get_settings  # noqa: E402
+from case_zero.generator.pipeline import generate_case  # noqa: E402
+from case_zero.llm.backend import make_backend  # noqa: E402
+from case_zero.persistence.case_store import save_case  # noqa: E402
+from case_zero.persistence.paths import prebaked_cases_dir  # noqa: E402
+from case_zero.schemas.case import CaseFile, GenerationKnobs  # noqa: E402
+from case_zero.schemas.enums import CrimeKind  # noqa: E402
+
+# The existing pool is homicide-heavy, so new bakes lean into the other kinds first
+# (the four newest kinds open the plan so the next bake adds them immediately).
+_KIND_PLAN: tuple[CrimeKind, ...] = (
+    CrimeKind.CON, CrimeKind.POISONING, CrimeKind.RANSOM, CrimeKind.SABOTAGE,
+    CrimeKind.THEFT, CrimeKind.BLACKMAIL, CrimeKind.ARSON, CrimeKind.MISSING,
+    CrimeKind.FRAUD, CrimeKind.CON, CrimeKind.POISONING, CrimeKind.SABOTAGE,
+    CrimeKind.RANSOM, CrimeKind.HOMICIDE, CrimeKind.THEFT, CrimeKind.FRAUD,
+)
+
+_SMALL = {"a", "an", "and", "at", "but", "by", "for", "in", "of", "on", "or", "the", "to"}
+
+
+def _titlecase(raw: str) -> str:
+    words = (raw or "").strip().split()
+    out = []
+    for i, w in enumerate(words):
+        lw = w.lower()
+        out.append(lw if (i not in (0, len(words) - 1) and lw in _SMALL) else lw.capitalize())
+    return " ".join(out)
+
+_BAD_ROLE = re.compile(
+    r"\b(detective|officer|investigator|police|inspector|sergeant|constable|cop|agent)\b",
+    re.IGNORECASE,
+)
+# Filler names a small model reaches for - they read as obviously fake and kill the mood.
+_PLACEHOLDER_NAMES = {
+    "john doe", "jane doe", "john smith", "jane smith", "joe bloggs", "richard roe",
+    "mary major", "john q public", "tom johnson", "tom smith", "jack smith", "jane roe",
+    "john brown", "bob smith", "foo bar", "first last", "name surname",
+}
+# A "name" that is really a role description ("Rival Curator", "Business Partner").
+_ROLE_AS_NAME = re.compile(
+    r"\b(rival|partner|business|curator|servant|butler|maid|cousin|nephew|niece|heir|"
+    r"the\s|guest|stranger|visitor|neighbou?r|colleague|assistant|clerk|owner|manager)\b",
+    re.IGNORECASE,
+)
+
+
+def _name_malformed(n: str) -> bool:
+    # The model sometimes bakes a gender/age/label into the name: "John Smith, Male",
+    # "Lara White, 45" - or hands back a role instead of a name ("Rival Curator").
+    return bool("," in n or any(c.isdigit() for c in n)
+                or re.search(r"\b(male|female)\b", n, re.I) or _ROLE_AS_NAME.search(n))
+
+
+def _name_prefix(n: str) -> str:
+    return " ".join(n.lower().replace(",", " ").split()[:2])
+
+
+def _is_exciting(case: CaseFile) -> tuple[bool, str]:
+    """Reject bland or malformed cases; keep ones that will read well to a judge."""
+    title = (case.title or "").strip()
+    if len(title) < 5:
+        return False, "weak title"
+    vname = case.victim.name.strip()
+    if not vname or " " not in vname or _name_malformed(vname):
+        return False, f"victim needs a clean full name: '{vname}'"
+    names = [s.name.strip() for s in case.suspects]
+    low = [n.lower() for n in names]
+    if len(set(low)) != len(names):
+        return False, "duplicate suspect names"
+    if any(len(n) < 3 or " " not in n for n in names):
+        return False, "suspect needs a full name"
+    if any(_name_malformed(n) for n in names):
+        return False, f"malformed name (comma/digit/gender): {names}"
+    if any(_name_prefix(n) in _PLACEHOLDER_NAMES for n in names):
+        return False, f"placeholder name: {names}"
+    roles = [s.role.strip().lower() for s in case.suspects]
+    if len(set(roles)) < len(roles):
+        return False, "duplicate suspect roles"
+    for s in case.suspects:
+        if _BAD_ROLE.search(s.role) or _BAD_ROLE.search(s.name):
+            return False, f"detective-like suspect: {s.name} ({s.role})"
+    if not any((s.visual.gender or "").lower().startswith("f") for s in case.suspects):
+        return False, "no female suspect"
+    if not any((s.visual.gender or "").lower().startswith("m") for s in case.suspects):
+        return False, "no male suspect"
+    # A real culprit with a written motive and method makes the mystery land.
+    if not (case.culprit.method_narrative or "").strip():
+        return False, "no method narrative"
+    return True, "ok"
+
+
+def main() -> int:
+    target = int(sys.argv[1]) if len(sys.argv) > 1 else 8
+    start_seed = int(sys.argv[2]) if len(sys.argv) > 2 else 51000
+    max_attempts = target * 4 + 8
+
+    backend = make_backend(get_settings())
+    out_dir = prebaked_cases_dir()
+    out_dir.mkdir(parents=True, exist_ok=True)
+    existing = len(list(out_dir.glob("CASE-*.json")))
+    print(f"pool has {existing} cases; appending {target} new ones across crime kinds")
+
+    kept: list[CaseFile] = []
+    seed = start_seed
+    attempts = 0
+    while len(kept) < target and attempts < max_attempts:
+        attempts += 1
+        kind = _KIND_PLAN[len(kept) % len(_KIND_PLAN)]
+        try:
+            result = generate_case(backend, seed=seed,
+                                   knobs=GenerationKnobs(crime_kind=kind))
+        except Exception as exc:  # generation hiccup - skip this seed
+            print(f"[seed {seed}] generation error: {exc}")
+            seed += 1
+            continue
+        seed += 1
+        if not result.report.ok:
+            print(f"[seed {seed - 1}] unsolvable, skipped")
+            continue
+        ok, why = _is_exciting(result.case)
+        if not ok:
+            print(f"[seed {seed - 1}] rejected: {why} -- '{result.case.title}'")
+            continue
+        case_id = f"CASE-{existing + len(kept) + 1:04d}"
+        case = result.case.model_copy(update={"case_id": case_id,
+                                              "title": _titlecase(result.case.title)})
+        save_case(case, out_dir / f"{case_id}.json")
+        kept.append(case)
+        cast = ", ".join(f"{s.name} ({s.visual.gender[:1].upper()})" for s in case.suspects)
+        print(f"[KEEP {case_id}] ({kind.value}) '{case.title}' - victim {case.victim.name} | {cast}")
+
+    print(f"\nDONE: kept {len(kept)}/{target} in {attempts} attempts -> {out_dir}")
+    return 0 if kept else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

src/case_zero/api/case_adapter.py

@@ -14,6 +14,7 @@ import re
 from ..generator.crime_profiles import CrimeProfile, profile_for
 from ..schemas.case import CaseFile
 from ..schemas.clue import Clue
+from .exhibits import synthesize_payload
 from .public_view import (
     FlashbackAccount,
     PublicCase,
@@ -148,8 +149,11 @@ def _suspect_public(case: CaseFile, idx: int) -> PublicSuspect:
         name=s.name,
         role=s.role,
         age=30 + (seed % 35),
-        sprite=s.sus_id,
+        # Salted with the case id so S1 in one case is a different face than S1 in
+        # another (the client hashes the whole sprite string into its portrait pools).
+        sprite=f"{case.case_id}:{s.sus_id}",
         gender=gender,
+        accent_color=(s.visual.accent_color if s.visual else "") or "",
         tag=tag[:22],
         baseline_suspicion=25 + (seed % 16),
         motive=_APPARENT[idx % len(_APPARENT)],
@@ -162,17 +166,23 @@ def _suspect_public(case: CaseFile, idx: int) -> PublicSuspect:
 
 def _evidence_public(case: CaseFile, clue: Clue, idx: int) -> PublicEvidence:
     at = next((f.at_min for f in case.facts if f.fact_id == clue.supports_fact_id and f.at_min is not None), None)
-    time = _clock(at) if at is not None else _clock(case.setting.murder_window.start_min + 7 * (idx + 1))
-    return PublicEvidence(
+    base_min = at if at is not None else case.setting.murder_window.start_min + 7 * (idx + 1)
+    time = _clock(base_min)
+    icon = _icon_for(clue.name, clue.reveal_text, idx, clue.discovery_method.value)
+    kwargs: dict = dict(
         id=clue.clue_id,
         name=clue.name.upper(),
         type=clue.discovery_method.value.upper(),
-        icon=_icon_for(clue.name, clue.reveal_text, idx, clue.discovery_method.value),
+        icon=icon,
         time=time,
         found=f"Recovered from {_loc_name(case, clue.discoverable_at_loc_id)}.",
         summary=clue.reveal_text,
         detail=clue.reveal_text,
     )
+    # Rich device payload (phone thread / voicemail / keycard table / CCTV / scene
+    # photo) synthesized deterministically from the clue's own public material.
+    kwargs.update(synthesize_payload(case, clue, icon, idx, base_min, time))
+    return PublicEvidence(**kwargs)
 
 
 def _timeline(case: CaseFile, profile: CrimeProfile) -> tuple[TimelineBeat, ...]:
@@ -239,8 +249,10 @@ def _story_beats(case: CaseFile, profile: CrimeProfile, scene: str) -> tuple[Sto
         _loc_name(case, crime_loc),
     )
     return (
-        StoryBeat(scene="skyline", kicker=case.setting.name.upper(), title="The call", text=case.briefing),
-        StoryBeat(scene=scene, kicker="THE VICTIM", title=v.name, text=f"{v.name}, {v.role}. {v.cause_of_death}"),
+        # Beat 1 backdrop: an establishing shot of the actual crime setting (the client
+        # resolves the place name to a painter; bare "skyline" stays the city default).
+        StoryBeat(scene=case.setting.name or "skyline", kicker=case.setting.name.upper(), title="The call", text=case.briefing),
+        StoryBeat(scene=scene, kicker="THE VICTIM", title=v.name, text=f"{v.name}, {v.role}. {v.cause_of_death}", incident=True),
         StoryBeat(scene=f"{building} — {other_room}", kicker="THOSE WHO STAYED", title="Persons of interest",
                   text="Each of them had a reason to be here tonight, and a story you'll need to take apart."),
         StoryBeat(scene="desk", kicker="YOUR CASE NOW", title="Detective",

src/case_zero/api/dto.py

@@ -1,31 +1,34 @@
-"""Wire DTOs for the public game API.
-
-These are the exact shapes the Preact client exchanges with the server. The client
-speaks camelCase; pydantic aliases map that to snake_case internally. The sealed
-``CaseFile``/``Solution`` never appears here - only the public ``PlayerCaseView``
-projection is ever returned before the verdict.
-"""
-
-from __future__ import annotations
-
-from pydantic import BaseModel, ConfigDict, Field
-
-from .public_view import PublicCase
-
-
-class _CamelModel(BaseModel):
-    """Base: accept snake_case or camelCase on input, emit camelCase on output."""
-
-    model_config = ConfigDict(populate_by_name=True)
-
-
-class NewCaseRequest(_CamelModel):
-    seed: int | None = None
-    case_id: str | None = Field(default=None, alias="caseId")
-    difficulty: str | None = None
-
-
-class CaseResponse(_CamelModel):
-    case_id: str = Field(alias="caseId")
-    run_id: str = Field(alias="runId")
-    case: PublicCase
+"""Wire DTOs for the public game API.
+
+These are the exact shapes the Preact client exchanges with the server. The client
+speaks camelCase; pydantic aliases map that to snake_case internally. The sealed
+``CaseFile``/``Solution`` never appears here - only the public ``PlayerCaseView``
+projection is ever returned before the verdict.
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .public_view import PublicCase
+
+
+class _CamelModel(BaseModel):
+    """Base: accept snake_case or camelCase on input, emit camelCase on output."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+
+class NewCaseRequest(_CamelModel):
+    seed: int | None = None
+    case_id: str | None = Field(default=None, alias="caseId")
+    difficulty: str | None = None
+    # Case ids this player already started, oldest first. New Case never re-deals
+    # these (explicit ?case=/caseId loads bypass the filter so share links work).
+    exclude_case_ids: list[str] = Field(default_factory=list, alias="excludeCaseIds")
+
+
+class CaseResponse(_CamelModel):
+    case_id: str = Field(alias="caseId")
+    run_id: str = Field(alias="runId")
+    case: PublicCase

src/case_zero/api/exhibits.py

@@ -0,0 +1,186 @@
+"""Deterministic rich-exhibit payloads for generated and prebaked cases.
+
+The golden case hand-authors device mockups (phone threads, voicemail players, keycard
+tables, CCTV stills). Generated cases get the same treatment here, synthesized at serve
+time from each clue's OWN public material - no model call, instant, reproducible.
+
+NO-LEAK RULE (enforced by tests): synthesizers may read ONLY
+  - the clue's name / reveal_text / location / supporting fact's ``at_min``,
+  - suspects' names, roles, and STATED alibis (their public dossier claims),
+  - the victim's name and the murder window.
+Never the culprit, solution, secrets, true whereabouts, anchored lies, or any sealed
+``Fact.statement``. A suspect's name may appear in synthesized content only if it is
+verbatim in the reveal_text (already shown to players) or restating that suspect's own
+stated alibi. Filler lines come from fixed banks that assert no plot facts.
+"""
+
+from __future__ import annotations
+
+from ..schemas.case import CaseFile
+from ..schemas.clue import Clue
+from ..schemas.enums import DiscoveryMethod
+from .public_view import ThreadMessage
+
+
+def _hash(s: str) -> int:
+    h = 0
+    for ch in s:
+        h = (h * 31 + ord(ch)) & 0x7FFFFFFF
+    return h
+
+
+def _clock12(minute: int) -> str:
+    h = (minute // 60) % 24
+    m = minute % 60
+    return f"{h % 12 or 12}:{m:02d}"
+
+
+def _clock24(minute: int) -> str:
+    return f"{(minute // 60) % 24:02d}:{minute % 60:02d}"
+
+
+def _loc_name(case: CaseFile, loc_id: str) -> str:
+    for loc in case.setting.locations:
+        if loc.loc_id == loc_id:
+            return loc.name
+    return loc_id
+
+
+def _surname(full: str) -> str:
+    parts = (full or "").split()
+    return parts[-1] if parts else full
+
+
+def _named_in(text: str, case: CaseFile) -> str | None:
+    """A suspect's name, only if the clue's own text already names them."""
+    hay = text or ""
+    for s in case.suspects:
+        if s.name and s.name in hay:
+            return s.name
+        sur = _surname(s.name)
+        if len(sur) > 2 and sur in hay:
+            return s.name
+    return None
+
+
+def _split_sentences(text: str, limit: int = 2) -> list[str]:
+    parts = [p.strip() for p in (text or "").replace("? ", "?|").replace("! ", "!|").replace(". ", ".|").split("|") if p.strip()]
+    if not parts:
+        return [text or ""]
+    if len(parts) <= limit:
+        return parts
+    head = " ".join(parts[: len(parts) - limit + 1])
+    return [head, *parts[len(parts) - limit + 1:]]
+
+
+# Plot-neutral openers: timestamps and pleasantries only, never case facts.
+_OPENERS = (
+    "We need to talk.",
+    "Not over the phone.",
+    "Are you there?",
+    "Don't make me ask twice.",
+    "You know why I'm writing.",
+)
+
+
+def _thread(case: CaseFile, clue: Clue, base_min: int) -> dict:
+    seed = _hash(case.case_id + clue.clue_id)
+    other = _named_in(f"{clue.name} {clue.reveal_text}", case)
+    who_other = _surname(other).upper() if other else "UNKNOWN"
+    who_me = _surname(case.victim.name).upper()
+    climax = _split_sentences(clue.reveal_text, 2)
+    n_open = 2 + seed % 2
+    msgs: list[ThreadMessage] = []
+    minute = base_min - 3 * (n_open + len(climax))
+    for i in range(n_open):
+        frm = "them" if i % 2 == 0 else "me"
+        msgs.append(ThreadMessage(**{
+            "from": frm,
+            "who": who_other if frm == "them" else who_me,
+            "t": _clock12(minute),
+            "m": _OPENERS[(seed + i) % len(_OPENERS)],
+        }))
+        minute += 2 + (seed >> i) % 3
+    for i, line in enumerate(climax):
+        frm = "them" if (n_open + i) % 2 == 0 else "me"
+        msgs.append(ThreadMessage(**{
+            "from": frm,
+            "who": who_other if frm == "them" else who_me,
+            "t": _clock12(min(minute, base_min)),
+            "m": line,
+        }))
+        minute += 2
+    return {"type": "PHONE", "thread": tuple(msgs)}
+
+
+def _voicemail(clue: Clue) -> dict:
+    text = (clue.reveal_text or "").strip()
+    quoted = text if text.startswith(("“", '"')) else f"“{text}”"
+    secs = max(8, min(55, round(len(text.split()) * 0.4)))
+    return {"type": "AUDIO", "transcript": quoted, "dur": f"0:{secs:02d}"}
+
+
+def _keycard(case: CaseFile, clue: Clue, base_min: int) -> dict:
+    rows: list[tuple[str, str, str, str]] = []
+    for s in case.suspects[:4]:
+        segs = s.stated_alibi.claimed_segments
+        if not segs:
+            continue
+        seg = segs[0]
+        rows.append((
+            _clock24(seg.window.start_min),
+            _loc_name(case, seg.loc_id),
+            _surname(s.name).upper(),
+            "ok",
+        ))
+    holder = _named_in(f"{clue.name} {clue.reveal_text}", case)
+    rows.append((
+        _clock24(base_min),
+        _loc_name(case, clue.discoverable_at_loc_id),
+        _surname(holder).upper() if holder else "UNREGISTERED",
+        "flag",
+    ))
+    rows.sort(key=lambda r: r[0])
+    return {"type": "DATA", "rows": tuple(rows[:6])}
+
+
+def _cctv(case: CaseFile, clue: Clue, time_str: str) -> dict:
+    loc = _loc_name(case, clue.discoverable_at_loc_id)
+    return {
+        "type": "IMAGE",
+        "detail": f"CAM — {loc.upper()}\n{time_str}\n{clue.reveal_text}",
+    }
+
+
+def _photo(case: CaseFile, clue: Clue, idx: int, keep_icon: bool = False) -> dict:
+    loc = _loc_name(case, clue.discoverable_at_loc_id)
+    out: dict = {
+        "type": "IMAGE",
+        "detail": f"{loc.upper()} — EVIDENCE MARKER {idx + 1}\n{clue.reveal_text}",
+    }
+    if not keep_icon:
+        out["icon"] = "photoEv"
+    return out
+
+
+# Forensic finds that read best as an in-situ scene photograph (evidence marker shot):
+# the locker shows the photo frame, while the board/dossier keep the object art.
+_IN_SITU_ICONS = frozenset({"fingerprint", "bootprint", "tumbler", "jewel", "clock"})
+
+
+def synthesize_payload(case: CaseFile, clue: Clue, icon: str, idx: int, base_min: int, time_str: str) -> dict:
+    """Extra ``PublicEvidence`` kwargs for one clue: a display type plus at most one
+    rich payload. Anything unmatched stays a paper exhibit (the existing look)."""
+    if icon == "phone":
+        return _thread(case, clue, base_min)
+    if icon == "voicemail" or (clue.discovery_method is DiscoveryMethod.INTERROGATION):
+        return _voicemail(clue)
+    if icon == "keycard":
+        return _keycard(case, clue, base_min)
+    if icon == "cctv":
+        return _cctv(case, clue, time_str)
+    if icon == "photoEv":
+        return _photo(case, clue, idx)
+    if clue.discovery_method is DiscoveryMethod.FORENSIC and icon in _IN_SITU_ICONS:
+        return _photo(case, clue, idx, keep_icon=True)
+    return {}

src/case_zero/api/public_view.py

@@ -1,187 +1,192 @@
-"""The PUBLIC wire contract: the exact case shape the Preact client receives.
-
-This mirrors the prototype's ``prototype/js/case.jsx`` (the data-model-by-example) in
-camelCase. It is the ONLY case representation that ever reaches the browser before the
-verdict. The sealed solution - killer, true motive, key-evidence chain - and every
-per-question/per-evidence suspicion *delta* and scripted *answer* are deliberately absent:
-those are produced live, server-side (the deltas alone would reveal the killer).
-"""
-
-from __future__ import annotations
-
-from pydantic import BaseModel, ConfigDict, Field
-from pydantic.alias_generators import to_camel
-
-
-class _Wire(BaseModel):
-    """camelCase on the wire; snake_case in Python. Frozen - a view is never mutated."""
-
-    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True, frozen=True)
-
-
-class PublicVictim(_Wire):
-    name: str
-    role: str
-    age: int
-    sprite: str
-    bio: str
-
-
-class SuggestedQuestion(_Wire):
-    id: str
-    q: str
-
-
-class PublicSuspect(_Wire):
-    id: str
-    name: str
-    role: str
-    age: int
-    sprite: str
-    gender: str = "male"
-    tag: str
-    baseline_suspicion: int
-    motive: str  # apparent motive shown in the dossier - NOT proof
-    alibi: str
-    quote: str
-    greet: str
-    suggested_questions: tuple[SuggestedQuestion, ...]
-
-
-class ThreadMessage(_Wire):
-    from_: str = Field(alias="from")
-    who: str
-    t: str
-    m: str
-
-
-class PublicEvidence(_Wire):
-    id: str
-    name: str
-    type: str  # PHONE | PAPER | IMAGE | AUDIO | DATA
-    icon: str
-    time: str
-    found: str
-    summary: str
-    # Exactly one of these display payloads is populated, per type.
-    thread: tuple[ThreadMessage, ...] | None = None
-    detail: str | None = None
-    transcript: str | None = None
-    dur: str | None = None
-    rows: tuple[tuple[str, ...], ...] | None = None
-
-
-class TimelineBeat(_Wire):
-    time: str
-    label: str
-    locked: bool = False
-    ev: str | None = None
-    conflict: bool = False
-
-
-class FlashbackAccount(_Wire):
-    who: str
-    scene: str
-    lines: tuple[str, ...]
-    flags: tuple[int, ...] = ()
-
-
-class PublicFlashback(_Wire):
-    title: str
-    a: FlashbackAccount
-    b: FlashbackAccount
-
-
-class PublicMotive(_Wire):
-    id: str
-    text: str
-
-
-class StoryBeat(_Wire):
-    scene: str
-    kicker: str
-    title: str
-    text: str
-
-
-class PublicCase(_Wire):
-    id: str
-    city: str
-    district: str
-    title: str
-    tagline: str
-    weather: str
-    victim: PublicVictim
-    scene: str
-    tod: str
-    found: str
-    cause: str
-    # Case-kind display labels. Defaulted to homicide so the golden case and every
-    # pre-kind stored case keep their exact current wording.
-    kind: str = "homicide"
-    kind_label: str = "HOMICIDE"  # title screen: "A PROCEDURAL {kindLabel}"
-    division: str = "HOMICIDE DIVISION"
-    victim_status: str = "DECEASED"  # dossier stamp next to the victim
-    tod_label: str = "T.O.D."
-    verdict: str = "Homicide"  # KEY FACTS verdict line
-    facts: tuple[tuple[str, str], ...]
-    boot_lines: tuple[str, ...]
-    story_beats: tuple[StoryBeat, ...]
-    suspects: tuple[PublicSuspect, ...]
-    evidence: tuple[PublicEvidence, ...]
-    timeline: tuple[TimelineBeat, ...]
-    flashback: PublicFlashback
-    motives: tuple[PublicMotive, ...]
-
-
-def golden_to_public(data: dict) -> PublicCase:
-    """Project a sealed golden/stored case dict into the PUBLIC view.
-
-    Strips the ``sealed`` block and, per suspect, the scripted ``answer``/``delta`` and
-    the ``present``/``default`` reply tables - leaving only question text the player sees.
-    """
-    suspects = tuple(
-        PublicSuspect(
-            id=s["id"],
-            name=s["name"],
-            role=s["role"],
-            age=s["age"],
-            sprite=s["sprite"],
-            gender=s.get("gender", "male"),
-            tag=s["tag"],
-            baseline_suspicion=s["suspicion"],
-            motive=s["motive"],
-            alibi=s["alibi"],
-            quote=s["quote"],
-            greet=s["greet"],
-            suggested_questions=tuple(
-                SuggestedQuestion(id=q["id"], q=q["q"]) for q in s["questions"]
-            ),
-        )
-        for s in data["suspects"]
-    )
-    return PublicCase(
-        id=data["id"],
-        city=data["city"],
-        district=data["district"],
-        title=data["title"],
-        tagline=data["tagline"],
-        weather=data["weather"],
-        victim=PublicVictim(**data["victim"]),
-        scene=data["scene"],
-        tod=data["tod"],
-        found=data["found"],
-        cause=data["cause"],
-        facts=tuple(tuple(pair) for pair in data["facts"]),
-        boot_lines=tuple(data["bootLines"]),
-        story_beats=tuple(StoryBeat(**b) for b in data.get("storyBeats", [])),
-        suspects=suspects,
-        evidence=tuple(PublicEvidence(**e) for e in data["evidence"]),
-        timeline=tuple(TimelineBeat(**b) for b in data["timeline"]),
-        flashback=PublicFlashback(
-            title=data["flashback"]["title"],
-            a=FlashbackAccount(**data["flashback"]["a"]),
-            b=FlashbackAccount(**data["flashback"]["b"]),
-        ),
-        motives=tuple(PublicMotive(**m) for m in data["motives"]),
-    )
+"""The PUBLIC wire contract: the exact case shape the Preact client receives.
+
+This mirrors the prototype's ``prototype/js/case.jsx`` (the data-model-by-example) in
+camelCase. It is the ONLY case representation that ever reaches the browser before the
+verdict. The sealed solution - killer, true motive, key-evidence chain - and every
+per-question/per-evidence suspicion *delta* and scripted *answer* are deliberately absent:
+those are produced live, server-side (the deltas alone would reveal the killer).
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+from pydantic.alias_generators import to_camel
+
+
+class _Wire(BaseModel):
+    """camelCase on the wire; snake_case in Python. Frozen - a view is never mutated."""
+
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True, frozen=True)
+
+
+class PublicVictim(_Wire):
+    name: str
+    role: str
+    age: int
+    sprite: str
+    bio: str
+
+
+class SuggestedQuestion(_Wire):
+    id: str
+    q: str
+
+
+class PublicSuspect(_Wire):
+    id: str
+    name: str
+    role: str
+    age: int
+    sprite: str
+    gender: str = "male"
+    accent_color: str = ""  # outfit accent hex; the client recolors the sprite with it
+    tag: str
+    baseline_suspicion: int
+    motive: str  # apparent motive shown in the dossier - NOT proof
+    alibi: str
+    quote: str
+    greet: str
+    suggested_questions: tuple[SuggestedQuestion, ...]
+
+
+class ThreadMessage(_Wire):
+    from_: str = Field(alias="from")
+    who: str
+    t: str
+    m: str
+
+
+class PublicEvidence(_Wire):
+    id: str
+    name: str
+    type: str  # PHONE | PAPER | IMAGE | AUDIO | DATA
+    icon: str
+    time: str
+    found: str
+    summary: str
+    # Exactly one of these display payloads is populated, per type.
+    thread: tuple[ThreadMessage, ...] | None = None
+    detail: str | None = None
+    transcript: str | None = None
+    dur: str | None = None
+    rows: tuple[tuple[str, ...], ...] | None = None
+
+
+class TimelineBeat(_Wire):
+    time: str
+    label: str
+    locked: bool = False
+    ev: str | None = None
+    conflict: bool = False
+
+
+class FlashbackAccount(_Wire):
+    who: str
+    scene: str
+    lines: tuple[str, ...]
+    flags: tuple[int, ...] = ()
+
+
+class PublicFlashback(_Wire):
+    title: str
+    a: FlashbackAccount
+    b: FlashbackAccount
+
+
+class PublicMotive(_Wire):
+    id: str
+    text: str
+
+
+class StoryBeat(_Wire):
+    scene: str
+    kicker: str
+    title: str
+    text: str
+    # True on the beat that narrates the MAIN ACTION (the body, the empty pedestal...):
+    # the client draws the crime-kind vignette over the scene so the act is SEEN.
+    incident: bool = False
+
+
+class PublicCase(_Wire):
+    id: str
+    city: str
+    district: str
+    title: str
+    tagline: str
+    weather: str
+    victim: PublicVictim
+    scene: str
+    tod: str
+    found: str
+    cause: str
+    # Case-kind display labels. Defaulted to homicide so the golden case and every
+    # pre-kind stored case keep their exact current wording.
+    kind: str = "homicide"
+    kind_label: str = "HOMICIDE"  # title screen: "A PROCEDURAL {kindLabel}"
+    division: str = "HOMICIDE DIVISION"
+    victim_status: str = "DECEASED"  # dossier stamp next to the victim
+    tod_label: str = "T.O.D."
+    verdict: str = "Homicide"  # KEY FACTS verdict line
+    facts: tuple[tuple[str, str], ...]
+    boot_lines: tuple[str, ...]
+    story_beats: tuple[StoryBeat, ...]
+    suspects: tuple[PublicSuspect, ...]
+    evidence: tuple[PublicEvidence, ...]
+    timeline: tuple[TimelineBeat, ...]
+    flashback: PublicFlashback
+    motives: tuple[PublicMotive, ...]
+
+
+def golden_to_public(data: dict) -> PublicCase:
+    """Project a sealed golden/stored case dict into the PUBLIC view.
+
+    Strips the ``sealed`` block and, per suspect, the scripted ``answer``/``delta`` and
+    the ``present``/``default`` reply tables - leaving only question text the player sees.
+    """
+    suspects = tuple(
+        PublicSuspect(
+            id=s["id"],
+            name=s["name"],
+            role=s["role"],
+            age=s["age"],
+            sprite=s["sprite"],
+            gender=s.get("gender", "male"),
+            accent_color=s.get("accentColor", ""),
+            tag=s["tag"],
+            baseline_suspicion=s["suspicion"],
+            motive=s["motive"],
+            alibi=s["alibi"],
+            quote=s["quote"],
+            greet=s["greet"],
+            suggested_questions=tuple(
+                SuggestedQuestion(id=q["id"], q=q["q"]) for q in s["questions"]
+            ),
+        )
+        for s in data["suspects"]
+    )
+    return PublicCase(
+        id=data["id"],
+        city=data["city"],
+        district=data["district"],
+        title=data["title"],
+        tagline=data["tagline"],
+        weather=data["weather"],
+        victim=PublicVictim(**data["victim"]),
+        scene=data["scene"],
+        tod=data["tod"],
+        found=data["found"],
+        cause=data["cause"],
+        facts=tuple(tuple(pair) for pair in data["facts"]),
+        boot_lines=tuple(data["bootLines"]),
+        story_beats=tuple(StoryBeat(**b) for b in data.get("storyBeats", [])),
+        suspects=suspects,
+        evidence=tuple(PublicEvidence(**e) for e in data["evidence"]),
+        timeline=tuple(TimelineBeat(**b) for b in data["timeline"]),
+        flashback=PublicFlashback(
+            title=data["flashback"]["title"],
+            a=FlashbackAccount(**data["flashback"]["a"]),
+            b=FlashbackAccount(**data["flashback"]["b"]),
+        ),
+        motives=tuple(PublicMotive(**m) for m in data["motives"]),
+    )

src/case_zero/api/routes_case.py

@@ -1,55 +1,57 @@
-"""Case lifecycle: create a new case (generate, or load by ID) and fetch a public view.
-
-New Case generates a fresh, solvable mystery via the in-process LLM (buffered one-ahead);
-if generation is unavailable (no weights / load failure) it falls back to the GRAYMOOR-3107
-golden case so the loop is always playable. Generated cases are persisted by Case ID, so a
-shared ID reloads the identical mystery. The sealed solution is never in any response here.
-"""
-
-from __future__ import annotations
-
-from fastapi import APIRouter, HTTPException
-
-from ..persistence.golden import golden_exists, load_golden
-from ..persistence.run_store import create_run
-from .dto import CaseResponse, NewCaseRequest
-from .public_view import golden_to_public
-from .runtime import RUNTIME
-
-router = APIRouter(prefix="/api", tags=["case"])
-
-DEFAULT_CASE_ID = "GRAYMOOR-3107"
-
-
-def _golden_response(case_id: str) -> CaseResponse:
-    run = create_run(case_id)
-    return CaseResponse(case_id=case_id, run_id=run.run_id, case=golden_to_public(load_golden(case_id)))
-
-
-@router.post("/case", response_model=CaseResponse)
-def new_case(req: NewCaseRequest) -> CaseResponse:
-    if req.case_id:
-        if golden_exists(req.case_id):
-            return _golden_response(req.case_id)
-        loaded = RUNTIME.load_generated_run(req.case_id)
-        if loaded is not None:
-            public, run_id = loaded
-            return CaseResponse(case_id=public.id, run_id=run_id, case=public)
-        return _golden_response(DEFAULT_CASE_ID)
-
-    generated = RUNTIME.new_generated_run()
-    if generated is not None:
-        public, run_id = generated
-        return CaseResponse(case_id=public.id, run_id=run_id, case=public)
-    return _golden_response(DEFAULT_CASE_ID)
-
-
-@router.get("/case/{case_id}", response_model=CaseResponse)
-def get_case(case_id: str) -> CaseResponse:
-    if golden_exists(case_id):
-        return _golden_response(case_id)
-    loaded = RUNTIME.load_generated_run(case_id)
-    if loaded is not None:
-        public, run_id = loaded
-        return CaseResponse(case_id=public.id, run_id=run_id, case=public)
-    raise HTTPException(status_code=404, detail=f"case not found: {case_id}")
+"""Case lifecycle: create a new case (generate, or load by ID) and fetch a public view.
+
+New Case generates a fresh, solvable mystery via the in-process LLM (buffered one-ahead);
+if generation is unavailable (no weights / load failure) it falls back to the GRAYMOOR-3107
+golden case so the loop is always playable. Generated cases are persisted by Case ID, so a
+shared ID reloads the identical mystery. The sealed solution is never in any response here.
+"""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException
+
+from ..persistence.golden import golden_exists, load_golden
+from ..persistence.run_store import create_run
+from .dto import CaseResponse, NewCaseRequest
+from .public_view import golden_to_public
+from .runtime import RUNTIME
+
+router = APIRouter(prefix="/api", tags=["case"])
+
+DEFAULT_CASE_ID = "GRAYMOOR-3107"
+
+
+def _golden_response(case_id: str) -> CaseResponse:
+    run = create_run(case_id)
+    return CaseResponse(case_id=case_id, run_id=run.run_id, case=golden_to_public(load_golden(case_id)))
+
+
+@router.post("/case", response_model=CaseResponse)
+def new_case(req: NewCaseRequest) -> CaseResponse:
+    if req.case_id:
+        if golden_exists(req.case_id):
+            return _golden_response(req.case_id)
+        loaded = RUNTIME.load_generated_run(req.case_id)
+        if loaded is not None:
+            public, run_id = loaded
+            return CaseResponse(case_id=public.id, run_id=run_id, case=public)
+        return _golden_response(DEFAULT_CASE_ID)
+
+    # Exclusions are best-effort: the golden fallback below ignores them (it only
+    # triggers when the LLM runtime is unavailable, i.e. local dev, or total failure).
+    generated = RUNTIME.new_generated_run(exclude=req.exclude_case_ids[:300])
+    if generated is not None:
+        public, run_id = generated
+        return CaseResponse(case_id=public.id, run_id=run_id, case=public)
+    return _golden_response(DEFAULT_CASE_ID)
+
+
+@router.get("/case/{case_id}", response_model=CaseResponse)
+def get_case(case_id: str) -> CaseResponse:
+    if golden_exists(case_id):
+        return _golden_response(case_id)
+    loaded = RUNTIME.load_generated_run(case_id)
+    if loaded is not None:
+        public, run_id = loaded
+        return CaseResponse(case_id=public.id, run_id=run_id, case=public)
+    raise HTTPException(status_code=404, detail=f"case not found: {case_id}")

src/case_zero/api/runtime.py

@@ -1,319 +1,353 @@
-"""Live game runtime: lazily builds the in-process llama.cpp backend, generates cases,
-and holds live ``Session`` objects per run.
-
-Single-flight is MANDATORY: ``llama_cpp.Llama`` is not thread-safe, so every model call
-(generation + interrogation) runs under one lock - never concurrently, on any machine.
-
-Background case generation runs on EVERY box, but it can never make a player wait:
-each generation call holds the lock for just that one call (never the whole pipeline),
-and on a small box it streams with an interrupt check between tokens - the moment a
-player asks a question the in-flight generation aborts within a token, the lock frees,
-and the turn runs. Generation resumes once the table has been idle for a while. Fresh
-AI cases land in the buffer (served on the very next New Case) AND join the shuffled
-rotation, so the pool of mysteries grows for as long as the Space stays up.
-"""
-
-from __future__ import annotations
-
-import random
-import threading
-import time
-import uuid
-from collections.abc import Iterator
-from dataclasses import dataclass
-
-from ..config import effective_cpus, get_settings
-from ..engine.session import Session
-from ..generator.pipeline import generate_case
-from ..llm.backend import GenParams, LLMBackend, LLMError, make_backend
-from ..persistence.case_store import load_case, save_runtime_case
-from ..persistence.paths import prebaked_cases_dir, runtime_cases_dir
-from ..schemas.accusation import Accusation
-from ..schemas.case import CaseFile
-from ..schemas.enums import Relevance
-from .case_adapter import casefile_to_public
-from .public_view import PublicCase
-
-# How long the table must be quiet (no interrogation turn) before a small box starts -
-# or resumes - a background generation.
-_IDLE_SECS = 90.0
-
-
-class _SharedLockBackend:
-    """Per-call single-flight wrapper. Each model call holds the runtime lock for JUST
-    that call, so a player's turn waits behind at most one in-flight call - never a
-    whole multi-call generation. With an ``interrupt`` event the call streams internally
-    and aborts between tokens the moment a player shows up, freeing the lock at once."""
-
-    def __init__(self, inner: LLMBackend, lock: threading.Lock,
-                 interrupt: threading.Event | None = None) -> None:
-        self._inner = inner
-        self._lock = lock
-        self._interrupt = interrupt
-
-    def generate(self, prompt: str, params: GenParams) -> str:
-        with self._lock:
-            if self._interrupt is None:
-                return self._inner.generate(prompt, params)
-            if self._interrupt.is_set():
-                raise LLMError("generation interrupted by player")
-            parts: list[str] = []
-            for delta in self._inner.stream(prompt, params):
-                parts.append(delta)
-                if self._interrupt.is_set():
-                    raise LLMError("generation interrupted by player")
-            return "".join(parts)
-
-    def stream(self, prompt: str, params: GenParams) -> Iterator[str]:
-        with self._lock:
-            yield from self._inner.stream(prompt, params)
-
-
-@dataclass
-class LiveRun:
-    run_id: str
-    case: CaseFile
-    session: Session
-    public: PublicCase
-    baselines: dict[str, int]
-
-
-class GameRuntime:
-    def __init__(self) -> None:
-        self._lock = threading.Lock()  # MANDATORY single-flight over all model calls
-        self._backend: LLMBackend | None = None
-        self._backend_failed = False
-        self._runs: dict[str, LiveRun] = {}
-        self._buffer: CaseFile | None = None
-        self._buffer_lock = threading.Lock()
-        self._seed = int(time.time()) % 900_000 + 1000
-        self._rng = random.Random(self._seed)
-        # Pre-baked pool: full, model-authored cases shipped with the Space, served instantly
-        # on New Case so nobody waits ~2 min for live generation. Interrogation is still live.
-        self._prebaked: list[CaseFile] = []
-        self._prebaked_idx = 0
-        self._prebaked_loaded = False
-        # Background generation: a fast box generates immediately; a small box (the 2-vCPU
-        # Space) waits for an idle table and aborts between tokens when a player shows up.
-        self._fast_box = effective_cpus() > 4
-        self._gen_interrupt = threading.Event()
-        self._gen_running = False
-        self._gen_flag_lock = threading.Lock()
-        self._last_player_ts = 0.0
-
-    # ---- backend ----
-    def _get_backend(self) -> LLMBackend | None:
-        if self._backend is None and not self._backend_failed:
-            try:
-                self._backend = make_backend(get_settings())
-            except LLMError:
-                self._backend_failed = True
-        return self._backend
-
-    def available(self) -> bool:
-        return self._get_backend() is not None
-
-    def _next_seed(self) -> int:
-        self._seed += 1
-        return self._seed
-
-    # ---- generation ----
-    def _generate(self, seed: int, *, interruptible: bool = False) -> CaseFile:
-        backend = self._get_backend()
-        if backend is None:
-            raise LLMError("no backend")
-        wrapped = _SharedLockBackend(backend, self._lock,
-                                     self._gen_interrupt if interruptible else None)
-        result = generate_case(wrapped, seed=seed)
-        save_runtime_case(result.case)
-        return result.case
-
-    def _prebuild(self) -> None:
-        """Generate ONE fresh AI case in the background, yielding to players. On a small
-        box: wait until the table is idle, abort between tokens if a player interrupts,
-        then wait for idle again and retry. The finished case is served on the very next
-        New Case and joins the rotation for good."""
-        try:
-            for _ in range(8):
-                try:
-                    if not self._fast_box:
-                        while time.time() - self._last_player_ts < _IDLE_SECS:
-                            time.sleep(5)
-                    case = self._generate(self._next_seed(), interruptible=not self._fast_box)
-                except LLMError:
-                    continue  # interrupted by a player, or malformed output - try again
-                except Exception:
-                    break
-                with self._buffer_lock:
-                    self._buffer = case
-                self._prebaked.append(case)
-                break
-        finally:
-            with self._gen_flag_lock:
-                self._gen_running = False
-
-    def _spawn_gen(self) -> None:
-        if not self.available():
-            return
-        with self._gen_flag_lock:
-            if self._gen_running:
-                return
-            self._gen_running = True
-        threading.Thread(target=self._prebuild, daemon=True).start()
-
-    def _load_prebaked(self) -> None:
-        if self._prebaked_loaded:
-            return
-        self._prebaked_loaded = True
-        pool_dir = prebaked_cases_dir()
-        if not pool_dir.is_dir():
-            return
-        for path in sorted(pool_dir.glob("*.json")):
-            try:
-                self._prebaked.append(load_case(path))
-            except Exception:
-                continue
-        # Shuffle per process (the seed is time-based) so the FIRST case of every fresh
-        # visit/restart is randomized - never the same opening mystery twice in a row.
-        self._rng.shuffle(self._prebaked)
-
-    def start_buffer(self) -> None:
-        """Make the first New Case instant (shipped pool, shuffled) and start growing the
-        pool with a fresh AI-generated case in the background."""
-        self._load_prebaked()
-        self._spawn_gen()
-
-    def _take_buffered(self) -> CaseFile | None:
-        with self._buffer_lock:
-            case = self._buffer
-            self._buffer = None
-        return case
-
-    def _take_prebaked(self) -> CaseFile | None:
-        self._load_prebaked()
-        if not self._prebaked:
-            return None
-        if self._prebaked_idx >= len(self._prebaked):
-            # Bag exhausted: reshuffle for a fresh order on the next lap.
-            self._rng.shuffle(self._prebaked)
-            self._prebaked_idx = 0
-        case = self._prebaked[self._prebaked_idx]
-        self._prebaked_idx += 1
-        return case
-
-    def _maybe_refill(self) -> None:
-        """Keep one fresh AI case cooking in the background whenever the buffer is empty."""
-        if self._buffer is None:
-            self._spawn_gen()
-
-    def new_generated_run(self) -> tuple[PublicCase, str] | None:
-        if not self.available():
-            return None
-        # Prefer a freshly generated case if one is ready; else serve the pre-baked pool
-        # instantly; only with neither do we generate synchronously (first run, no pool).
-        case = self._take_buffered() or self._take_prebaked()
-        if case is None:
-            try:
-                case = self._generate(self._next_seed())
-            except Exception:
-                return None
-        self._maybe_refill()
-        return self._register(case)
-
-    def load_generated_run(self, case_id: str) -> tuple[PublicCase, str] | None:
-        if not self.available():
-            return None
-        self._load_prebaked()
-        case = next((c for c in self._prebaked if c.case_id == case_id), None)
-        if case is None:
-            for directory in (prebaked_cases_dir(), runtime_cases_dir()):
-                path = directory / f"{case_id}.json"
-                if path.exists():
-                    try:
-                        case = load_case(path)
-                    except Exception:
-                        case = None
-                    break
-        if case is None:
-            return None
-        return self._register(case)
-
-    def _register(self, case: CaseFile) -> tuple[PublicCase, str]:
-        public = casefile_to_public(case)
-        session = Session(case, self._get_backend())  # type: ignore[arg-type]
-        run_id = uuid.uuid4().hex
-        baselines = {s.id: s.baseline_suspicion for s in public.suspects}
-        self._runs[run_id] = LiveRun(run_id, case, session, public, baselines)
-        return public, run_id
-
-    def get(self, run_id: str) -> LiveRun | None:
-        return self._runs.get(run_id)
-
-    # ---- live turn / verdict ----
-    def _suspicion(self, run: LiveRun, sus_id: str) -> int:
-        st = run.session.state.state_for(sus_id)
-        base = run.baselines.get(sus_id, 25)
-        val = base + round(st.stress * 55) + (20 if st.broken_lie_ids else 0)
-        return max(0, min(100, val))
-
-    def interrogate_live(
-        self, run: LiveRun, sus_id: str, question: str, clue_id: str | None
-    ) -> dict:
-        prev = self._suspicion(run, sus_id)
-        # Tell any in-flight background generation to yield the lock NOW (it aborts
-        # between tokens), then take the table.
-        self._gen_interrupt.set()
-        self._last_player_ts = time.time()
-        with self._lock:
-            self._gen_interrupt.clear()
-            final = None
-            for ev in run.session.interrogate(sus_id, question, presented_clue_id=clue_id):
-                if ev.final is not None:
-                    final = ev.final
-        self._last_player_ts = time.time()
-        reply = final.turn.spoken if final else "…I have nothing to say to that."
-        after = self._suspicion(run, sus_id)
-        adj = final.adjudication if final else None
-        rattled = bool(adj and adj.relevance in (Relevance.DIRECT, Relevance.BREAKING))
-        cornered = bool(adj and adj.is_contradiction)
-        return {
-            "reply": reply,
-            "suspicionDelta": after - prev,
-            "suspicion": after,
-            "flags": {"rattled": rattled, "contradictionExposed": cornered, "cornered": cornered},
-        }
-
-    def accuse_live(self, run: LiveRun, suspect_id: str, motive_id: str, evidence_ids: list[str]) -> dict:
-        verdict = run.session.accuse(
-            Accusation(accused_sus_id=suspect_id, motive_id=motive_id, cited_clue_ids=tuple(evidence_ids))
-        )
-        culprit_id = run.case.culprit.sus_id
-        killer = run.case.suspect(culprit_id)
-        if verdict.culprit_correct:
-            truth = verdict.rationale or run.case.culprit.method_narrative
-        else:
-            accused = run.case.suspect(suspect_id).name if any(s.sus_id == suspect_id for s in run.case.suspects) else "the accused"
-            truth = (
-                f"You charged {accused}. The case held for a night - but the evidence led past "
-                f"them to {killer.name}, who walked out into the rain."
-            )
-        return {
-            "correct": verdict.culprit_correct,
-            "verdict": {
-                "stamp": "CASE CLOSED" if verdict.culprit_correct else "MISTRIAL",
-                "killerId": culprit_id,
-                "killerName": killer.name,
-                "truth": truth,
-            },
-            "score": {
-                "points": verdict.score,
-                "max": 100,
-                "killerCorrect": verdict.culprit_correct,
-                "motiveCorrect": verdict.motive_correct,
-                "evidenceHits": len(evidence_ids),
-            },
-            "stats": [],
-        }
-
-
-RUNTIME = GameRuntime()
+"""Live game runtime: lazily builds the in-process llama.cpp backend, generates cases,
+and holds live ``Session`` objects per run.
+
+Single-flight is MANDATORY: ``llama_cpp.Llama`` is not thread-safe, so every model call
+(generation + interrogation) runs under one lock - never concurrently, on any machine.
+
+Background case generation runs on EVERY box, but it can never make a player wait:
+each generation call holds the lock for just that one call (never the whole pipeline),
+and on a small box it streams with an interrupt check between tokens - the moment a
+player asks a question the in-flight generation aborts within a token, the lock frees,
+and the turn runs. Generation resumes once the table has been idle for a while. Fresh
+AI cases land in the buffer (served on the very next New Case) AND join the shuffled
+rotation, so the pool of mysteries grows for as long as the Space stays up.
+"""
+
+from __future__ import annotations
+
+import random
+import threading
+import time
+import uuid
+from collections.abc import Iterator, Sequence
+from dataclasses import dataclass
+
+from ..config import effective_cpus, get_settings
+from ..engine.session import Session
+from ..generator.pipeline import generate_case
+from ..llm.backend import GenParams, LLMBackend, LLMError, make_backend
+from ..persistence.case_store import load_case, save_runtime_case
+from ..persistence.paths import prebaked_cases_dir, runtime_cases_dir
+from ..schemas.accusation import Accusation
+from ..schemas.case import CaseFile
+from ..schemas.enums import Relevance
+from .case_adapter import casefile_to_public
+from .public_view import PublicCase
+
+# How long the table must be quiet (no interrogation turn) before a small box starts -
+# or resumes - a background generation.
+_IDLE_SECS = 90.0
+
+
+class _SharedLockBackend:
+    """Per-call single-flight wrapper. Each model call holds the runtime lock for JUST
+    that call, so a player's turn waits behind at most one in-flight call - never a
+    whole multi-call generation. With an ``interrupt`` event the call streams internally
+    and aborts between tokens the moment a player shows up, freeing the lock at once."""
+
+    def __init__(self, inner: LLMBackend, lock: threading.Lock,
+                 interrupt: threading.Event | None = None) -> None:
+        self._inner = inner
+        self._lock = lock
+        self._interrupt = interrupt
+
+    def generate(self, prompt: str, params: GenParams) -> str:
+        with self._lock:
+            if self._interrupt is None:
+                return self._inner.generate(prompt, params)
+            if self._interrupt.is_set():
+                raise LLMError("generation interrupted by player")
+            parts: list[str] = []
+            for delta in self._inner.stream(prompt, params):
+                parts.append(delta)
+                if self._interrupt.is_set():
+                    raise LLMError("generation interrupted by player")
+            return "".join(parts)
+
+    def stream(self, prompt: str, params: GenParams) -> Iterator[str]:
+        with self._lock:
+            yield from self._inner.stream(prompt, params)
+
+
+@dataclass
+class LiveRun:
+    run_id: str
+    case: CaseFile
+    session: Session
+    public: PublicCase
+    baselines: dict[str, int]
+
+
+class GameRuntime:
+    def __init__(self) -> None:
+        self._lock = threading.Lock()  # MANDATORY single-flight over all model calls
+        self._backend: LLMBackend | None = None
+        self._backend_failed = False
+        self._runs: dict[str, LiveRun] = {}
+        self._buffer: CaseFile | None = None
+        self._buffer_lock = threading.Lock()
+        self._seed = int(time.time()) % 900_000 + 1000
+        self._rng = random.Random(self._seed)
+        # Pre-baked pool: full, model-authored cases shipped with the Space, served instantly
+        # on New Case so nobody waits ~2 min for live generation. Interrogation is still live.
+        self._prebaked: list[CaseFile] = []
+        self._prebaked_idx = 0
+        self._prebaked_loaded = False
+        # Background generation: a fast box generates immediately; a small box (the 2-vCPU
+        # Space) waits for an idle table and aborts between tokens when a player shows up.
+        self._fast_box = effective_cpus() > 4
+        self._gen_interrupt = threading.Event()
+        self._gen_running = False
+        self._gen_flag_lock = threading.Lock()
+        self._last_player_ts = 0.0
+
+    # ---- backend ----
+    def _get_backend(self) -> LLMBackend | None:
+        if self._backend is None and not self._backend_failed:
+            try:
+                self._backend = make_backend(get_settings())
+            except LLMError:
+                self._backend_failed = True
+        return self._backend
+
+    def available(self) -> bool:
+        return self._get_backend() is not None
+
+    def _next_seed(self) -> int:
+        self._seed += 1
+        return self._seed
+
+    # ---- generation ----
+    def _generate(self, seed: int, *, interruptible: bool = False) -> CaseFile:
+        backend = self._get_backend()
+        if backend is None:
+            raise LLMError("no backend")
+        wrapped = _SharedLockBackend(backend, self._lock,
+                                     self._gen_interrupt if interruptible else None)
+        result = generate_case(wrapped, seed=seed)
+        save_runtime_case(result.case)
+        return result.case
+
+    def _prebuild(self) -> None:
+        """Generate ONE fresh AI case in the background, yielding to players. On a small
+        box: wait until the table is idle, abort between tokens if a player interrupts,
+        then wait for idle again and retry. The finished case is served on the very next
+        New Case and joins the rotation for good."""
+        try:
+            for _ in range(8):
+                try:
+                    if not self._fast_box:
+                        while time.time() - self._last_player_ts < _IDLE_SECS:
+                            time.sleep(5)
+                    case = self._generate(self._next_seed(), interruptible=not self._fast_box)
+                except LLMError:
+                    continue  # interrupted by a player, or malformed output - try again
+                except Exception:
+                    break
+                with self._buffer_lock:
+                    self._buffer = case
+                self._prebaked.append(case)
+                break
+        finally:
+            with self._gen_flag_lock:
+                self._gen_running = False
+
+    def _spawn_gen(self) -> None:
+        if not self.available():
+            return
+        with self._gen_flag_lock:
+            if self._gen_running:
+                return
+            self._gen_running = True
+        threading.Thread(target=self._prebuild, daemon=True).start()
+
+    def _load_prebaked(self) -> None:
+        if self._prebaked_loaded:
+            return
+        self._prebaked_loaded = True
+        seen: set[str] = set()
+        # Shipped pool first, then cases generated during previous runs of this Space
+        # (solver-validated at save time) - the pool keeps growing across restarts
+        # instead of resetting to the shipped set.
+        for pool_dir in (prebaked_cases_dir(), runtime_cases_dir()):
+            if not pool_dir.is_dir():
+                continue
+            for path in sorted(pool_dir.glob("*.json")):
+                try:
+                    case = load_case(path)
+                except Exception:
+                    continue
+                if case.case_id in seen:
+                    continue
+                seen.add(case.case_id)
+                self._prebaked.append(case)
+        # Shuffle per process (the seed is time-based) so the FIRST case of every fresh
+        # visit/restart is randomized - never the same opening mystery twice in a row.
+        self._rng.shuffle(self._prebaked)
+
+    def start_buffer(self) -> None:
+        """Make the first New Case instant (shipped pool, shuffled) and start growing the
+        pool with a fresh AI-generated case in the background."""
+        self._load_prebaked()
+        self._spawn_gen()
+
+    def _take_buffered(self, exclude: set[str] | None = None) -> CaseFile | None:
+        with self._buffer_lock:
+            case = self._buffer
+            if case is not None and exclude and case.case_id in exclude:
+                # This player has seen it - leave it buffered for someone who hasn't.
+                return None
+            self._buffer = None
+        return case
+
+    def _take_prebaked(self, exclude: set[str] | None = None) -> CaseFile | None:
+        self._load_prebaked()
+        if not self._prebaked:
+            return None
+        if exclude:
+            # Per-player filter: pick randomly among unplayed cases WITHOUT touching
+            # the shared rotation index (other players keep their rotation order).
+            candidates = [c for c in list(self._prebaked) if c.case_id not in exclude]
+            return self._rng.choice(candidates) if candidates else None
+        if self._prebaked_idx >= len(self._prebaked):
+            # Bag exhausted: reshuffle for a fresh order on the next lap.
+            self._rng.shuffle(self._prebaked)
+            self._prebaked_idx = 0
+        case = self._prebaked[self._prebaked_idx]
+        self._prebaked_idx += 1
+        return case
+
+    def _maybe_refill(self) -> None:
+        """Keep one fresh AI case cooking in the background whenever the buffer is empty."""
+        if self._buffer is None:
+            self._spawn_gen()
+
+    def new_generated_run(self, exclude: Sequence[str] = ()) -> tuple[PublicCase, str] | None:
+        """Deal a case this player hasn't started yet.
+
+        Ladder: buffered fresh case -> random unplayed pool case -> synchronous
+        generation (the Space has the model; the client shows its forming-a-case
+        screen) -> least-recently-played repeat (a repeat beats an error) -> None
+        (golden fallback upstream; LLM-less local dev only).
+        """
+        if not self.available():
+            return None
+        exclude_set = set(exclude)
+        # Heavy players drain their personal pool: keep generation ahead of them.
+        self._load_prebaked()
+        if exclude_set:
+            unplayed = sum(1 for c in list(self._prebaked) if c.case_id not in exclude_set)
+            if unplayed < 3:
+                self._spawn_gen()
+        case = self._take_buffered(exclude_set) or self._take_prebaked(exclude_set)
+        if case is None:
+            try:
+                case = self._generate(self._next_seed())
+            except Exception:
+                # Last resort: re-deal the LEAST recently played (client sends oldest
+                # first), rather than erroring out on a player who finished the pool.
+                for case_id in exclude:
+                    loaded = self.load_generated_run(case_id)
+                    if loaded is not None:
+                        return loaded
+                return None
+        self._maybe_refill()
+        return self._register(case)
+
+    def load_generated_run(self, case_id: str) -> tuple[PublicCase, str] | None:
+        if not self.available():
+            return None
+        self._load_prebaked()
+        case = next((c for c in self._prebaked if c.case_id == case_id), None)
+        if case is None:
+            for directory in (prebaked_cases_dir(), runtime_cases_dir()):
+                path = directory / f"{case_id}.json"
+                if path.exists():
+                    try:
+                        case = load_case(path)
+                    except Exception:
+                        case = None
+                    break
+        if case is None:
+            return None
+        return self._register(case)
+
+    def _register(self, case: CaseFile) -> tuple[PublicCase, str]:
+        public = casefile_to_public(case)
+        session = Session(case, self._get_backend())  # type: ignore[arg-type]
+        run_id = uuid.uuid4().hex
+        baselines = {s.id: s.baseline_suspicion for s in public.suspects}
+        self._runs[run_id] = LiveRun(run_id, case, session, public, baselines)
+        return public, run_id
+
+    def get(self, run_id: str) -> LiveRun | None:
+        return self._runs.get(run_id)
+
+    # ---- live turn / verdict ----
+    def _suspicion(self, run: LiveRun, sus_id: str) -> int:
+        st = run.session.state.state_for(sus_id)
+        base = run.baselines.get(sus_id, 25)
+        val = base + round(st.stress * 55) + (20 if st.broken_lie_ids else 0)
+        return max(0, min(100, val))
+
+    def interrogate_live(
+        self, run: LiveRun, sus_id: str, question: str, clue_id: str | None
+    ) -> dict:
+        prev = self._suspicion(run, sus_id)
+        # Tell any in-flight background generation to yield the lock NOW (it aborts
+        # between tokens), then take the table.
+        self._gen_interrupt.set()
+        self._last_player_ts = time.time()
+        with self._lock:
+            self._gen_interrupt.clear()
+            final = None
+            for ev in run.session.interrogate(sus_id, question, presented_clue_id=clue_id):
+                if ev.final is not None:
+                    final = ev.final
+        self._last_player_ts = time.time()
+        reply = final.turn.spoken if final else "…I have nothing to say to that."
+        after = self._suspicion(run, sus_id)
+        adj = final.adjudication if final else None
+        rattled = bool(adj and adj.relevance in (Relevance.DIRECT, Relevance.BREAKING))
+        cornered = bool(adj and adj.is_contradiction)
+        return {
+            "reply": reply,
+            "suspicionDelta": after - prev,
+            "suspicion": after,
+            "flags": {"rattled": rattled, "contradictionExposed": cornered, "cornered": cornered},
+        }
+
+    def accuse_live(self, run: LiveRun, suspect_id: str, motive_id: str, evidence_ids: list[str]) -> dict:
+        verdict = run.session.accuse(
+            Accusation(accused_sus_id=suspect_id, motive_id=motive_id, cited_clue_ids=tuple(evidence_ids))
+        )
+        culprit_id = run.case.culprit.sus_id
+        killer = run.case.suspect(culprit_id)
+        if verdict.culprit_correct:
+            truth = verdict.rationale or run.case.culprit.method_narrative
+        else:
+            accused = run.case.suspect(suspect_id).name if any(s.sus_id == suspect_id for s in run.case.suspects) else "the accused"
+            truth = (
+                f"You charged {accused}. The case held for a night - but the evidence led past "
+                f"them to {killer.name}, who walked out into the rain."
+            )
+        return {
+            "correct": verdict.culprit_correct,
+            "verdict": {
+                "stamp": "CASE CLOSED" if verdict.culprit_correct else "MISTRIAL",
+                "killerId": culprit_id,
+                "killerName": killer.name,
+                "truth": truth,
+            },
+            "score": {
+                "points": verdict.score,
+                "max": 100,
+                "killerCorrect": verdict.culprit_correct,
+                "motiveCorrect": verdict.motive_correct,
+                "evidenceHits": len(evidence_ids),
+            },
+            "stats": [],
+        }
+
+
+RUNTIME = GameRuntime()

src/case_zero/generator/crime_profiles.py

@@ -1,247 +1,372 @@
-"""Crime profiles: one frozen table that tells every layer how to talk about a case.
-
-The solver and engine are crime-agnostic - they only check structure (one culprit, a
-false alibi contradicted by discoverable evidence, innocents cleared). A profile maps a
-``CrimeKind`` to the words each layer needs: how the generator prompts the model, how
-the suspect brief states the culprit's deed, and how the dossier/verdict label the case.
-
-Field semantics are REUSED rather than renamed, so no schema churn:
-- ``victim``  = the wronged party (the deceased / the one robbed / the missing person);
-- ``weapon``  = the instrument or object of the crime (knife / stolen jewel / forged deed);
-- ``time_of_death`` = the moment of the incident;
-- ``cause_of_death`` = one line describing what happened to the victim.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from ..schemas.enums import CrimeKind
-
-
-@dataclass(frozen=True)
-class CrimeProfile:
-    kind: CrimeKind
-    # --- generator prompts ---
-    author_noun: str        # "murder mystery"
-    incident_noun: str      # "murder" - used in "during the {incident_noun}"
-    incident_line: str      # world prompt: what happened that evening
-    victim_ask: str         # world prompt: who the victim is + what cause_of_death holds
-    instrument_ask: str     # world prompt: what weapon_name/kind hold
-    deed_line: str          # mystery prompt: "{culprit} ... {victim} ... {room} ... {instrument}"
-    trace_ask: str          # mystery prompt: what the two breaker clues prove
-    # --- engine ---
-    brief_deed: str         # suspect brief, second person: "You killed {victim}."
-    confession_verbs: str   # extra regex alternatives for the confession scrubber
-    # --- display ---
-    perp_noun: str          # "killer"
-    division: str           # "HOMICIDE DIVISION"
-    victim_status: str      # dossier stamp: "DECEASED"
-    verdict: str            # KEY FACTS verdict line: "Homicide"
-    kind_label: str         # title screen: "A PROCEDURAL {kind_label}"
-    tod_label: str          # "T.O.D." vs "LAST SEEN" vs "INCIDENT"
-    found_verb: str         # "Found in" vs "Last seen in"
-    timeline_line: str      # "{name} is killed. Time of death."
-    boot_line: str          # boot screen: "A death no one saw coming."
-    fallback_titles: tuple[str, ...]
-
-
-_P = CrimeProfile
-
-PROFILES: dict[CrimeKind, CrimeProfile] = {
-    CrimeKind.HOMICIDE: _P(
-        kind=CrimeKind.HOMICIDE,
-        author_noun="murder mystery",
-        incident_noun="murder",
-        incident_line="The murder happened between {start} and {end} one evening.",
-        victim_ask="the victim (name, role, cause of death) and which room index (0-based) "
-                   "they were found in",
-        instrument_ask="the murder weapon (name, kind)",
-        deed_line="They murdered {victim} in the {room} with the {instrument} between "
-                  "{start} and {end}, then lied that they never left the {claimed}.",
-        trace_ask="quietly place {culprit} in the {room} during the murder",
-        brief_deed="You killed {victim}.",
-        confession_verbs=r"killed|murdered|stabbed|poisoned|strangled|shot|drowned|smothered",
-        perp_noun="killer",
-        division="HOMICIDE DIVISION",
-        victim_status="DECEASED",
-        verdict="Homicide",
-        kind_label="HOMICIDE",
-        tod_label="T.O.D.",
-        found_verb="Found in",
-        timeline_line="{name} is killed. Time of death.",
-        boot_line="A death no one saw coming.",
-        fallback_titles=(
-            "A Death in the {room}", "The {room} Affair", "Murder at {setting}",
-            "The {last} File", "Blood in the {room}", "Last Call at {setting}",
-            "The {setting} Killing", "The {room} Verdict",
-        ),
-    ),
-    CrimeKind.THEFT: _P(
-        kind=CrimeKind.THEFT,
-        author_noun="heist mystery - a prized object stolen from under everyone's nose",
-        incident_noun="theft",
-        incident_line="The theft happened between {start} and {end} one evening.",
-        victim_ask="the victim - the OWNER of what was stolen (name, role, and in "
-                   "cause_of_death one line on how they discovered the loss) and which room "
-                   "index (0-based) the theft happened in",
-        instrument_ask="the STOLEN OBJECT itself (name, kind) - one specific prized thing: "
-                       "a jewel, a painting, a rare manuscript, a strongbox",
-        deed_line="They stole the {instrument} from {victim}'s {room} between {start} and "
-                  "{end}, then lied that they never left the {claimed}.",
-        trace_ask="quietly place {culprit} in the {room} during the theft",
-        brief_deed="You stole the {instrument} from {victim}.",
-        confession_verbs=r"stole|robbed|took\s+the|lifted\s+the|pocketed",
-        perp_noun="thief",
-        division="ROBBERY DIVISION",
-        victim_status="ROBBED",
-        verdict="Grand Larceny",
-        kind_label="HEIST",
-        tod_label="TAKEN AT",
-        found_verb="Taken from",
-        timeline_line="The {instrument} vanishes from the {room}.",
-        boot_line="A theft no one saw happen.",
-        fallback_titles=(
-            "The Empty Case in the {room}", "The {setting} Job", "The {last} Collection",
-            "What Left the {room}", "The {setting} Take", "A Hole in the {room}",
-        ),
-    ),
-    CrimeKind.FRAUD: _P(
-        kind=CrimeKind.FRAUD,
-        author_noun="financial-fraud mystery - a swindle unravelling among people who "
-                    "trusted each other",
-        incident_noun="fraud",
-        incident_line="The decisive forged transaction was pushed through between {start} "
-                      "and {end} one evening.",
-        victim_ask="the victim - the person DEFRAUDED (name, role, and in cause_of_death "
-                   "one line on what they lost and how they found out) and which room index "
-                   "(0-based) the scheme was run from",
-        instrument_ask="the INSTRUMENT of the fraud (name, kind) - a forged deed, a doctored "
-                       "ledger, a fake certificate, a rigged contract",
-        deed_line="They defrauded {victim} using the {instrument}, working from the {room} "
-                  "between {start} and {end}, then lied that they never left the {claimed}.",
-        trace_ask="quietly place {culprit} in the {room} when the {instrument} was made",
-        brief_deed="You defrauded {victim} using the {instrument}.",
-        confession_verbs=r"forged|defrauded|swindled|scammed|embezzled|doctored\s+the",
-        perp_noun="fraudster",
-        division="FRAUD DIVISION",
-        victim_status="DEFRAUDED",
-        verdict="Fraud",
-        kind_label="SWINDLE",
-        tod_label="SIGNED AT",
-        found_verb="Uncovered in",
-        timeline_line="The {instrument} is signed in the {room}.",
-        boot_line="A fortune signed away in one evening.",
-        fallback_titles=(
-            "The {room} Signature", "The {setting} Accounts", "The {last} Trust",
-            "Ink in the {room}", "The Paper Fortune", "The {setting} Ledger",
-        ),
-    ),
-    CrimeKind.BLACKMAIL: _P(
-        kind=CrimeKind.BLACKMAIL,
-        author_noun="blackmail mystery - someone is being bled, and the extortionist sat "
-                    "at the same table",
-        incident_noun="blackmail drop",
-        incident_line="The latest blackmail demand was planted between {start} and {end} "
-                      "one evening.",
-        victim_ask="the victim - the person BLACKMAILED (name, role, and in cause_of_death "
-                   "one line on the demand and what it is costing them) and which room index "
-                   "(0-based) the demand was planted in",
-        instrument_ask="the LEVERAGE (name, kind) - compromising photographs, stolen letters, "
-                       "an incriminating ledger page",
-        deed_line="They are blackmailing {victim} with the {instrument}, and planted the "
-                  "demand in the {room} between {start} and {end}, then lied that they "
-                  "never left the {claimed}.",
-        trace_ask="quietly place {culprit} in the {room} when the demand was planted",
-        brief_deed="You are blackmailing {victim} with the {instrument}.",
-        confession_verbs=r"blackmailed|blackmailing|extorted|bled\s+(him|her|them)",
-        perp_noun="blackmailer",
-        division="EXTORTION UNIT",
-        victim_status="EXTORTED",
-        verdict="Extortion",
-        kind_label="EXTORTION",
-        tod_label="PLANTED AT",
-        found_verb="Planted in",
-        timeline_line="The demand is planted in the {room}.",
-        boot_line="An envelope no one will admit to leaving.",
-        fallback_titles=(
-            "The {room} Envelope", "The Price of {last}", "The {setting} Demand",
-            "Postage Due at {setting}", "The {room} Letters", "What {last} Pays For",
-        ),
-    ),
-    CrimeKind.ARSON: _P(
-        kind=CrimeKind.ARSON,
-        author_noun="arson mystery - a fire set by a familiar hand",
-        incident_noun="fire",
-        incident_line="The fire was set between {start} and {end} one evening.",
-        victim_ask="the victim - the person whose property BURNED (name, role, and in "
-                   "cause_of_death one line on what the fire took from them) and which room "
-                   "index (0-based) the fire started in",
-        instrument_ask="the MEANS of the fire (name, kind) - a kerosene tin, an oil lamp, "
-                       "a candle and curtains",
-        deed_line="They set the fire in {victim}'s {room} using the {instrument} between "
-                  "{start} and {end}, then lied that they never left the {claimed}.",
-        trace_ask="quietly place {culprit} in the {room} just before the fire started",
-        brief_deed="You set the fire in {victim}'s {room} using the {instrument}.",
-        confession_verbs=r"torched|set\s+the\s+fire|burned\s+it|lit\s+the|started\s+the\s+fire",
-        perp_noun="arsonist",
-        division="ARSON UNIT",
-        victim_status="BURNED OUT",
-        verdict="Arson",
-        kind_label="ARSON",
-        tod_label="IGNITED AT",
-        found_verb="Started in",
-        timeline_line="The fire starts in the {room}.",
-        boot_line="A fire that started exactly where it hurt most.",
-        fallback_titles=(
-            "The {room} Burn", "Ashes at {setting}", "The {last} Fire",
-            "What the {room} Kept", "Kindling at {setting}", "The {setting} Blaze",
-        ),
-    ),
-    CrimeKind.MISSING: _P(
-        kind=CrimeKind.MISSING,
-        author_noun="missing-person mystery - someone walked into a room and never walked out",
-        incident_noun="disappearance",
-        incident_line="The disappearance happened between {start} and {end} one evening.",
-        victim_ask="the victim - the person who VANISHED (name, role, and in cause_of_death "
-                   "one line on how their absence was noticed) and which room index (0-based) "
-                   "they were last seen in",
-        instrument_ask="the LURE (name, kind) - the thing used to draw them away: a forged "
-                       "note, a false telegram, a promised meeting",
-        deed_line="They are behind {victim}'s disappearance - they lured them from the {room} "
-                  "using the {instrument} between {start} and {end}, then lied that they "
-                  "never left the {claimed}.",
-        trace_ask="quietly place {culprit} in the {room} when {victim} was last seen",
-        brief_deed="You are behind {victim}'s disappearance; you lured them away with the "
-                   "{instrument}. {victim} is alive, but you must hide what you did.",
-        confession_verbs=r"abducted|kidnapped|lured\s+(him|her|them)|took\s+(him|her|them)",
-        perp_noun="abductor",
-        division="MISSING PERSONS",
-        victim_status="MISSING",
-        verdict="Missing Person",
-        kind_label="DISAPPEARANCE",
-        tod_label="LAST SEEN",
-        found_verb="Last seen in",
-        timeline_line="{name} is seen for the last time.",
-        boot_line="A chair still warm, and nobody in it.",
-        fallback_titles=(
-            "The Empty Chair in the {room}", "Where {last} Went", "The {setting} Absence",
-            "Last Seen in the {room}", "The {last} Vanishing", "Gone from {setting}",
-        ),
-    ),
-}
-
-# Weighted draw: homicide stays the backbone of a noir game; the rest add variety.
-_KIND_BAG: tuple[CrimeKind, ...] = (
-    CrimeKind.HOMICIDE, CrimeKind.HOMICIDE, CrimeKind.HOMICIDE,
-    CrimeKind.THEFT, CrimeKind.THEFT,
-    CrimeKind.FRAUD, CrimeKind.BLACKMAIL, CrimeKind.ARSON, CrimeKind.MISSING,
-)
-
-
-def profile_for(kind: CrimeKind | str) -> CrimeProfile:
-    return PROFILES[CrimeKind(kind)]
-
-
-def kind_for_seed(seed: int) -> CrimeKind:
-    return _KIND_BAG[seed % len(_KIND_BAG)]
+"""Crime profiles: one frozen table that tells every layer how to talk about a case.
+
+The solver and engine are crime-agnostic - they only check structure (one culprit, a
+false alibi contradicted by discoverable evidence, innocents cleared). A profile maps a
+``CrimeKind`` to the words each layer needs: how the generator prompts the model, how
+the suspect brief states the culprit's deed, and how the dossier/verdict label the case.
+
+Field semantics are REUSED rather than renamed, so no schema churn:
+- ``victim``  = the wronged party (the deceased / the one robbed / the missing person);
+- ``weapon``  = the instrument or object of the crime (knife / stolen jewel / forged deed);
+- ``time_of_death`` = the moment of the incident;
+- ``cause_of_death`` = one line describing what happened to the victim.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ..schemas.enums import CrimeKind
+
+
+@dataclass(frozen=True)
+class CrimeProfile:
+    kind: CrimeKind
+    # --- generator prompts ---
+    author_noun: str        # "murder mystery"
+    incident_noun: str      # "murder" - used in "during the {incident_noun}"
+    incident_line: str      # world prompt: what happened that evening
+    victim_ask: str         # world prompt: who the victim is + what cause_of_death holds
+    instrument_ask: str     # world prompt: what weapon_name/kind hold
+    deed_line: str          # mystery prompt: "{culprit} ... {victim} ... {room} ... {instrument}"
+    trace_ask: str          # mystery prompt: what the two breaker clues prove
+    # --- engine ---
+    brief_deed: str         # suspect brief, second person: "You killed {victim}."
+    confession_verbs: str   # extra regex alternatives for the confession scrubber
+    # --- display ---
+    perp_noun: str          # "killer"
+    division: str           # "HOMICIDE DIVISION"
+    victim_status: str      # dossier stamp: "DECEASED"
+    verdict: str            # KEY FACTS verdict line: "Homicide"
+    kind_label: str         # title screen: "A PROCEDURAL {kind_label}"
+    tod_label: str          # "T.O.D." vs "LAST SEEN" vs "INCIDENT"
+    found_verb: str         # "Found in" vs "Last seen in"
+    timeline_line: str      # "{name} is killed. Time of death."
+    boot_line: str          # boot screen: "A death no one saw coming."
+    fallback_titles: tuple[str, ...]
+
+
+_P = CrimeProfile
+
+PROFILES: dict[CrimeKind, CrimeProfile] = {
+    CrimeKind.HOMICIDE: _P(
+        kind=CrimeKind.HOMICIDE,
+        author_noun="murder mystery",
+        incident_noun="murder",
+        incident_line="The murder happened between {start} and {end} one evening.",
+        victim_ask="the victim (name, role, cause of death) and which room index (0-based) "
+                   "they were found in",
+        instrument_ask="the murder weapon (name, kind)",
+        deed_line="They murdered {victim} in the {room} with the {instrument} between "
+                  "{start} and {end}, then lied that they never left the {claimed}.",
+        trace_ask="quietly place {culprit} in the {room} during the murder",
+        brief_deed="You killed {victim}.",
+        confession_verbs=r"killed|murdered|stabbed|poisoned|strangled|shot|drowned|smothered",
+        perp_noun="killer",
+        division="HOMICIDE DIVISION",
+        victim_status="DECEASED",
+        verdict="Homicide",
+        kind_label="HOMICIDE",
+        tod_label="T.O.D.",
+        found_verb="Found in",
+        timeline_line="{name} is killed. Time of death.",
+        boot_line="A death no one saw coming.",
+        fallback_titles=(
+            "A Death in the {room}", "The {room} Affair", "Murder at {setting}",
+            "The {last} File", "Blood in the {room}", "Last Call at {setting}",
+            "The {setting} Killing", "The {room} Verdict",
+        ),
+    ),
+    CrimeKind.THEFT: _P(
+        kind=CrimeKind.THEFT,
+        author_noun="heist mystery - a prized object stolen from under everyone's nose",
+        incident_noun="theft",
+        incident_line="The theft happened between {start} and {end} one evening.",
+        victim_ask="the victim - the OWNER of what was stolen (name, role, and in "
+                   "cause_of_death one line on how they discovered the loss) and which room "
+                   "index (0-based) the theft happened in",
+        instrument_ask="the STOLEN OBJECT itself (name, kind) - one specific prized thing: "
+                       "a jewel, a painting, a rare manuscript, a strongbox",
+        deed_line="They stole the {instrument} from {victim}'s {room} between {start} and "
+                  "{end}, then lied that they never left the {claimed}.",
+        trace_ask="quietly place {culprit} in the {room} during the theft",
+        brief_deed="You stole the {instrument} from {victim}.",
+        confession_verbs=r"stole|robbed|took\s+the|lifted\s+the|pocketed",
+        perp_noun="thief",
+        division="ROBBERY DIVISION",
+        victim_status="ROBBED",
+        verdict="Grand Larceny",
+        kind_label="HEIST",
+        tod_label="TAKEN AT",
+        found_verb="Taken from",
+        timeline_line="The {instrument} vanishes from the {room}.",
+        boot_line="A theft no one saw happen.",
+        fallback_titles=(
+            "The Empty Case in the {room}", "The {setting} Job", "The {last} Collection",
+            "What Left the {room}", "The {setting} Take", "A Hole in the {room}",
+        ),
+    ),
+    CrimeKind.FRAUD: _P(
+        kind=CrimeKind.FRAUD,
+        author_noun="financial-fraud mystery - a swindle unravelling among people who "
+                    "trusted each other",
+        incident_noun="fraud",
+        incident_line="The decisive forged transaction was pushed through between {start} "
+                      "and {end} one evening.",
+        victim_ask="the victim - the person DEFRAUDED (name, role, and in cause_of_death "
+                   "one line on what they lost and how they found out) and which room index "
+                   "(0-based) the scheme was run from",
+        instrument_ask="the INSTRUMENT of the fraud (name, kind) - a forged deed, a doctored "
+                       "ledger, a fake certificate, a rigged contract",
+        deed_line="They defrauded {victim} using the {instrument}, working from the {room} "
+                  "between {start} and {end}, then lied that they never left the {claimed}.",
+        trace_ask="quietly place {culprit} in the {room} when the {instrument} was made",
+        brief_deed="You defrauded {victim} using the {instrument}.",
+        confession_verbs=r"forged|defrauded|swindled|scammed|embezzled|doctored\s+the",
+        perp_noun="fraudster",
+        division="FRAUD DIVISION",
+        victim_status="DEFRAUDED",
+        verdict="Fraud",
+        kind_label="SWINDLE",
+        tod_label="SIGNED AT",
+        found_verb="Uncovered in",
+        timeline_line="The {instrument} is signed in the {room}.",
+        boot_line="A fortune signed away in one evening.",
+        fallback_titles=(
+            "The {room} Signature", "The {setting} Accounts", "The {last} Trust",
+            "Ink in the {room}", "The Paper Fortune", "The {setting} Ledger",
+        ),
+    ),
+    CrimeKind.BLACKMAIL: _P(
+        kind=CrimeKind.BLACKMAIL,
+        author_noun="blackmail mystery - someone is being bled, and the extortionist sat "
+                    "at the same table",
+        incident_noun="blackmail drop",
+        incident_line="The latest blackmail demand was planted between {start} and {end} "
+                      "one evening.",
+        victim_ask="the victim - the person BLACKMAILED (name, role, and in cause_of_death "
+                   "one line on the demand and what it is costing them) and which room index "
+                   "(0-based) the demand was planted in",
+        instrument_ask="the LEVERAGE (name, kind) - compromising photographs, stolen letters, "
+                       "an incriminating ledger page",
+        deed_line="They are blackmailing {victim} with the {instrument}, and planted the "
+                  "demand in the {room} between {start} and {end}, then lied that they "
+                  "never left the {claimed}.",
+        trace_ask="quietly place {culprit} in the {room} when the demand was planted",
+        brief_deed="You are blackmailing {victim} with the {instrument}.",
+        confession_verbs=r"blackmailed|blackmailing|extorted|bled\s+(him|her|them)",
+        perp_noun="blackmailer",
+        division="EXTORTION UNIT",
+        victim_status="EXTORTED",
+        verdict="Extortion",
+        kind_label="EXTORTION",
+        tod_label="PLANTED AT",
+        found_verb="Planted in",
+        timeline_line="The demand is planted in the {room}.",
+        boot_line="An envelope no one will admit to leaving.",
+        fallback_titles=(
+            "The {room} Envelope", "The Price of {last}", "The {setting} Demand",
+            "Postage Due at {setting}", "The {room} Letters", "What {last} Pays For",
+        ),
+    ),
+    CrimeKind.ARSON: _P(
+        kind=CrimeKind.ARSON,
+        author_noun="arson mystery - a fire set by a familiar hand",
+        incident_noun="fire",
+        incident_line="The fire was set between {start} and {end} one evening.",
+        victim_ask="the victim - the person whose property BURNED (name, role, and in "
+                   "cause_of_death one line on what the fire took from them) and which room "
+                   "index (0-based) the fire started in",
+        instrument_ask="the MEANS of the fire (name, kind) - a kerosene tin, an oil lamp, "
+                       "a candle and curtains",
+        deed_line="They set the fire in {victim}'s {room} using the {instrument} between "
+                  "{start} and {end}, then lied that they never left the {claimed}.",
+        trace_ask="quietly place {culprit} in the {room} just before the fire started",
+        brief_deed="You set the fire in {victim}'s {room} using the {instrument}.",
+        confession_verbs=r"torched|set\s+the\s+fire|burned\s+it|lit\s+the|started\s+the\s+fire",
+        perp_noun="arsonist",
+        division="ARSON UNIT",
+        victim_status="BURNED OUT",
+        verdict="Arson",
+        kind_label="ARSON",
+        tod_label="IGNITED AT",
+        found_verb="Started in",
+        timeline_line="The fire starts in the {room}.",
+        boot_line="A fire that started exactly where it hurt most.",
+        fallback_titles=(
+            "The {room} Burn", "Ashes at {setting}", "The {last} Fire",
+            "What the {room} Kept", "Kindling at {setting}", "The {setting} Blaze",
+        ),
+    ),
+    CrimeKind.MISSING: _P(
+        kind=CrimeKind.MISSING,
+        author_noun="missing-person mystery - someone walked into a room and never walked out",
+        incident_noun="disappearance",
+        incident_line="The disappearance happened between {start} and {end} one evening.",
+        victim_ask="the victim - the person who VANISHED (name, role, and in cause_of_death "
+                   "one line on how their absence was noticed) and which room index (0-based) "
+                   "they were last seen in",
+        instrument_ask="the LURE (name, kind) - the thing used to draw them away: a forged "
+                       "note, a false telegram, a promised meeting",
+        deed_line="They are behind {victim}'s disappearance - they lured them from the {room} "
+                  "using the {instrument} between {start} and {end}, then lied that they "
+                  "never left the {claimed}.",
+        trace_ask="quietly place {culprit} in the {room} when {victim} was last seen",
+        brief_deed="You are behind {victim}'s disappearance; you lured them away with the "
+                   "{instrument}. {victim} is alive, but you must hide what you did.",
+        confession_verbs=r"abducted|kidnapped|lured\s+(him|her|them)|took\s+(him|her|them)",
+        perp_noun="abductor",
+        division="MISSING PERSONS",
+        victim_status="MISSING",
+        verdict="Missing Person",
+        kind_label="DISAPPEARANCE",
+        tod_label="LAST SEEN",
+        found_verb="Last seen in",
+        timeline_line="{name} is seen for the last time.",
+        boot_line="A chair still warm, and nobody in it.",
+        fallback_titles=(
+            "The Empty Chair in the {room}", "Where {last} Went", "The {setting} Absence",
+            "Last Seen in the {room}", "The {last} Vanishing", "Gone from {setting}",
+        ),
+    ),
+    CrimeKind.CON: _P(
+        kind=CrimeKind.CON,
+        author_noun="confidence-game mystery - a charming swindler emptied someone's "
+                    "savings through a venture that never existed",
+        incident_noun="swindle",
+        incident_line="The decisive payment of the swindle changed hands between {start} "
+                      "and {end} one evening.",
+        victim_ask="the victim - the person CONNED (name, role, and in cause_of_death "
+                   "one line on what they handed over and the moment they realized the "
+                   "venture was smoke) and which room index (0-based) the deal was closed in",
+        instrument_ask="the BAIT of the con (name, kind) - a false prospectus, fake share "
+                       "certificates, a salted mine sample, a counterfeit letter of credit",
+        deed_line="They conned {victim} out of a fortune using the {instrument}, closing "
+                  "the deal in the {room} between {start} and {end}, then lied that they "
+                  "never left the {claimed}.",
+        trace_ask="quietly place {culprit} in the {room} when the deal was closed",
+        brief_deed="You conned {victim} out of their savings using the {instrument}.",
+        confession_verbs=r"conned|swindled|fleeced|duped|took\s+(him|her|them)\s+for",
+        perp_noun="con artist",
+        division="BUNCO SQUAD",
+        victim_status="FLEECED",
+        verdict="Confidence Fraud",
+        kind_label="CON GAME",
+        tod_label="CLOSED AT",
+        found_verb="Closed in",
+        timeline_line="The deal is closed in the {room}.",
+        boot_line="A fortune handed over with a smile.",
+        fallback_titles=(
+            "The {room} Prospectus", "The {setting} Promise", "The {last} Venture",
+            "Paper Gold at {setting}", "The Long Game in the {room}", "The {setting} Pitch",
+        ),
+    ),
+    CrimeKind.POISONING: _P(
+        kind=CrimeKind.POISONING,
+        author_noun="poisoning mystery - a tainted glass passed at a familiar table",
+        incident_noun="poisoning",
+        incident_line="The poison was administered between {start} and {end} one evening.",
+        victim_ask="the victim (name, role, cause of death - what they drank or ate and "
+                   "how it took them) and which room index (0-based) they were stricken in",
+        instrument_ask="the VECTOR of the poison (name, kind) - a decanter, a teacup, a "
+                       "tonic bottle, a dessert plate",
+        deed_line="They poisoned {victim} via the {instrument} in the {room} between "
+                  "{start} and {end}, then lied that they never left the {claimed}.",
+        trace_ask="quietly place {culprit} near the {instrument} before {victim} was stricken",
+        brief_deed="You poisoned {victim}.",
+        confession_verbs=r"poisoned|dosed|laced|tainted|spiked",
+        perp_noun="poisoner",
+        division="TOXICOLOGY UNIT",
+        victim_status="POISONED",
+        verdict="Poisoning",
+        kind_label="POISONING",
+        tod_label="T.O.D.",
+        found_verb="Stricken in",
+        timeline_line="{name} is stricken. The glass is still warm.",
+        boot_line="A toast no one should have drunk.",
+        fallback_titles=(
+            "The Bitter Glass in the {room}", "The {setting} Toast", "The {last} Dose",
+            "What the Decanter Held", "Last Pour at {setting}", "The {room} Vintage",
+        ),
+    ),
+    CrimeKind.RANSOM: _P(
+        kind=CrimeKind.RANSOM,
+        author_noun="ransom mystery - someone was taken, and a demand was left where it "
+                    "would be found",
+        incident_noun="abduction",
+        incident_line="The abduction happened between {start} and {end} one evening.",
+        victim_ask="the victim - the person TAKEN (name, role, and in cause_of_death one "
+                   "line on how the ransom demand was discovered) and which room index "
+                   "(0-based) they were taken from",
+        instrument_ask="the RANSOM NOTE (name, kind) - cut letters, a typed card, a wax-"
+                       "sealed demand",
+        deed_line="They are behind {victim}'s abduction - they took them from the {room} "
+                  "and left the {instrument} between {start} and {end}, then lied that "
+                  "they never left the {claimed}.",
+        trace_ask="quietly place {culprit} in the {room} when {victim} was taken",
+        brief_deed="You took {victim} and left the {instrument}. {victim} is alive and "
+                   "unharmed, but you must hide what you did.",
+        confession_verbs=r"abducted|kidnapped|took\s+(him|her|them)|snatched|holding\s+(him|her|them)",
+        perp_noun="kidnapper",
+        division="RANSOM DETAIL",
+        victim_status="TAKEN",
+        verdict="Kidnapping",
+        kind_label="RANSOM",
+        tod_label="TAKEN AT",
+        found_verb="Taken from",
+        timeline_line="{name} is taken. The note is found.",
+        boot_line="An empty chair and a demand on the mantel.",
+        fallback_titles=(
+            "The {room} Demand", "The Price of {last}", "Taken from {setting}",
+            "The {setting} Note", "What the {room} Lost", "The {last} Exchange",
+        ),
+    ),
+    CrimeKind.SABOTAGE: _P(
+        kind=CrimeKind.SABOTAGE,
+        author_noun="sabotage mystery - machinery, a performance, or a life's work wrecked "
+                    "by a familiar hand",
+        incident_noun="sabotage",
+        incident_line="The sabotage was carried out between {start} and {end} one evening.",
+        victim_ask="the victim - the person whose WORK WAS WRECKED (name, role, and in "
+                   "cause_of_death one line on what failed and what it cost them) and which "
+                   "room index (0-based) the tampering happened in",
+        instrument_ask="the TAMPERED MECHANISM (name, kind) - a severed cable, a loosened "
+                       "valve, a doctored mixture, a cut harness",
+        deed_line="They sabotaged {victim}'s work - tampering with the {instrument} in the "
+                  "{room} between {start} and {end} - then lied that they never left the "
+                  "{claimed}.",
+        trace_ask="quietly place {culprit} in the {room} when the tampering was done",
+        brief_deed="You sabotaged {victim}'s work by tampering with the {instrument}. "
+                   "{victim} survived, but you must hide what you did.",
+        confession_verbs=r"sabotaged|tampered|rigged\s+it|cut\s+the|loosened\s+the|wrecked\s+it",
+        perp_noun="saboteur",
+        division="INCIDENT UNIT",
+        victim_status="RUINED",
+        verdict="Sabotage",
+        kind_label="SABOTAGE",
+        tod_label="FAILED AT",
+        found_verb="Tampered with in",
+        timeline_line="The {instrument} gives way in the {room}.",
+        boot_line="It did not break. It was broken.",
+        fallback_titles=(
+            "The {room} Failure", "What Gave Way at {setting}", "The {last} Collapse",
+            "A Loose Thread in the {room}", "The {setting} Incident", "Made to Fail",
+        ),
+    ),
+}
+
+# Weighted draw: homicide stays the backbone of a noir game; the rest add variety.
+_KIND_BAG: tuple[CrimeKind, ...] = (
+    CrimeKind.HOMICIDE, CrimeKind.HOMICIDE, CrimeKind.HOMICIDE,
+    CrimeKind.THEFT, CrimeKind.THEFT,
+    CrimeKind.FRAUD, CrimeKind.BLACKMAIL, CrimeKind.ARSON, CrimeKind.MISSING,
+    CrimeKind.CON, CrimeKind.POISONING, CrimeKind.RANSOM, CrimeKind.SABOTAGE,
+)
+
+
+def profile_for(kind: CrimeKind | str) -> CrimeProfile:
+    return PROFILES[CrimeKind(kind)]
+
+
+def kind_for_seed(seed: int) -> CrimeKind:
+    return _KIND_BAG[seed % len(_KIND_BAG)]

src/case_zero/schemas/enums.py

@@ -29,6 +29,10 @@ class CrimeKind(StrEnum):
     BLACKMAIL = "blackmail"
     ARSON = "arson"
     MISSING = "missing_person"
+    CON = "con"
+    POISONING = "poisoning"
+    RANSOM = "ransom"
+    SABOTAGE = "sabotage"
 
 
 class DiscoveryMethod(StrEnum):

tests/test_exhibits.py

@@ -0,0 +1,103 @@
+"""Rich-exhibit synthesis: every payload kind has the exact wire shape the client
+renders, and synthesized content never leaks sealed material."""
+
+from __future__ import annotations
+
+import json
+import re
+
+from test_case_adapter import _casefile
+
+from case_zero.api.case_adapter import casefile_to_public
+from case_zero.api.exhibits import synthesize_payload
+from case_zero.schemas.clue import Clue
+from case_zero.schemas.enums import DiscoveryMethod
+
+
+def _clue(case, name: str, reveal: str, method: DiscoveryMethod = DiscoveryMethod.SEARCH) -> Clue:
+    return Clue(
+        clue_id="C_t1",
+        name=name,
+        reveal_text=reveal,
+        discoverable_at_loc_id=case.setting.locations[0].loc_id,
+        discovery_method=method,
+    )
+
+
+def test_phone_thread_shape():
+    case = _casefile()
+    clue = _clue(case, "burner phone", "You can't announce it tonight. Meet me first.")
+    out = synthesize_payload(case, clue, "phone", 0, 21 * 60 + 30, "9:30 PM")
+    assert out["type"] == "PHONE"
+    msgs = out["thread"]
+    assert 3 <= len(msgs) <= 5
+    for m in msgs:
+        assert m.from_ in ("me", "them")
+        assert re.match(r"^\d{1,2}:\d{2}$", m.t)
+    # the climactic lines are the clue's own reveal text, split at sentence bounds
+    joined = " ".join(m.m for m in msgs)
+    assert "Meet me first." in joined
+    # nobody is named unless the reveal names them
+    assert all(m.who in ("UNKNOWN", "CRANE") for m in msgs)
+
+
+def test_phone_thread_names_only_verbatim_suspects():
+    case = _casefile()
+    clue = _clue(case, "message slip", "Miles Ardent never answered the last message.")
+    out = synthesize_payload(case, clue, "phone", 0, 21 * 60 + 30, "9:30 PM")
+    whos = {m.who for m in out["thread"]}
+    assert "ARDENT" in whos
+
+
+def test_voicemail_shape():
+    case = _casefile()
+    clue = _clue(case, "wax cylinder recording", "I heard them argue about the press.")
+    out = synthesize_payload(case, clue, "voicemail", 0, 21 * 60, "9:00 PM")
+    assert out["type"] == "AUDIO"
+    assert out["transcript"].startswith("“")
+    assert re.match(r"^0:\d{2}$", out["dur"])
+
+
+def test_keycard_rows_shape():
+    case = _casefile()
+    clue = _clue(case, "keycard log", "The service door opened twice after closing.")
+    out = synthesize_payload(case, clue, "keycard", 0, 21 * 60 + 41, "9:41 PM")
+    assert out["type"] == "DATA"
+    rows = out["rows"]
+    assert 2 <= len(rows) <= 6
+    assert all(len(r) == 4 for r in rows)
+    assert any(r[3] == "flag" for r in rows)
+    flag = next(r for r in rows if r[3] == "flag")
+    assert flag[2] == "UNREGISTERED"  # reveal names nobody
+    assert [r[0] for r in rows] == sorted(r[0] for r in rows)
+
+
+def test_cctv_and_photo_shapes():
+    case = _casefile()
+    cam = synthesize_payload(case, _clue(case, "cctv still", "A pale coat at the rail."), "cctv", 0, 0, "11:43 PM")
+    assert cam["type"] == "IMAGE" and cam["detail"].startswith("CAM —")
+    photo = synthesize_payload(case, _clue(case, "old photograph", "Two figures by the gate."), "photoEv", 2, 0, "9:00 PM")
+    assert photo["type"] == "IMAGE" and photo["icon"] == "photoEv" and "EVIDENCE MARKER 3" in photo["detail"]
+
+
+def test_forensic_in_situ_keeps_icon():
+    case = _casefile()
+    clue = _clue(case, "partial fingerprint", "A partial print on the latch.", DiscoveryMethod.FORENSIC)
+    out = synthesize_payload(case, clue, "fingerprint", 0, 0, "9:00 PM")
+    assert out["type"] == "IMAGE"
+    assert "icon" not in out  # the object icon stays
+
+
+def test_paper_fallthrough():
+    case = _casefile()
+    out = synthesize_payload(case, _clue(case, "pawn ticket", "A stub from the city den."), "receipt", 0, 0, "9:00 PM")
+    assert out == {}
+
+
+def test_synthesized_case_does_not_leak_sealed_material():
+    case = _casefile()
+    blob = json.dumps(casefile_to_public(case).model_dump(by_alias=True))
+    assert case.culprit.method_narrative not in blob
+    for s in case.suspects:
+        for secret in s.secrets:
+            assert secret not in blob

tests/test_runtime_pool.py

@@ -0,0 +1,86 @@
+"""Never-repeat pool logic: excluded case ids are never dealt, the shared rotation is
+untouched by per-player filtering, and the fallback ladder degrades gracefully."""
+
+from __future__ import annotations
+
+from test_case_adapter import _casefile
+
+from case_zero.api.runtime import GameRuntime
+
+
+def _pool(ids: list[str]):
+    base = _casefile()
+    return [base.model_copy(update={"case_id": cid}) for cid in ids]
+
+
+def _runtime_with(ids: list[str]) -> GameRuntime:
+    rt = GameRuntime()
+    rt._prebaked_loaded = True
+    rt._prebaked = _pool(ids)
+    return rt
+
+
+def test_rotation_unchanged_without_exclusions():
+    rt = _runtime_with(["A", "B", "C"])
+    dealt = [rt._take_prebaked().case_id for _ in range(3)]
+    assert dealt == ["A", "B", "C"]
+    assert rt._prebaked_idx == 3
+
+
+def test_excluded_ids_never_dealt_and_rotation_untouched():
+    rt = _runtime_with(["A", "B", "C"])
+    for _ in range(20):
+        case = rt._take_prebaked({"A", "C"})
+        assert case.case_id == "B"
+    assert rt._prebaked_idx == 0  # per-player picks never advance the shared rotation
+
+
+def test_all_excluded_returns_none():
+    rt = _runtime_with(["A", "B"])
+    assert rt._take_prebaked({"A", "B"}) is None
+
+
+def test_excluded_buffered_case_stays_buffered():
+    rt = _runtime_with(["A"])
+    buffered = _pool(["FRESH"])[0]
+    rt._buffer = buffered
+    assert rt._take_buffered({"FRESH"}) is None
+    assert rt._buffer is buffered  # still there for another player
+    assert rt._take_buffered(set()).case_id == "FRESH"
+    assert rt._buffer is None
+
+
+def test_pressure_heuristic_spawns_generation(monkeypatch):
+    rt = _runtime_with(["A", "B", "C"])
+    spawned = []
+    monkeypatch.setattr(rt, "available", lambda: True)
+    monkeypatch.setattr(rt, "_spawn_gen", lambda: spawned.append(1))
+    monkeypatch.setattr(rt, "_register", lambda case: (case.case_id, "run"))
+    monkeypatch.setattr(rt, "_maybe_refill", lambda: None)
+    # two of three already played -> fewer than 3 unplayed -> pressure spawn
+    out = rt.new_generated_run(exclude=["A", "B"])
+    assert out == ("C", "run")
+    assert spawned
+
+
+def test_lru_fallback_when_generation_fails(monkeypatch):
+    rt = _runtime_with(["A", "B"])
+    monkeypatch.setattr(rt, "available", lambda: True)
+    monkeypatch.setattr(rt, "_spawn_gen", lambda: None)
+    monkeypatch.setattr(rt, "_maybe_refill", lambda: None)
+
+    def boom(seed, **kw):
+        raise RuntimeError("no model")
+
+    monkeypatch.setattr(rt, "_generate", boom)
+    registered = []
+
+    def fake_load(case_id):
+        registered.append(case_id)
+        return (case_id, "run")
+
+    monkeypatch.setattr(rt, "load_generated_run", fake_load)
+    # everything played: generation fails -> oldest played id is re-dealt
+    out = rt.new_generated_run(exclude=["A", "B"])
+    assert out == ("A", "run")
+    assert registered == ["A"]

web/src/api.ts

@@ -1,71 +1,73 @@
-// Typed client for the Case Zero game API (served by gradio.Server under /api).
-import type { InterrogateResult, PublicCase, VerdictResult } from './types'
-
-export interface CaseResponse {
-  caseId: string
-  runId: string
-  case: PublicCase
-}
-
-async function postJSON<T>(url: string, body: unknown): Promise<T> {
-  const res = await fetch(url, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-  })
-  if (!res.ok) throw new Error(`POST ${url} failed: ${res.status}`)
-  return (await res.json()) as T
-}
-
-async function getJSON<T>(url: string): Promise<T> {
-  const res = await fetch(url)
-  if (!res.ok) throw new Error(`GET ${url} failed: ${res.status}`)
-  return (await res.json()) as T
-}
-
-export interface NewCaseRequest {
-  seed?: number
-  caseId?: string
-  difficulty?: string
-}
-
-export function newCase(req: NewCaseRequest = {}): Promise<CaseResponse> {
-  return postJSON<CaseResponse>('/api/case', req)
-}
-
-export function getCase(caseId: string): Promise<CaseResponse> {
-  return getJSON<CaseResponse>(`/api/case/${encodeURIComponent(caseId)}`)
-}
-
-export interface InterrogateBody {
-  questionId?: string
-  freeText?: string
-  presentEvidenceId?: string
-}
-
-export function interrogate(
-  runId: string,
-  suspectId: string,
-  body: InterrogateBody,
-): Promise<InterrogateResult> {
-  return postJSON<InterrogateResult>(
-    `/api/run/${encodeURIComponent(runId)}/interrogate/${encodeURIComponent(suspectId)}`,
-    body,
-  )
-}
-
-export function getHint(runId: string, screen: string): Promise<{ hint: string }> {
-  return getJSON<{ hint: string }>(
-    `/api/run/${encodeURIComponent(runId)}/hint?screen=${encodeURIComponent(screen)}`,
-  )
-}
-
-export interface AccuseBody {
-  suspectId: string
-  motiveId: string
-  evidenceIds: string[]
-}
-
-export function accuse(runId: string, body: AccuseBody): Promise<VerdictResult> {
-  return postJSON<VerdictResult>(`/api/run/${encodeURIComponent(runId)}/accuse`, body)
-}
+// Typed client for the Case Zero game API (served by gradio.Server under /api).
+import type { InterrogateResult, PublicCase, VerdictResult } from './types'
+
+export interface CaseResponse {
+  caseId: string
+  runId: string
+  case: PublicCase
+}
+
+async function postJSON<T>(url: string, body: unknown): Promise<T> {
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  })
+  if (!res.ok) throw new Error(`POST ${url} failed: ${res.status}`)
+  return (await res.json()) as T
+}
+
+async function getJSON<T>(url: string): Promise<T> {
+  const res = await fetch(url)
+  if (!res.ok) throw new Error(`GET ${url} failed: ${res.status}`)
+  return (await res.json()) as T
+}
+
+export interface NewCaseRequest {
+  seed?: number
+  caseId?: string
+  difficulty?: string
+  /** Case ids this player already started, oldest first — the server won't re-deal them. */
+  excludeCaseIds?: string[]
+}
+
+export function newCase(req: NewCaseRequest = {}): Promise<CaseResponse> {
+  return postJSON<CaseResponse>('/api/case', req)
+}
+
+export function getCase(caseId: string): Promise<CaseResponse> {
+  return getJSON<CaseResponse>(`/api/case/${encodeURIComponent(caseId)}`)
+}
+
+export interface InterrogateBody {
+  questionId?: string
+  freeText?: string
+  presentEvidenceId?: string
+}
+
+export function interrogate(
+  runId: string,
+  suspectId: string,
+  body: InterrogateBody,
+): Promise<InterrogateResult> {
+  return postJSON<InterrogateResult>(
+    `/api/run/${encodeURIComponent(runId)}/interrogate/${encodeURIComponent(suspectId)}`,
+    body,
+  )
+}
+
+export function getHint(runId: string, screen: string): Promise<{ hint: string }> {
+  return getJSON<{ hint: string }>(
+    `/api/run/${encodeURIComponent(runId)}/hint?screen=${encodeURIComponent(screen)}`,
+  )
+}
+
+export interface AccuseBody {
+  suspectId: string
+  motiveId: string
+  evidenceIds: string[]
+}
+
+export function accuse(runId: string, body: AccuseBody): Promise<VerdictResult> {
+  return postJSON<VerdictResult>(`/api/run/${encodeURIComponent(runId)}/accuse`, body)
+}

web/src/app.tsx

@@ -1,161 +1,172 @@
-// Root shell: loads the case from the server (or ?case=ID), then mounts the game.
-import { useEffect, useState } from 'preact/hooks'
-
-import { getCase, newCase } from './api'
-import { RainFX, prefersReducedMotion } from './engine/pixel'
-import { GameProvider, type Screen, useGame, useMode, useTweaks } from './store'
-import type { PublicCase } from './types'
-import { SCREENS } from './screens'
-import { TitleScreen } from './screens/cold'
-import { Assistant } from './ui/assistant'
-import { unlockAudioOnce } from './ui/audio'
-import { Btn } from './ui/components'
-
-const RAIN_SCREENS = new Set(['title', 'interro', 'briefing', 'verdict', 'flashback', 'story'])
-
-function ScreenHost() {
-  const g = useGame()
-  const Screen = SCREENS[g.state.screen] || TitleScreen
-  const t = g.state.tweaks
-  const showRain = t.rain && t.fx !== 'low' && !prefersReducedMotion() && RAIN_SCREENS.has(g.state.screen)
-  return (
-    <div class="app__stage">
-      <div class="app__frame">
-        <Screen key={g.state.screen} />
-        <div class="fx-layer fx-scanlines" />
-        <div class="fx-layer fx-vignette" />
-        <div class="fx-layer fx-flicker" />
-        {showRain && (
-          <div class="fx-layer">
-            <RainFX density={t.fx === 'high' ? 130 : 80} />
-          </div>
-        )}
-      </div>
-      <Assistant />
-    </div>
-  )
-}
-
-function Loading() {
-  const showRain = !prefersReducedMotion()
-  return (
-    <div class="app__stage">
-      <div class="app__frame" style={{ position: 'relative', background: 'var(--ink-0)' }}>
-        {showRain && (
-          <div class="fx-layer">
-            <RainFX density={80} />
-          </div>
-        )}
-        <div style={{ position: 'absolute', inset: 0, background: 'radial-gradient(80% 70% at 50% 45%, transparent 35%, rgba(8,11,16,.85) 100%)' }} />
-        <div class="screen-center" style={{ position: 'relative', zIndex: 2 }}>
-          <div class="col center" style={{ gap: 14, textAlign: 'center' }}>
-            <div class="t-label" style={{ letterSpacing: '.34em', color: 'var(--amber-2)' }}>CASE ZERO</div>
-            <div class="t-display" style={{ fontSize: 'clamp(18px,4vw,28px)', color: 'var(--bone-3)' }}>FORMING A CASE<span class="cursor" /></div>
-            <div class="t-mono dim" style={{ fontSize: 'calc(15px*var(--mono-scale))', maxWidth: 320 }}>The city, the body, the lies — coming together from the night wire.</div>
-          </div>
-        </div>
-        <div class="fx-layer fx-scanlines" />
-        <div class="fx-layer fx-vignette" />
-      </div>
-    </div>
-  )
-}
-
-function ErrorView({ msg, retry }: { msg: string; retry: () => void }) {
-  return (
-    <div class="app__stage">
-      <div class="app__frame">
-        <div class="screen-center">
-          <div class="panel panel--ox col center" style={{ gap: 14, maxWidth: 420, textAlign: 'center', padding: 24 }}>
-            <div class="t-display ox" style={{ fontSize: 14 }}>THE WIRE WENT DEAD</div>
-            <div class="t-body" style={{ color: 'var(--bone-2)' }}>{msg}</div>
-            <Btn variant="amber" onClick={retry}>Try again</Btn>
-          </div>
-        </div>
-      </div>
-    </div>
-  )
-}
-
-export function Root() {
-  const [data, setData] = useState<{ case: PublicCase; runId: string } | null>(null)
-  const [error, setError] = useState<string | null>(null)
-  const [startScreen, setStartScreen] = useState<Screen>('title')
-  const mode = useMode('auto')  // always responsive to the real viewport
-  const [tweaks, setTweak] = useTweaks()
-
-  useEffect(() => {
-    const r = document.documentElement
-    r.setAttribute('data-palette', tweaks.palette)
-    r.setAttribute('data-fonts', tweaks.fonts)
-    r.setAttribute('data-fx', tweaks.fx)
-    r.setAttribute('data-mood', tweaks.mood)
-    window.__pxScale = tweaks.pixelScale
-  }, [tweaks])
-
-  useEffect(unlockAudioOnce, []) // grant audio playback on first tap (mobile autoplay policy)
-
-  const load = () => {
-    setError(null)
-    setData(null)
-    setStartScreen('title')
-    const params = new URLSearchParams(window.location.search)
-    const cid = params.get('case')
-    const req = cid ? getCase(cid) : newCase()
-    req.then((r) => setData({ case: r.case, runId: r.runId })).catch((e) => setError(e instanceof Error ? e.message : String(e)))
-  }
-  useEffect(load, [])
-
-  // "Begin New Case" - always fetch a FRESH case from the server (never replay the loaded one)
-  // and start playing it. A shared ?case= is cleared so a refresh won't snap back to it.
-  const beginNewCase = () => {
-    setError(null)
-    setData(null)
-    setStartScreen('story')
-    const u = new URL(window.location.href)
-    if (u.searchParams.has('case')) {
-      u.searchParams.delete('case')
-      window.history.replaceState({}, '', u.pathname + u.search)
-    }
-    newCase()
-      .then((r) => setData({ case: r.case, runId: r.runId }))
-      .catch((e) => setError(e instanceof Error ? e.message : String(e)))
-  }
-
-  // "Enter Case ID" - load that exact case (fresh run) and jump straight into playing it.
-  const loadCaseById = (id: string) => {
-    const cid = id.trim()
-    if (!cid) return
-    setError(null)
-    setData(null)
-    setStartScreen('story')
-    const u = new URL(window.location.href)
-    u.searchParams.set('case', cid)
-    window.history.replaceState({}, '', u.pathname + u.search)
-    getCase(cid)
-      .then((r) => setData({ case: r.case, runId: r.runId }))
-      .catch((e) => setError(e instanceof Error ? e.message : String(e)))
-  }
-
-  if (error) {
-    return (
-      <div class="app" data-mode={mode}>
-        <ErrorView msg={error} retry={load} />
-      </div>
-    )
-  }
-  if (!data) {
-    return (
-      <div class="app" data-mode={mode}>
-        <Loading />
-      </div>
-    )
-  }
-  return (
-    <div class="app" data-mode={mode}>
-      <GameProvider key={data.runId} case={data.case} runId={data.runId} mode={mode} tweaks={tweaks} setTweak={setTweak} initialScreen={startScreen} newCase={beginNewCase} loadCase={loadCaseById}>
-        <ScreenHost />
-      </GameProvider>
-    </div>
-  )
-}
+// Root shell: loads the case from the server (or ?case=ID), then mounts the game.
+import { useEffect, useState } from 'preact/hooks'
+
+import { type CaseResponse, getCase, newCase } from './api'
+import { RainFX, prefersReducedMotion } from './engine/pixel'
+import { getCaseTheme, setCaseTheme, themeFromCase } from './engine/theme'
+import { getPlayed, markPlayed } from './played'
+import { GameProvider, type Screen, useGame, useMode, useTweaks } from './store'
+import type { PublicCase } from './types'
+import { SCREENS } from './screens'
+import { TitleScreen } from './screens/cold'
+import { Assistant } from './ui/assistant'
+import { unlockAudioOnce } from './ui/audio'
+import { Btn } from './ui/components'
+
+const RAIN_SCREENS = new Set(['title', 'interro', 'briefing', 'verdict', 'flashback', 'story'])
+
+function ScreenHost() {
+  const g = useGame()
+  const Screen = SCREENS[g.state.screen] || TitleScreen
+  const t = g.state.tweaks
+  const wet = ['rain', 'sleet'].includes(getCaseTheme().weather)
+  const showRain = wet && t.rain && t.fx !== 'low' && !prefersReducedMotion() && RAIN_SCREENS.has(g.state.screen)
+  return (
+    <div class="app__stage">
+      <div class="app__frame">
+        <Screen key={g.state.screen} />
+        <div class="fx-layer fx-scanlines" />
+        <div class="fx-layer fx-vignette" />
+        <div class="fx-layer fx-flicker" />
+        {showRain && (
+          <div class="fx-layer">
+            <RainFX density={t.fx === 'high' ? 130 : 80} />
+          </div>
+        )}
+      </div>
+      <Assistant />
+    </div>
+  )
+}
+
+function Loading() {
+  const showRain = !prefersReducedMotion()
+  return (
+    <div class="app__stage">
+      <div class="app__frame" style={{ position: 'relative', background: 'var(--ink-0)' }}>
+        {showRain && (
+          <div class="fx-layer">
+            <RainFX density={80} />
+          </div>
+        )}
+        <div style={{ position: 'absolute', inset: 0, background: 'radial-gradient(80% 70% at 50% 45%, transparent 35%, rgba(8,11,16,.85) 100%)' }} />
+        <div class="screen-center" style={{ position: 'relative', zIndex: 2 }}>
+          <div class="col center" style={{ gap: 14, textAlign: 'center' }}>
+            <div class="t-label" style={{ letterSpacing: '.34em', color: 'var(--amber-2)' }}>CASE ZERO</div>
+            <div class="t-display" style={{ fontSize: 'clamp(18px,4vw,28px)', color: 'var(--bone-3)' }}>FORMING A CASE<span class="cursor" /></div>
+            <div class="t-mono dim" style={{ fontSize: 'calc(15px*var(--mono-scale))', maxWidth: 320 }}>The city, the body, the lies — coming together from the night wire.</div>
+          </div>
+        </div>
+        <div class="fx-layer fx-scanlines" />
+        <div class="fx-layer fx-vignette" />
+      </div>
+    </div>
+  )
+}
+
+function ErrorView({ msg, retry }: { msg: string; retry: () => void }) {
+  return (
+    <div class="app__stage">
+      <div class="app__frame">
+        <div class="screen-center">
+          <div class="panel panel--ox col center" style={{ gap: 14, maxWidth: 420, textAlign: 'center', padding: 24 }}>
+            <div class="t-display ox" style={{ fontSize: 14 }}>THE WIRE WENT DEAD</div>
+            <div class="t-body" style={{ color: 'var(--bone-2)' }}>{msg}</div>
+            <Btn variant="amber" onClick={retry}>Try again</Btn>
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export function Root() {
+  const [data, setData] = useState<{ case: PublicCase; runId: string } | null>(null)
+  const [error, setError] = useState<string | null>(null)
+  const [startScreen, setStartScreen] = useState<Screen>('title')
+  const mode = useMode('auto')  // always responsive to the real viewport
+  const [tweaks, setTweak] = useTweaks()
+
+  useEffect(() => {
+    const r = document.documentElement
+    r.setAttribute('data-palette', tweaks.palette)
+    r.setAttribute('data-fonts', tweaks.fonts)
+    r.setAttribute('data-fx', tweaks.fx)
+    r.setAttribute('data-mood', tweaks.mood)
+    window.__pxScale = tweaks.pixelScale
+  }, [tweaks])
+
+  useEffect(unlockAudioOnce, []) // grant audio playback on first tap (mobile autoplay policy)
+
+  // Every path a case arrives through: set its visual theme and remember it as
+  // played (so New Case never deals this browser the same mystery again).
+  const apply = (r: CaseResponse) => {
+    setCaseTheme(themeFromCase(r.case))
+    markPlayed(r.case.id)
+    setData({ case: r.case, runId: r.runId })
+  }
+
+  const load = () => {
+    setError(null)
+    setData(null)
+    setStartScreen('title')
+    const params = new URLSearchParams(window.location.search)
+    const cid = params.get('case')
+    const req = cid ? getCase(cid) : newCase({ excludeCaseIds: getPlayed() })
+    req.then(apply).catch((e) => setError(e instanceof Error ? e.message : String(e)))
+  }
+  useEffect(load, [])
+
+  // "Begin New Case" - always fetch a FRESH case from the server (never replay the loaded one)
+  // and start playing it. A shared ?case= is cleared so a refresh won't snap back to it.
+  const beginNewCase = () => {
+    setError(null)
+    setData(null)
+    setStartScreen('story')
+    const u = new URL(window.location.href)
+    if (u.searchParams.has('case')) {
+      u.searchParams.delete('case')
+      window.history.replaceState({}, '', u.pathname + u.search)
+    }
+    newCase({ excludeCaseIds: getPlayed() })
+      .then(apply)
+      .catch((e) => setError(e instanceof Error ? e.message : String(e)))
+  }
+
+  // "Enter Case ID" - load that exact case (fresh run) and jump straight into playing it.
+  const loadCaseById = (id: string) => {
+    const cid = id.trim()
+    if (!cid) return
+    setError(null)
+    setData(null)
+    setStartScreen('story')
+    const u = new URL(window.location.href)
+    u.searchParams.set('case', cid)
+    window.history.replaceState({}, '', u.pathname + u.search)
+    getCase(cid)
+      .then(apply)
+      .catch((e) => setError(e instanceof Error ? e.message : String(e)))
+  }
+
+  if (error) {
+    return (
+      <div class="app" data-mode={mode}>
+        <ErrorView msg={error} retry={load} />
+      </div>
+    )
+  }
+  if (!data) {
+    return (
+      <div class="app" data-mode={mode}>
+        <Loading />
+      </div>
+    )
+  }
+  return (
+    <div class="app" data-mode={mode}>
+      <GameProvider key={data.runId} case={data.case} runId={data.runId} mode={mode} tweaks={tweaks} setTweak={setTweak} initialScreen={startScreen} newCase={beginNewCase} loadCase={loadCaseById}>
+        <ScreenHost />
+      </GameProvider>
+    </div>
+  )
+}

web/src/engine/art.ts

@@ -4,6 +4,7 @@
 import { BAYER4, ditherGrad } from './draw'
 import type { Pal } from './draw'
 import type { ScenePainter } from './pixel'
+import { getCaseTheme } from './theme'
 
 type Grid = string[][]
 interface Sprite {
@@ -236,29 +237,39 @@ export const BODIES: Record<string, Sprite> = {
 }
 
 // Gender-matched fallback casts for generated suspects (named portraits are golden-only).
-// A female suspect always draws a female portrait/body; a male suspect a male one.
-const _M_PORTRAITS: Sprite[] = [
-  PORTRAITS.wexler, PORTRAITS.teo,
-  makePortrait({ skin: SPAL['6'], skinS: SPAL['7'], hair: SPAL.h, hairHl: SPAL.H, style: 'curly', cloth: SPAL.t, clothHl: SPAL.T, accent: SPAL.i }),
-  makePortrait({ skin: SPAL['1'], skinS: SPAL['2'], hair: SPAL.r, hairHl: SPAL.R, style: 'bald', cloth: SPAL.g, clothHl: SPAL.G, accent: SPAL.M, beard: '#5a4030' }),
-  makePortrait({ skin: SPAL['4'], skinS: SPAL['5'], hair: SPAL.y, hairHl: SPAL.Y, style: 'short', cloth: SPAL.m, clothHl: SPAL.M, accent: SPAL.n, stubble: true }),
+// Kept as OPTION sets so a per-case accent color can re-dress the same face; the base
+// sprites (no accent) are prebuilt and identical to the original pools.
+const _M_PORTRAIT_OPTS: PortraitOpts[] = [
+  { skin: SPAL['1'], skinS: SPAL['2'], hair: SPAL.y, hairHl: SPAL.Y, style: 'slick', cloth: SPAL.m, clothHl: SPAL.M, accent: SPAL.i, tie: SPAL.x, beard: '#7d7c72', stubble: true },
+  { skin: SPAL['6'], skinS: SPAL['7'], hair: SPAL.h, hairHl: SPAL.H, style: 'short', cloth: SPAL.g, clothHl: SPAL.G, accent: SPAL.M, stubble: true },
+  { skin: SPAL['6'], skinS: SPAL['7'], hair: SPAL.h, hairHl: SPAL.H, style: 'curly', cloth: SPAL.t, clothHl: SPAL.T, accent: SPAL.i },
+  { skin: SPAL['1'], skinS: SPAL['2'], hair: SPAL.r, hairHl: SPAL.R, style: 'bald', cloth: SPAL.g, clothHl: SPAL.G, accent: SPAL.M, beard: '#5a4030' },
+  { skin: SPAL['4'], skinS: SPAL['5'], hair: SPAL.y, hairHl: SPAL.Y, style: 'short', cloth: SPAL.m, clothHl: SPAL.M, accent: SPAL.n, stubble: true },
 ]
-const _F_PORTRAITS: Sprite[] = [
-  PORTRAITS.iris, PORTRAITS.frost,
-  makePortrait({ skin: SPAL['6'], skinS: SPAL['7'], hair: SPAL.h, hairHl: SPAL.H, style: 'bun', cloth: SPAL.x, clothHl: SPAL.X, accent: SPAL.i, lip: SPAL.p }),
-  makePortrait({ skin: SPAL['1'], skinS: SPAL['2'], hair: SPAL.r, hairHl: SPAL.R, style: 'curly', cloth: SPAL.t, clothHl: SPAL.T, accent: SPAL.n, lip: SPAL.p }),
-  makePortrait({ skin: SPAL['4'], skinS: SPAL['5'], hair: SPAL.u, hairHl: SPAL.U, style: 'wave', cloth: SPAL.w, clothHl: SPAL.W, accent: SPAL.t, lip: SPAL.p }),
+const _F_PORTRAIT_OPTS: PortraitOpts[] = [
+  { skin: SPAL['4'], skinS: SPAL['5'], hair: SPAL.u, hairHl: SPAL.U, style: 'long', cloth: SPAL.w, clothHl: SPAL.W, accent: SPAL.t, lip: SPAL.p },
+  { skin: SPAL['1'], skinS: SPAL['2'], hair: SPAL.y, hairHl: SPAL.Y, style: 'wave', cloth: SPAL.t, clothHl: SPAL.T, accent: SPAL.i, glasses: SPAL.g, lip: SPAL.p },
+  { skin: SPAL['6'], skinS: SPAL['7'], hair: SPAL.h, hairHl: SPAL.H, style: 'bun', cloth: SPAL.x, clothHl: SPAL.X, accent: SPAL.i, lip: SPAL.p },
+  { skin: SPAL['1'], skinS: SPAL['2'], hair: SPAL.r, hairHl: SPAL.R, style: 'curly', cloth: SPAL.t, clothHl: SPAL.T, accent: SPAL.n, lip: SPAL.p },
+  { skin: SPAL['4'], skinS: SPAL['5'], hair: SPAL.u, hairHl: SPAL.U, style: 'wave', cloth: SPAL.w, clothHl: SPAL.W, accent: SPAL.t, lip: SPAL.p },
 ]
-const _M_BODIES: Sprite[] = [
-  BODIES.wexler, BODIES.teo,
-  makeBody({ skin: SPAL['6'], skinS: SPAL['7'], hair: SPAL.h, hairHl: SPAL.H, style: 'short', cloth: SPAL.t, clothHl: SPAL.T, accent: SPAL.i, legs: SPAL.m }),
-  makeBody({ skin: SPAL['1'], skinS: SPAL['2'], hair: SPAL.r, hairHl: SPAL.R, style: 'short', cloth: SPAL.g, clothHl: SPAL.G, accent: SPAL.M, legs: SPAL.m, beard: '#5a4030' }),
+const _M_BODY_OPTS: PortraitOpts[] = [
+  { skin: SPAL['1'], skinS: SPAL['2'], hair: SPAL.y, hairHl: SPAL.Y, style: 'slick', cloth: SPAL.m, clothHl: SPAL.M, accent: SPAL.i, tie: SPAL.x, beard: '#7d7c72' },
+  { skin: SPAL['6'], skinS: SPAL['7'], hair: SPAL.h, hairHl: SPAL.H, style: 'short', cloth: SPAL.g, clothHl: SPAL.G, accent: SPAL.M, legs: SPAL.m },
+  { skin: SPAL['6'], skinS: SPAL['7'], hair: SPAL.h, hairHl: SPAL.H, style: 'short', cloth: SPAL.t, clothHl: SPAL.T, accent: SPAL.i, legs: SPAL.m },
+  { skin: SPAL['1'], skinS: SPAL['2'], hair: SPAL.r, hairHl: SPAL.R, style: 'short', cloth: SPAL.g, clothHl: SPAL.G, accent: SPAL.M, legs: SPAL.m, beard: '#5a4030' },
 ]
-const _F_BODIES: Sprite[] = [
-  BODIES.iris, BODIES.frost,
-  makeBody({ skin: SPAL['6'], skinS: SPAL['7'], hair: SPAL.h, hairHl: SPAL.H, style: 'long', cloth: SPAL.x, clothHl: SPAL.X, accent: SPAL.i, lip: SPAL.p }),
-  makeBody({ skin: SPAL['4'], skinS: SPAL['5'], hair: SPAL.u, hairHl: SPAL.U, style: 'long', cloth: SPAL.t, clothHl: SPAL.T, accent: SPAL.n, lip: SPAL.p }),
+const _F_BODY_OPTS: PortraitOpts[] = [
+  { skin: SPAL['4'], skinS: SPAL['5'], hair: SPAL.u, hairHl: SPAL.U, style: 'long', cloth: SPAL.w, clothHl: SPAL.W, accent: SPAL.t, lip: SPAL.p },
+  { skin: SPAL['1'], skinS: SPAL['2'], hair: SPAL.y, hairHl: SPAL.Y, style: 'wave', cloth: SPAL.t, clothHl: SPAL.T, accent: SPAL.i, glasses: SPAL.g, lip: SPAL.p },
+  { skin: SPAL['6'], skinS: SPAL['7'], hair: SPAL.h, hairHl: SPAL.H, style: 'long', cloth: SPAL.x, clothHl: SPAL.X, accent: SPAL.i, lip: SPAL.p },
+  { skin: SPAL['4'], skinS: SPAL['5'], hair: SPAL.u, hairHl: SPAL.U, style: 'long', cloth: SPAL.t, clothHl: SPAL.T, accent: SPAL.n, lip: SPAL.p },
 ]
+const _M_PORTRAITS: Sprite[] = _M_PORTRAIT_OPTS.map((o) => makePortrait(o))
+const _F_PORTRAITS: Sprite[] = _F_PORTRAIT_OPTS.map((o) => makePortrait(o))
+const _M_BODIES: Sprite[] = _M_BODY_OPTS.map((o) => makeBody(o))
+const _F_BODIES: Sprite[] = _F_BODY_OPTS.map((o) => makeBody(o))
+
 function _hash(s: string): number {
   let h = 0
   for (let i = 0; i < s.length; i++) h = (h * 31 + s.charCodeAt(i)) >>> 0
@@ -267,15 +278,34 @@ function _hash(s: string): number {
 function _isFemale(gender?: string): boolean {
   return (gender || '').toLowerCase().startsWith('f')
 }
-export function portraitFor(id: string, gender?: string): Sprite {
+
+// Accent-recolored sprites are memoized: one rebuild per (face, accent) pair ever.
+const _accentCache = new Map<string, Sprite>()
+function _accented(kind: 'p' | 'b', female: boolean, idx: number, accent: string): Sprite {
+  const key = `${kind}:${female ? 'f' : 'm'}:${idx}:${accent}`
+  let s = _accentCache.get(key)
+  if (!s) {
+    const opts = kind === 'p' ? (female ? _F_PORTRAIT_OPTS : _M_PORTRAIT_OPTS) : (female ? _F_BODY_OPTS : _M_BODY_OPTS)
+    const o = { ...opts[idx], accent, tie: accent }
+    s = kind === 'p' ? makePortrait(o) : makeBody(o)
+    _accentCache.set(key, s)
+  }
+  return s
+}
+
+export function portraitFor(id: string, gender?: string, accent?: string): Sprite {
   if (PORTRAITS[id]) return PORTRAITS[id]
-  const pool = _isFemale(gender) ? _F_PORTRAITS : _M_PORTRAITS
-  return pool[_hash(id) % pool.length]
+  const female = _isFemale(gender)
+  const pool = female ? _F_PORTRAITS : _M_PORTRAITS
+  const idx = _hash(id) % pool.length
+  return accent ? _accented('p', female, idx, accent) : pool[idx]
 }
-export function bodyFor(id: string, gender?: string): Sprite {
+export function bodyFor(id: string, gender?: string, accent?: string): Sprite {
   if (BODIES[id]) return BODIES[id]
-  const pool = _isFemale(gender) ? _F_BODIES : _M_BODIES
-  return pool[_hash(id) % pool.length]
+  const female = _isFemale(gender)
+  const pool = female ? _F_BODIES : _M_BODIES
+  const idx = _hash(id) % pool.length
+  return accent ? _accented('b', female, idx, accent) : pool[idx]
 }
 
 export const IPAL: Record<string, string> = {
@@ -334,7 +364,21 @@ function lampCone(ctx: CanvasRenderingContext2D, cx: number, cy: number, w: numb
   }
   ctx.globalAlpha = 1
 }
+// Weather-aware: every painter that calls this automatically honors the case's
+// weather — fog and dry nights get no streaks, sleet falls in slanted steps.
 function rainStreaks(ctx: CanvasRenderingContext2D, w: number, h: number, t: number): void {
+  const wk = getCaseTheme().weather
+  if (wk === 'fog' || wk === 'dry') return
+  if (wk === 'sleet') {
+    ctx.fillStyle = 'rgba(195,205,215,0.24)'
+    for (let i = 0; i < 30; i++) {
+      const x = (i * 43 + t * 5) % w
+      const y = (i * 53 + t * 7) % h
+      ctx.fillRect(Math.floor(x), Math.floor(y), 1, 2)
+      ctx.fillRect(Math.floor(x) + 1, Math.floor(y) + 2, 1, 2)
+    }
+    return
+  }
   ctx.fillStyle = 'rgba(170,190,200,0.22)'
   for (let i = 0; i < 40; i++) {
     const x = (i * 37 + t * 4) % w
@@ -343,7 +387,7 @@ function rainStreaks(ctx: CanvasRenderingContext2D, w: number, h: number, t: num
   }
 }
 
-const paintSkyline: ScenePainter = (ctx, w, h) => {
+const paintSkyline: ScenePainter = (ctx, w, h, _t, seed = 0) => {
   const horizon = Math.floor(h * 0.5)
   ditherGrad(ctx, 0, 0, w, horizon, C.sky2, C.sky1)
   for (let y = horizon - 22; y < horizon; y++) {
@@ -355,25 +399,26 @@ const paintSkyline: ScenePainter = (ctx, w, h) => {
   }
   ditherGrad(ctx, 0, horizon, w, h - horizon, '#0c1620', '#0a121a')
   const dist = [[0.0, 0.16, 0.09], [0.08, 0.28, 0.07], [0.14, 0.18, 0.1], [0.23, 0.34, 0.08], [0.31, 0.22, 0.1], [0.4, 0.4, 0.09], [0.49, 0.2, 0.11], [0.58, 0.3, 0.09], [0.66, 0.24, 0.1], [0.75, 0.38, 0.08], [0.83, 0.2, 0.1], [0.91, 0.28, 0.1]]
+  let bi = 0
   for (const [bx, bh, bw] of dist) {
     const x = Math.floor(bx * w)
-    const bht = Math.floor(bh * h * 0.44)
+    const bht = Math.floor(bh * h * 0.44) + ((seed >> (bi++ % 8)) & 3)
     const wd = Math.ceil(bw * w)
     ctx.fillStyle = '#0a121a'; ctx.fillRect(x, horizon - bht, wd, bht)
     ctx.fillStyle = C.bldgL; ctx.fillRect(x, horizon - bht, 1, bht)
     for (let wy = horizon - bht + 3; wy < horizon - 2; wy += 5)
-      for (let wx = x + 2; wx < x + wd - 2; wx += 4) { ctx.fillStyle = (wx + wy) % 3 ? C.winDim : C.win; ctx.fillRect(wx, wy, 2, 2) }
+      for (let wx = x + 2; wx < x + wd - 2; wx += 4) { ctx.fillStyle = (wx + wy + seed) % 3 ? C.winDim : C.win; ctx.fillRect(wx, wy, 2, 2) }
   }
   const fg = [[0.0, 0.4, 0.16], [0.15, 0.3, 0.13], [0.27, 0.52, 0.15], [0.41, 0.34, 0.12], [0.52, 0.46, 0.16], [0.67, 0.3, 0.14], [0.8, 0.5, 0.2]]
   for (const [bx, bh, bw] of fg) {
     const x = Math.floor(bx * w)
     const wd = Math.ceil(bw * w)
-    const topY = Math.floor(h * (0.5 + (1 - bh) * 0.22))
+    const topY = Math.floor(h * (0.5 + (1 - bh) * 0.22)) + ((seed >> (bi++ % 8)) & 3)
     ctx.fillStyle = '#070d13'; ctx.fillRect(x, topY, wd, h - topY)
     ctx.fillStyle = '#0e1a24'; ctx.fillRect(x, topY, wd, 2)
     ctx.fillStyle = '#10202b'; ctx.fillRect(x, topY, 1, h - topY)
     for (let wy = topY + 5; wy < h - 3; wy += 8)
-      for (let wx = x + 3; wx < x + wd - 4; wx += 8) { const lit = (wx * 3 + wy) % 5; ctx.fillStyle = lit === 0 ? C.amber : lit === 1 ? C.win : '#0c151d'; ctx.fillRect(wx, wy, 3, 4) }
+      for (let wx = x + 3; wx < x + wd - 4; wx += 8) { const lit = (wx * 3 + wy + seed) % 5; ctx.fillStyle = lit === 0 ? C.amber : lit === 1 ? C.win : '#0c151d'; ctx.fillRect(wx, wy, 3, 4) }
   }
 }
 
@@ -527,13 +572,13 @@ const paintKitchen: ScenePainter = (ctx, w, h, t) => {
   rainStreaks(ctx, w, h * 0.4, t)
 }
 
-const paintStudy: ScenePainter = (ctx, w, h) => {
+const paintStudy: ScenePainter = (ctx, w, h, _t, seed = 0) => {
   ditherGrad(ctx, 0, 0, w, h, C.sky2, C.sky0)
   const shelf = (sx: number, sw: number) => {
     ctx.fillStyle = _WOOD; ctx.fillRect(sx, 12, sw, h - 40)
     for (let sy = 18; sy < h - 34; sy += 16) {
       ctx.fillStyle = '#241a10'; ctx.fillRect(sx + 2, sy + 12, sw - 4, 3)
-      for (let bx = sx + 3; bx < sx + sw - 3; bx += 3) { ctx.fillStyle = _BOOK[(bx + sy) % _BOOK.length]; ctx.fillRect(bx, sy, 2, 12) }
+      for (let bx = sx + 3; bx < sx + sw - 3; bx += 3) { ctx.fillStyle = _BOOK[(bx + sy + seed) % _BOOK.length]; ctx.fillRect(bx, sy, 2, 12) }
     }
   }
   shelf(8, Math.floor(w * 0.34))
@@ -549,22 +594,26 @@ const paintStudy: ScenePainter = (ctx, w, h) => {
   ctx.fillStyle = C.ox; ctx.fillRect(lx + 12, dy - 3, 3, 3)
 }
 
-const paintParlor: ScenePainter = (ctx, w, h, t) => {
+const paintParlor: ScenePainter = (ctx, w, h, t, seed = 0) => {
   ditherGrad(ctx, 0, 0, w, h, C.sky2, C.sky0)
   ctx.fillStyle = C.bldgL; ctx.fillRect(0, Math.floor(h * 0.55), w, 2)
-  const fx = 12
+  // fireplace flips sides per case; the painting takes the opposite wall
+  const flip = (seed & 1) === 1
+  const fx = flip ? w - 52 : 12
   const fy = Math.floor(h * 0.32)
   ctx.fillStyle = '#1a1410'; ctx.fillRect(fx, fy, 40, h - fy - 22)
   ctx.fillStyle = _WOOD; ctx.fillRect(fx - 3, fy - 4, 46, 5)
   ctx.fillStyle = '#0a0805'; ctx.fillRect(fx + 8, fy + 10, 24, h - fy - 40)
-  for (let i = 0; i < 30; i++) { const ex = fx + 10 + ((i * 7) % 20); const ey = h - 36 - ((i * 5) % 16); ctx.fillStyle = i % 3 ? C.amberD : C.amber; ctx.fillRect(ex, ey, 2, 2) }
-  ctx.fillStyle = _WOOD_L; ctx.fillRect(w - 46, fy, 30, 22); ctx.fillStyle = C.slate; ctx.fillRect(w - 43, fy + 3, 24, 16)
+  for (let i = 0; i < 30; i++) { const ex = fx + 10 + ((i * 7 + seed) % 20); const ey = h - 36 - ((i * 5 + seed) % 16); ctx.fillStyle = i % 3 ? C.amberD : C.amber; ctx.fillRect(ex, ey, 2, 2) }
+  const px = flip ? 16 : w - 46
+  ctx.fillStyle = _WOOD_L; ctx.fillRect(px, fy, 30, 22); ctx.fillStyle = C.slate; ctx.fillRect(px + 3, fy + 3, 24, 16)
   const sy = h - 30
   const sofX = Math.floor(w * 0.34)
   const sofW = Math.floor(w * 0.4)
-  ctx.fillStyle = C.slate; ctx.fillRect(sofX, sy, sofW, 18)
+  const sofa = [C.slate, '#3f5161', '#54424a'][seed % 3]
+  ctx.fillStyle = sofa; ctx.fillRect(sofX, sy, sofW, 18)
   ctx.fillStyle = C.slateL; ctx.fillRect(sofX, sy, sofW, 4)
-  ctx.fillStyle = C.slate; ctx.fillRect(sofX - 4, sy - 6, 6, 24); ctx.fillRect(sofX + sofW, sy - 6, 6, 24)
+  ctx.fillStyle = sofa; ctx.fillRect(sofX - 4, sy - 6, 6, 24); ctx.fillRect(sofX + sofW, sy - 6, 6, 24)
   ctx.fillStyle = '#0c151b'; ctx.fillRect(0, h - 12, w, 12)
   ctx.fillStyle = C.ox; ctx.fillRect(Math.floor(w * 0.52), h - 8, 3, 3)
   lampCone(ctx, Math.floor(w * 0.5), 8, 50, h - 16)
@@ -590,14 +639,14 @@ const paintBedroom: ScenePainter = (ctx, w, h) => {
   ctx.fillStyle = '#0c151b'; ctx.fillRect(0, h - 10, w, 10)
 }
 
-const paintAlley: ScenePainter = (ctx, w, h, t) => {
+const paintAlley: ScenePainter = (ctx, w, h, t, seed = 0) => {
   ditherGrad(ctx, 0, 0, w, h, C.sky1, C.sky0)
   // facing walls funneling to a lit back street
   ctx.fillStyle = '#0a121a'; ctx.fillRect(0, 0, Math.floor(w * 0.3), h)
   ctx.fillStyle = '#0c141c'; ctx.fillRect(Math.floor(w * 0.7), 0, Math.ceil(w * 0.3), h)
   for (let y = 8; y < h - 30; y += 14) {
     ctx.fillStyle = C.bldgL; ctx.fillRect(8, y, 14, 8); ctx.fillRect(w - 24, y + 5, 14, 8)
-    ctx.fillStyle = (y % 28) ? C.winDim : C.win; ctx.fillRect(11, y + 2, 3, 3); ctx.fillRect(w - 21, y + 7, 3, 3)
+    ctx.fillStyle = ((y + (seed % 14)) % 28) ? C.winDim : C.win; ctx.fillRect(11, y + 2, 3, 3); ctx.fillRect(w - 21, y + 7, 3, 3)
   }
   // fire escape zig-zag on the left wall
   ctx.fillStyle = _METAL
@@ -609,11 +658,12 @@ const paintAlley: ScenePainter = (ctx, w, h, t) => {
   ctx.fillStyle = C.slate; ctx.fillRect(Math.floor(w * 0.32), h - 42, 34, 18)
   ctx.fillStyle = C.slateL; ctx.fillRect(Math.floor(w * 0.32), h - 42, 34, 3)
   ctx.fillStyle = _WOOD; ctx.fillRect(Math.floor(w * 0.32) + 40, h - 34, 12, 10); ctx.fillStyle = _WOOD_L; ctx.fillRect(Math.floor(w * 0.32) + 40, h - 34, 12, 2)
-  // buzzing sign at the alley mouth
+  // buzzing sign at the alley mouth (hue varies per case)
   const sx = Math.floor(w * 0.62)
   ctx.fillStyle = C.shadow; ctx.fillRect(sx, 18, 3, 16)
-  ctx.fillStyle = C.ox; ctx.fillRect(sx - 12, 20, 12, 12)
-  ctx.fillStyle = '#b8443f'; ctx.fillRect(sx - 10, 22, 8, 8)
+  const sign = [[C.ox, '#b8443f'], ['#1d5a52', '#2d8a7a'], ['#8a6a1e', '#c2a23f']][seed % 3]
+  ctx.fillStyle = sign[0]; ctx.fillRect(sx - 12, 20, 12, 12)
+  ctx.fillStyle = sign[1]; ctx.fillRect(sx - 10, 22, 8, 8)
   lampCone(ctx, sx - 6, 32, 30, h - 60)
   rainStreaks(ctx, w, h, t)
 }
@@ -769,14 +819,14 @@ const paintRooftop: ScenePainter = (ctx, w, h, t) => {
   rainStreaks(ctx, w, h, t)
 }
 
-const paintOffice: ScenePainter = (ctx, w, h, t) => {
+const paintOffice: ScenePainter = (ctx, w, h, t, seed = 0) => {
   ditherGrad(ctx, 0, 0, w, h, C.sky1, C.sky0)
-  // blinds with light slicing through
+  // blinds with light slicing through (slice phase varies per case)
   const bw = Math.floor(w * 0.3)
   ctx.fillStyle = C.sky2; ctx.fillRect(w - bw - 10, 8, bw, 44)
-  for (let y = 10; y < 50; y += 4) { ctx.fillStyle = (y % 8) ? C.shadow : C.winDim; ctx.fillRect(w - bw - 10, y, bw, 2) }
-  // filing cabinets
-  for (let i = 0; i < 2; i++) {
+  for (let y = 10; y < 50; y += 4) { ctx.fillStyle = ((y + (seed % 4) * 2) % 8) ? C.shadow : C.winDim; ctx.fillRect(w - bw - 10, y, bw, 2) }
+  // filing cabinets (2 or 3)
+  for (let i = 0; i < 2 + (seed % 2); i++) {
     const x = 10 + i * 22
     ctx.fillStyle = _METAL; ctx.fillRect(x, h - 64, 18, 40)
     for (let d = 0; d < 3; d++) { ctx.fillStyle = '#3a444e'; ctx.fillRect(x + 2, h - 60 + d * 12, 14, 2); ctx.fillStyle = C.amberD; ctx.fillRect(x + 7, h - 57 + d * 12, 4, 1) }
@@ -1063,6 +1113,176 @@ const paintVault: ScenePainter = (ctx, w, h) => {
   lampCone(ctx, Math.floor(w * 0.4), 2, 50, h - 30)
 }
 
+// ---- establishing exteriors (the building the case happens in) ----
+const paintManor: ScenePainter = (ctx, w, h, t, seed = 0) => {
+  const horizon = Math.floor(h * 0.64)
+  ditherGrad(ctx, 0, 0, w, horizon, C.sky2, C.sky1)
+  // low moon behind the roofline
+  const mx = Math.floor(w * (0.72 + ((seed >> 2) % 3) * 0.06))
+  ctx.fillStyle = '#b9c2c8'
+  for (let dy = -3; dy <= 3; dy++) for (let dx = -3; dx <= 3; dx++) {
+    if (dx * dx + dy * dy <= 9 && (BAYER4[(dy + 8) & 3][(dx + 8) & 3] + 0.5) / 16 < 0.7) ctx.fillRect(mx + dx, Math.floor(h * 0.14) + dy, 1, 1)
+  }
+  // grounds
+  ditherGrad(ctx, 0, horizon, w, h - horizon, '#0c141c', '#070b0f')
+  // two-story body
+  const bx = Math.floor(w * 0.2)
+  const bw = Math.floor(w * 0.6)
+  const by = Math.floor(h * 0.3)
+  const bh = horizon - by
+  ctx.fillStyle = '#0a1118'
+  ctx.fillRect(bx, by, bw, bh)
+  ctx.fillStyle = '#13202b'
+  ctx.fillRect(bx, by, bw, 1)
+  ctx.fillRect(bx, by, 1, bh)
+  // gables: 2-3 stepped peaks along the roofline
+  const gables = 2 + (seed % 2)
+  for (let g = 0; g < gables; g++) {
+    const gx = bx + Math.floor(((g + 0.5) / gables) * bw)
+    for (let r = 0; r < 7; r++) {
+      ctx.fillStyle = '#0a1118'
+      ctx.fillRect(gx - (7 - r), by - r, (7 - r) * 2, 1)
+    }
+    ctx.fillStyle = '#13202b'
+    ctx.fillRect(gx, by - 7, 1, 1)
+  }
+  // windows: tall pairs per floor, a few lit by seed
+  for (let fy = 0; fy < 2; fy++) {
+    const wy = by + 5 + fy * Math.floor(bh * 0.45)
+    for (let i = 0; i < 5; i++) {
+      const wx = bx + 6 + i * Math.floor((bw - 12) / 4.6)
+      const lit = ((i * 7 + fy * 13 + seed) % 5) < 2
+      ctx.fillStyle = lit ? C.win : '#101b24'
+      ctx.fillRect(wx, wy, 3, 5)
+      if (lit) { ctx.fillStyle = C.winDim; ctx.fillRect(wx, wy + 3, 3, 2) }
+    }
+  }
+  // door + steps
+  const dx = bx + Math.floor(bw / 2) - 2
+  ctx.fillStyle = '#1a1208'
+  ctx.fillRect(dx, horizon - 8, 5, 8)
+  ctx.fillStyle = C.winDim
+  ctx.fillRect(dx + 3, horizon - 5, 1, 1)
+  ctx.fillStyle = '#0e1820'
+  ctx.fillRect(dx - 2, horizon, 9, 2)
+  // hedge + gate posts
+  ctx.fillStyle = '#0c1812'
+  for (let x = 0; x < w; x += 3) ctx.fillRect(x, horizon + Math.floor(h * 0.1) + ((x >> 2) % 2), 3, 4)
+  ctx.fillStyle = '#161616'
+  ctx.fillRect(Math.floor(w * 0.47), horizon + Math.floor(h * 0.08), 2, 8)
+  ctx.fillRect(Math.floor(w * 0.53), horizon + Math.floor(h * 0.08), 2, 8)
+  // lamppost by the walk
+  const lx = Math.floor(w * 0.12)
+  ctx.fillStyle = '#161c22'
+  ctx.fillRect(lx, horizon - 16, 1, Math.floor(h * 0.26))
+  ctx.fillStyle = C.lamp
+  ctx.fillRect(lx - 1, horizon - 18, 3, 3)
+  lampCone(ctx, lx, horizon - 15, 26, 30)
+  rainStreaks(ctx, w, h, t)
+}
+
+const paintFacade: ScenePainter = (ctx, w, h, t, seed = 0) => {
+  const ground = Math.floor(h * 0.8)
+  ditherGrad(ctx, 0, 0, w, Math.floor(h * 0.4), C.sky1, C.sky2)
+  // building face
+  ctx.fillStyle = '#0d141c'
+  ctx.fillRect(0, Math.floor(h * 0.16), w, ground - Math.floor(h * 0.16))
+  // upper-floor windows
+  for (let i = 0; i < 6; i++) {
+    const wx = 8 + i * Math.floor((w - 16) / 5.6)
+    ctx.fillStyle = ((i + seed) % 3) === 0 ? C.winDim : '#101b24'
+    ctx.fillRect(wx, Math.floor(h * 0.22), 4, 6)
+  }
+  // awning: striped, color flips by seed
+  const ay = Math.floor(h * 0.44)
+  const aw = Math.floor(w * 0.62)
+  const ax = Math.floor(w * 0.19)
+  for (let x = 0; x < aw; x += 4) {
+    ctx.fillStyle = (Math.floor(x / 4) % 2) === 0 ? (seed % 2 ? C.ox : '#2d4a52') : C.bone
+    ctx.fillRect(ax + x, ay, Math.min(4, aw - x), 4)
+  }
+  ctx.fillStyle = '#070b0f'
+  ctx.fillRect(ax, ay + 4, aw, 1)
+  // glowing plate glass + door
+  const gy = ay + 6
+  const gh = ground - gy
+  ctx.fillStyle = '#2a2214'
+  ctx.fillRect(ax + 2, gy, aw - 14, gh)
+  for (let y = gy; y < ground; y++) for (let x = ax + 2; x < ax + aw - 12; x++) {
+    const thr = (BAYER4[y & 3][x & 3] + 0.5) / 16
+    if (thr < 0.32) { ctx.fillStyle = C.winDim; ctx.fillRect(x, y, 1, 1) }
+  }
+  ctx.fillStyle = '#191007'
+  ctx.fillRect(ax + aw - 10, gy, 8, gh)
+  ctx.fillStyle = C.win
+  ctx.fillRect(ax + aw - 5, gy + Math.floor(gh / 2), 1, 1)
+  // hanging sign on a bracket
+  ctx.fillStyle = '#161c22'
+  ctx.fillRect(ax - 7, Math.floor(h * 0.3), 8, 1)
+  ctx.fillStyle = seed % 2 ? C.amber : C.slateL
+  ctx.fillRect(ax - 8, Math.floor(h * 0.3) + 1, 6, 7)
+  ctx.fillStyle = '#070b0f'
+  ctx.fillRect(ax - 7, Math.floor(h * 0.3) + 3, 4, 1)
+  ctx.fillRect(ax - 7, Math.floor(h * 0.3) + 5, 4, 1)
+  // wet pavement
+  ditherGrad(ctx, 0, ground, w, h - ground, '#0e161e', '#080d12')
+  ctx.fillStyle = 'rgba(224,164,76,0.10)'
+  ctx.fillRect(ax + 2, ground, aw - 14, Math.floor((h - ground) * 0.7))
+  rainStreaks(ctx, w, h, t)
+}
+
+const paintTower: ScenePainter = (ctx, w, h, t, seed = 0) => {
+  ditherGrad(ctx, 0, 0, w, h, C.sky2, C.sky1)
+  // low rooftops
+  const base = Math.floor(h * 0.78)
+  for (let i = 0; i < 7; i++) {
+    const rx = i * Math.floor(w / 6.5)
+    const rh = Math.floor(h * (0.1 + ((i * 5 + seed) % 4) * 0.03))
+    ctx.fillStyle = '#0a121a'
+    ctx.fillRect(rx, base - rh, Math.floor(w / 6) + 2, rh + (h - base))
+    ctx.fillStyle = C.winDim
+    if ((i + seed) % 3 === 0) ctx.fillRect(rx + 4, base - rh + 3, 2, 2)
+  }
+  // tower shaft
+  const tx = Math.floor(w * 0.44)
+  const tw = Math.floor(w * 0.13)
+  const ty = Math.floor(h * 0.1)
+  ctx.fillStyle = '#0c141c'
+  ctx.fillRect(tx, ty, tw, base - ty)
+  ctx.fillStyle = '#15222d'
+  ctx.fillRect(tx, ty, 1, base - ty)
+  ctx.fillRect(tx, ty, tw, 1)
+  // belfry ledge + cap
+  ctx.fillStyle = '#0c141c'
+  ctx.fillRect(tx - 2, ty + 2, tw + 4, 2)
+  for (let r = 0; r < 6; r++) ctx.fillRect(tx + r, ty - 5 + r, tw - r * 2, 1)
+  // lit clock face
+  const cx = tx + Math.floor(tw / 2)
+  const cy = ty + Math.floor(h * 0.13)
+  const rad = Math.floor(tw * 0.42)
+  ctx.fillStyle = C.lamp
+  for (let dy = -rad; dy <= rad; dy++) for (let dx = -rad; dx <= rad; dx++) {
+    if (dx * dx + dy * dy <= rad * rad) ctx.fillRect(cx + dx, cy + dy, 1, 1)
+  }
+  ctx.fillStyle = '#3a2a10'
+  ctx.fillRect(cx, cy - rad + 1, 1, rad - 1) // minute hand to 12
+  const hourDx = ((seed % 3) - 1) * 2
+  ctx.fillRect(cx, cy, hourDx === 0 ? 1 : Math.abs(hourDx), 1)
+  if (hourDx < 0) ctx.fillRect(cx + hourDx, cy, -hourDx, 1)
+  // tall shaft windows
+  ctx.fillStyle = '#101b24'
+  ctx.fillRect(cx - 1, cy + rad + 4, 3, 8)
+  ctx.fillStyle = C.winDim
+  ctx.fillRect(cx - 1, base - 12, 3, 5)
+  // mist band at the base
+  ctx.fillStyle = 'rgba(170,185,195,0.22)'
+  for (let y = base - 4; y < base + 4 && y < h; y++) for (let x = 0; x < w; x++) {
+    const thr = (BAYER4[y & 3][x & 3] + 0.5) / 16
+    if (thr < 0.3) ctx.fillRect(x, y, 1, 1)
+  }
+  rainStreaks(ctx, w, h, t)
+}
+
 export const SCENES: Record<string, ScenePainter> = {
   skyline: paintSkyline, desk: paintDesk, atrium: paintAtrium, interro: paintInterro,
   seawall: paintSeawall, mezzanine: paintMezzanine, map: paintMap,
@@ -1071,6 +1291,7 @@ export const SCENES: Record<string, ScenePainter> = {
   warehouse: paintWarehouse, rooftop: paintRooftop, office: paintOffice, lobby: paintLobby,
   station: paintStation, garage: paintGarage, chapel: paintChapel, gallery: paintGallery,
   cellar: paintCellar, greenhouse: paintGreenhouse, diner: paintDiner, vault: paintVault,
+  manor: paintManor, facade: paintFacade, tower: paintTower,
 }
 
 // Map a free-text location name (generated cases invent rooms) to the closest set.
@@ -1092,9 +1313,9 @@ const _ROOM_MAP: [RegExp, string][] = [
   [/vault|safe\s*room|strong\s*room|\bbank\b|deposit|counting\s*house/i, 'vault'],
   [/greenhouse|conservatory|garden|orchard|arboretum|nursery\s*garden/i, 'greenhouse'],
   [/diner|caf[eé]|coffee|canteen|tea\s*room|bistro|restaurant/i, 'diner'],
-  [/kitchen|pantry|galley|scullery|bakery/i, 'kitchen'],
-  [/librar|study|den\b|archive|records|reading\s*room/i, 'study'],
-  [/bed|chamber|boudoir|suite|nursery|dormitor/i, 'bedroom'],
+  [/kitchen|pantry|galley|scullery|bakery|oven/i, 'kitchen'],
+  [/librar|study|den\b|archive|records|reading\s*room|biblioteca|stacks?\b/i, 'study'],
+  [/bed|chamber|boudoir|suite|nursery|dormitor|guest\s*room|bath|washroom|lavator/i, 'bedroom'],
   [/mezzanine|\brail\b|balcon|landing|stairwell/i, 'mezzanine'],
   [/dock|harbou?r|pier|seawall|wharf|seaside|waterfront|quay|marina|lighthouse/i, 'seawall'],
   [/parlou?r|lounge|living|sitting|drawing|salon|terrace|veranda|smoking\s*room/i, 'parlor'],
@@ -1106,6 +1327,32 @@ export function sceneForRoom(name: string): ScenePainter {
   return SCENES.parlor // generic interior
 }
 
+// Map a PLACE (the building/venue a case happens in) to an establishing shot.
+// Specific venue words first; unknown venues read best as a lit storefront.
+const _PLACE_MAP: [RegExp, string][] = [
+  [/manor|mansion|palace|estate|villa|ch[âa]teau|abbey|residence/i, 'manor'],
+  [/tower|spire|belfry/i, 'tower'],
+  [/museum|galler|exhibit/i, 'gallery'],
+  [/hotel|\binn\b|lodge|resort/i, 'lobby'],
+  [/librar|archive|ath?enaeum/i, 'facade'],
+  [/theat|playhouse|cabaret|opera|club/i, 'theater'],
+  [/casino|gambling/i, 'casino'],
+  [/\bbank\b|vault|exchange|trust\s*house/i, 'vault'],
+  [/church|chapel|cathedral|abbey/i, 'chapel'],
+  [/station|terminus|railway/i, 'station'],
+  [/dock|harbou?r|wharf|pier|marina|seawall|waterfront/i, 'seawall'],
+  [/bakery|shop|store|boutique|emporium|pawn|salon|caf[eé]|diner|restaurant|bistro/i, 'facade'],
+  [/precinct|district|city|downtown|quarter|street/i, 'skyline'],
+]
+
+export function sceneForPlace(name: string): ScenePainter {
+  const n = (name || '').trim()
+  if (!n) return SCENES.skyline
+  if (SCENES[n]) return SCENES[n] // exact painter key (golden beats pass 'skyline')
+  for (const [re, key] of _PLACE_MAP) if (re.test(n)) return SCENES[key]
+  return SCENES.facade
+}
+
 // ---- exhibit illustrations ----
 // Each exhibit gets a procedural "evidence photo": the object, large, on a forensic
 // table under a spot, with a measuring strip. The kind is read from the exhibit's
@@ -1446,3 +1693,255 @@ export function sceneFor(name: string): ScenePainter {
   const room = /[—–]/.test(name) ? name.split(/[—–]/).pop()!.trim() : name
   return sceneForRoom(room)
 }
+
+// ---- incident vignettes ----
+// The story beat that carries the MAIN ACTION ("…was poisoned", "…was stolen") draws
+// the act itself, big and center-stage, over the dimmed crime room: you should SEE the
+// crime, not just the wallpaper. One vignette per crime kind.
+type IncidentVignette = (ctx: CanvasRenderingContext2D, w: number, h: number) => void
+
+function _evidenceTent(ctx: CanvasRenderingContext2D, x: number, y: number): void {
+  for (let r = 0; r < 7; r++) {
+    ctx.fillStyle = C.amber
+    ctx.fillRect(x - r, y + r, r * 2 + 1, 1)
+  }
+  ctx.fillStyle = '#3a2a10'
+  ctx.fillRect(x - 1, y + 3, 3, 2)
+}
+
+const _INCIDENTS: Record<string, IncidentVignette> = {
+  homicide: (ctx, w, h) => {
+    const cx = Math.floor(w / 2)
+    const gy = Math.floor(h * 0.74)
+    // blood pool, dithered
+    for (let y = -2; y < 9; y++) for (let x = -30; x < 30; x++) {
+      if ((x * x) / 900 + (y * y) / 81 <= 1 && (BAYER4[(gy + y) & 3][(cx + x) & 3] + 0.5) / 16 < 0.55) {
+        ctx.fillStyle = '#5e1c1c'
+        ctx.fillRect(cx + x + 8, gy + y + 4, 1, 1)
+      }
+    }
+    // chalk outline of the fallen figure
+    ctx.fillStyle = C.bone
+    const hx = cx - 34
+    const hy = gy - 2
+    ctx.fillRect(hx - 5, hy - 2, 2, 7); ctx.fillRect(hx + 4, hy - 2, 2, 7)
+    ctx.fillRect(hx - 4, hy - 4, 9, 2); ctx.fillRect(hx - 4, hy + 5, 9, 2)
+    ctx.fillRect(hx + 6, hy, 26, 2)               // torso
+    ctx.fillRect(hx + 12, hy - 9, 2, 9); ctx.fillRect(hx + 12, hy - 9, 9, 2)  // raised arm
+    ctx.fillRect(hx + 19, hy + 2, 2, 9)            // lower arm
+    ctx.fillRect(hx + 32, hy, 2, 11); ctx.fillRect(hx + 32, hy + 9, 12, 2)    // bent leg
+    ctx.fillRect(hx + 32, hy - 7, 14, 2); ctx.fillRect(hx + 44, hy - 7, 2, 7) // straight leg
+    _evidenceTent(ctx, cx + 22, gy - 10)
+    _evidenceTent(ctx, cx - 46, gy + 8)
+  },
+  poisoning: (ctx, w, h) => {
+    const cx = Math.floor(w / 2)
+    const gy = Math.floor(h * 0.72)
+    // table edge
+    ctx.fillStyle = _WOOD; ctx.fillRect(cx - 40, gy, 80, 6)
+    ctx.fillStyle = _WOOD_L; ctx.fillRect(cx - 40, gy, 80, 2)
+    // toppled goblet on its side
+    ctx.fillStyle = '#b9c2c8'
+    ctx.fillRect(cx - 14, gy - 9, 11, 8)           // bowl
+    ctx.fillRect(cx - 3, gy - 6, 9, 2)             // stem
+    ctx.fillRect(cx + 6, gy - 8, 2, 6)             // base
+    ctx.fillStyle = '#070b0f'; ctx.fillRect(cx - 13, gy - 8, 2, 6) // bowl mouth shadow
+    // the spill: sickly green pool running off the table edge
+    for (let y = 0; y < 4; y++) for (let x = -22; x < 4; x++) {
+      if ((BAYER4[(gy + y) & 3][(cx + x) & 3] + 0.5) / 16 < 0.7) {
+        ctx.fillStyle = '#3f6b2a'
+        ctx.fillRect(cx + x - 6, gy - y - 1, 1, 1)
+      }
+    }
+    ctx.fillStyle = '#3f6b2a'
+    ctx.fillRect(cx - 24, gy + 2, 2, 9)            // drip over the edge
+    ctx.fillRect(cx - 25, gy + 12, 4, 2)           // floor drop
+    _evidenceTent(ctx, cx + 26, gy - 10)
+  },
+  theft: (ctx, w, h) => {
+    const cx = Math.floor(w / 2)
+    const gy = Math.floor(h * 0.78)
+    // display pedestal
+    ctx.fillStyle = '#2a2417'; ctx.fillRect(cx - 13, gy - 20, 26, 20)
+    ctx.fillStyle = '#3a3324'; ctx.fillRect(cx - 13, gy - 20, 26, 2)
+    ctx.fillStyle = '#15110a'; ctx.fillRect(cx - 16, gy - 22, 32, 3)
+    // glass dome set aside, ajar
+    ctx.fillStyle = '#5d8a8a'
+    ctx.fillRect(cx + 20, gy - 14, 2, 14); ctx.fillRect(cx + 34, gy - 14, 2, 14)
+    ctx.fillRect(cx + 21, gy - 16, 14, 2); ctx.fillRect(cx + 20, gy, 16, 2)
+    // dashed ghost of the missing prize
+    ctx.fillStyle = C.bone
+    for (let i = 0; i < 4; i++) {
+      ctx.fillRect(cx - 8 + i * 5, gy - 34, 3, 1)
+      ctx.fillRect(cx - 8 + i * 5, gy - 25, 3, 1)
+    }
+    for (let i = 0; i < 3; i++) {
+      ctx.fillRect(cx - 9, gy - 33 + i * 3, 1, 2)
+      ctx.fillRect(cx + 11, gy - 33 + i * 3, 1, 2)
+    }
+    _evidenceTent(ctx, cx - 30, gy - 8)
+  },
+  fraud: (ctx, w, h) => {
+    const cx = Math.floor(w / 2)
+    const gy = Math.floor(h * 0.74)
+    // open ledger, two pages
+    ctx.fillStyle = C.bone
+    ctx.fillRect(cx - 30, gy - 18, 28, 22); ctx.fillRect(cx + 2, gy - 18, 28, 22)
+    ctx.fillStyle = '#0a0805'; ctx.fillRect(cx - 1, gy - 18, 2, 22)
+    // entry lines
+    ctx.fillStyle = '#4a4234'
+    for (let i = 0; i < 5; i++) {
+      ctx.fillRect(cx - 26, gy - 13 + i * 4, 20, 1)
+      ctx.fillRect(cx + 6, gy - 13 + i * 4, 20, 1)
+    }
+    // the doctored entries, struck in red
+    ctx.fillStyle = '#8a2a2a'
+    ctx.fillRect(cx + 4, gy - 14, 24, 2)
+    ctx.fillRect(cx + 6, gy - 7, 22, 2)
+    ctx.fillRect(cx - 27, gy - 6, 6, 6) // ink blot
+    _evidenceTent(ctx, cx + 36, gy - 4)
+  },
+  blackmail: (ctx, w, h) => {
+    const cx = Math.floor(w / 2)
+    const gy = Math.floor(h * 0.72)
+    // the envelope, large, leaning into the light
+    ctx.fillStyle = C.bone; ctx.fillRect(cx - 22, gy - 22, 44, 28)
+    ctx.fillStyle = '#9a937e'
+    ctx.fillRect(cx - 22, gy - 22, 22, 2); ctx.fillRect(cx, gy - 22, 22, 2)
+    // flap V
+    for (let i = 0; i < 11; i++) {
+      ctx.fillRect(cx - 22 + i * 2, gy - 21 + i, 2, 1)
+      ctx.fillRect(cx + 20 - i * 2, gy - 21 + i, 2, 1)
+    }
+    // wax seal
+    ctx.fillStyle = '#8a2a2a'; ctx.fillRect(cx - 4, gy - 14, 9, 9)
+    ctx.fillStyle = '#5e1c1c'; ctx.fillRect(cx - 2, gy - 12, 5, 5)
+    _evidenceTent(ctx, cx + 30, gy)
+  },
+  arson: (ctx, w, h) => {
+    const cx = Math.floor(w / 2)
+    const gy = Math.floor(h * 0.8)
+    // scorched floor
+    for (let y = 0; y < 6; y++) for (let x = -36; x < 36; x++) {
+      if ((BAYER4[(gy + y) & 3][(cx + x) & 3] + 0.5) / 16 < 0.6) {
+        ctx.fillStyle = '#070707'
+        ctx.fillRect(cx + x, gy + y, 1, 1)
+      }
+    }
+    // flames: clustered tongues of amber
+    for (let i = -3; i <= 3; i++) {
+      const fx = cx + i * 9
+      const fh = 14 + ((i * 13 + 7) % 9)
+      for (let y = 0; y < fh; y++) {
+        const ww = Math.max(1, Math.floor((1 - y / fh) * 4))
+        ctx.fillStyle = y > fh * 0.55 ? C.amber : '#f5d08a'
+        ctx.fillRect(fx - ww + ((y * 3 + i) % 2), gy - y, ww * 2, 1)
+      }
+    }
+    // smoke drifting up, dithered
+    for (let y = 0; y < 22; y++) for (let x = -20; x < 20; x++) {
+      if ((BAYER4[y & 3][x & 3] + 0.5) / 16 < 0.16) {
+        ctx.fillStyle = 'rgba(150,150,150,0.5)'
+        ctx.fillRect(cx + x + Math.floor(y / 3), gy - 22 - y, 1, 1)
+      }
+    }
+  },
+  missing_person: (ctx, w, h) => {
+    const cx = Math.floor(w / 2)
+    const gy = Math.floor(h * 0.78)
+    // door ajar, light spilling
+    ctx.fillStyle = '#15110a'; ctx.fillRect(cx + 14, gy - 42, 22, 42)
+    ctx.fillStyle = C.lamp; ctx.fillRect(cx + 17, gy - 39, 7, 39)
+    for (let y = 0; y < 14; y++) {
+      if ((BAYER4[y & 3][1] + 0.5) / 16 < 0.5) { ctx.fillStyle = 'rgba(245,208,138,0.4)'; ctx.fillRect(cx + 8 - y, gy - 2 + Math.floor(y / 4), y, 1) }
+    }
+    // overturned chair
+    ctx.fillStyle = _WOOD
+    ctx.fillRect(cx - 34, gy - 4, 18, 4)           // seat on its side
+    ctx.fillRect(cx - 36, gy - 16, 4, 14)          // back flat on floor... legs up
+    ctx.fillRect(cx - 18, gy - 12, 3, 10)
+    ctx.fillRect(cx - 26, gy - 12, 3, 10)
+    // a dropped glove
+    ctx.fillStyle = C.slate; ctx.fillRect(cx - 4, gy + 2, 7, 4)
+    _evidenceTent(ctx, cx, gy - 14)
+  },
+  con: (ctx, w, h) => {
+    const cx = Math.floor(w / 2)
+    const gy = Math.floor(h * 0.74)
+    // worthless certificates fanned on the table
+    ctx.fillStyle = _WOOD; ctx.fillRect(cx - 40, gy + 2, 80, 5)
+    for (let i = 0; i < 3; i++) {
+      const ox = cx - 26 + i * 16
+      const oy = gy - 16 + (i % 2) * 3
+      ctx.fillStyle = C.bone; ctx.fillRect(ox, oy, 22, 16)
+      ctx.fillStyle = '#b8943e'; ctx.fillRect(ox + 2, oy + 2, 18, 1); ctx.fillRect(ox + 2, oy + 13, 18, 1)
+      ctx.fillStyle = '#4a4234'; ctx.fillRect(ox + 4, oy + 5, 14, 1); ctx.fillRect(ox + 4, oy + 8, 10, 1)
+    }
+    // the red verdict, stamped across them
+    ctx.fillStyle = '#8a2a2a'
+    ctx.fillRect(cx - 24, gy - 9, 48, 3)
+    // an emptied cash box
+    ctx.fillStyle = '#3a444e'; ctx.fillRect(cx + 26, gy - 10, 16, 10)
+    ctx.fillStyle = '#0a0e13'; ctx.fillRect(cx + 28, gy - 8, 12, 6)
+    ctx.fillStyle = '#3a444e'; ctx.fillRect(cx + 24, gy - 14, 20, 3)
+  },
+  ransom: (ctx, w, h) => {
+    const cx = Math.floor(w / 2)
+    const gy = Math.floor(h * 0.74)
+    // the demand, propped center
+    ctx.fillStyle = C.bone; ctx.fillRect(cx - 20, gy - 26, 40, 30)
+    ctx.fillStyle = '#9a937e'; ctx.fillRect(cx - 20, gy + 2, 40, 2)
+    // pasted cut-out letters, uneven
+    const cols = ['#0a0e13', '#8a2a2a', '#2a2417', '#46506b']
+    for (let r = 0; r < 3; r++) {
+      let x = cx - 15
+      for (let i = 0; i < 5 - (r % 2); i++) {
+        ctx.fillStyle = cols[(r * 5 + i) % cols.length]
+        const cw = 4 + ((r + i) % 3)
+        ctx.fillRect(x, gy - 21 + r * 8 + ((i % 2) ? 1 : -1), cw, 6)
+        x += cw + 2
+      }
+    }
+    // the empty chair it was left on
+    ctx.fillStyle = _WOOD
+    ctx.fillRect(cx - 30, gy + 4, 3, 10); ctx.fillRect(cx + 27, gy + 4, 3, 10)
+    _evidenceTent(ctx, cx + 32, gy - 12)
+  },
+  sabotage: (ctx, w, h) => {
+    const cx = Math.floor(w / 2)
+    const gy = Math.floor(h * 0.74)
+    // the cable, snapped: two frayed halves with a violent gap
+    ctx.fillStyle = '#3a444e'
+    ctx.fillRect(cx - 44, gy - 8, 32, 4)
+    ctx.fillRect(cx + 12, gy - 8, 32, 4)
+    ctx.fillStyle = '#5d6a76'
+    for (let i = 0; i < 4; i++) {
+      ctx.fillRect(cx - 12 + i, gy - 8 + i, 4 - i, 1)            // frayed strands
+      ctx.fillRect(cx + 9 - i, gy - 5 - i, 4 - i, 1)
+    }
+    // sparks at the break
+    ctx.fillStyle = '#f5d08a'
+    ctx.fillRect(cx - 2, gy - 12, 2, 2); ctx.fillRect(cx + 4, gy - 16, 1, 1)
+    ctx.fillRect(cx - 7, gy - 15, 1, 1); ctx.fillRect(cx + 1, gy - 4, 1, 1)
+    // a fallen gear and scattered bolts
+    ctx.fillStyle = '#3a444e'
+    ctx.fillRect(cx - 28, gy + 4, 12, 12)
+    ctx.fillStyle = '#0a0e13'; ctx.fillRect(cx - 25, gy + 7, 6, 6)
+    ctx.fillStyle = '#5d6a76'
+    ctx.fillRect(cx + 18, gy + 8, 3, 3); ctx.fillRect(cx + 28, gy + 12, 3, 3); ctx.fillRect(cx + 8, gy + 13, 3, 3)
+    _evidenceTent(ctx, cx + 38, gy - 4)
+  },
+}
+
+/** Compose a crime-kind vignette over a dimmed, spotlit room: the player should see
+ *  and feel the main action, not just the room it happened in. */
+export function incidentPainter(kind: string, room: ScenePainter): ScenePainter {
+  const vignette = _INCIDENTS[kind] || _INCIDENTS.homicide
+  return (ctx, w, h, t, seed) => {
+    room(ctx, w, h, t, seed)
+    ctx.fillStyle = 'rgba(6,9,13,0.52)'
+    ctx.fillRect(0, 0, w, h)
+    lampCone(ctx, Math.floor(w / 2), 0, Math.floor(w * 0.95), Math.floor(h * 0.95))
+    vignette(ctx, w, h)
+  }
+}

web/src/engine/pixel.tsx

@@ -3,12 +3,14 @@ import { useEffect, useRef, useState } from 'preact/hooks'
 import type { JSX } from 'preact'
 
 import { type Pal, type PixelMap, drawMap } from './draw'
+import { applySceneTheme, getCaseTheme, weatherOverlay } from './theme'
 
 export type ScenePainter = (
   ctx: CanvasRenderingContext2D,
   w: number,
   h: number,
   t: number,
+  seed?: number,
 ) => void
 
 interface PixelCanvasProps {
@@ -78,6 +80,9 @@ interface SceneCanvasProps {
   anim?: boolean
   full?: boolean
   rain?: boolean
+  /** Per-case theming: 'full' = tint + weather, 'tint' = tint only (indoor exhibits),
+   *  'none' (default) = exact legacy output. */
+  themed?: 'full' | 'tint' | 'none'
 }
 
 /** Procedural painter at low internal res. Static scenes paint once to an offscreen
@@ -93,6 +98,7 @@ export function SceneCanvas({
   anim = false,
   full = false,
   rain = true,
+  themed = 'none',
 }: SceneCanvasProps) {
   const ref = useRef<HTMLCanvasElement>(null)
   const bufRef = useRef<HTMLCanvasElement | null>(null)
@@ -103,12 +109,14 @@ export function SceneCanvas({
     const ctx = cv.getContext('2d')!
     ctx.imageSmoothingEnabled = false
 
+    const { seed } = getCaseTheme()
     const buf = document.createElement('canvas')
     buf.width = w
     buf.height = h
     const bctx = buf.getContext('2d')!
     bctx.imageSmoothingEnabled = false
-    paint(bctx, w, h, 0)
+    paint(bctx, w, h, 0, seed)
+    if (themed !== 'none') applySceneTheme(bctx, w, h, themed)
     bufRef.current = buf
 
     let raf = 0
@@ -122,7 +130,8 @@ export function SceneCanvas({
           last = ts
           tRef.current += 1
           ctx.clearRect(0, 0, w, h)
-          paint(ctx, w, h, tRef.current)
+          paint(ctx, w, h, tRef.current, seed)
+          if (themed !== 'none') applySceneTheme(ctx, w, h, themed)
         }
         raf = requestAnimationFrame(loop)
       }
@@ -135,12 +144,16 @@ export function SceneCanvas({
           tRef.current += 1
           ctx.clearRect(0, 0, w, h)
           ctx.drawImage(buf, 0, 0)
-          ctx.fillStyle = 'rgba(176,196,206,0.26)'
           const t = tRef.current
-          for (let i = 0; i < 36; i++) {
-            const x = (i * 41 + t * 5) % w
-            const y = (i * 57 + t * 9) % h
-            ctx.fillRect(Math.floor(x), Math.floor(y), 1, 3)
+          if (themed !== 'none') {
+            weatherOverlay(ctx, w, h, t)
+          } else {
+            ctx.fillStyle = 'rgba(176,196,206,0.26)'
+            for (let i = 0; i < 36; i++) {
+              const x = (i * 41 + t * 5) % w
+              const y = (i * 57 + t * 9) % h
+              ctx.fillRect(Math.floor(x), Math.floor(y), 1, 3)
+            }
           }
         }
         raf = requestAnimationFrame(loop)

web/src/engine/theme.ts

@@ -0,0 +1,119 @@
+// Per-case visual theme: a tint keyed to the crime kind, weather parsed from the case's
+// own weather line, and a stable seed for painter variation. Held in a module singleton
+// set when a case loads (GameProvider remounts per run, so every canvas repaints fresh).
+// DEFAULT_THEME reproduces the un-themed output exactly, so any canvas painted before a
+// case arrives looks like it always did.
+import { BAYER4 } from './draw'
+
+export type WeatherKind = 'rain' | 'fog' | 'sleet' | 'dry'
+
+export interface CaseTheme {
+  seed: number
+  weather: WeatherKind
+  tint: string
+  tintStrength: number
+}
+
+export const DEFAULT_THEME: CaseTheme = { seed: 0, weather: 'rain', tint: '', tintStrength: 0 }
+
+let _theme: CaseTheme = DEFAULT_THEME
+
+export function setCaseTheme(t: CaseTheme): void {
+  _theme = t
+}
+export function getCaseTheme(): CaseTheme {
+  return _theme
+}
+
+function hashStr(s: string): number {
+  let h = 0
+  for (let i = 0; i < s.length; i++) h = (h * 31 + s.charCodeAt(i)) >>> 0
+  return h
+}
+
+// Two noir-muted shades per crime kind; the seed picks one so two homicides
+// in a row still read slightly differently.
+const TINTS: Record<string, [string, string]> = {
+  homicide: ['#87292a', '#5e1c1c'],
+  theft: ['#37636b', '#284149'],
+  fraud: ['#1d5a2c', '#14401f'],
+  blackmail: ['#46506b', '#3a3a5e'],
+  arson: ['#b9772f', '#8a4a1e'],
+  missing_person: ['#2d3a5e', '#1d2832'],
+  con: ['#8a6a1e', '#6b521a'],
+  poisoning: ['#3f6b2a', '#2c4a1e'],
+  ransom: ['#3a4a5e', '#28323e'],
+  sabotage: ['#8a4a2a', '#6b3a1e'],
+}
+
+export function weatherFromText(text: string): WeatherKind {
+  const t = (text || '').toLowerCase()
+  if (/sleet/.test(t)) return 'sleet'
+  if (/fog|mist/.test(t)) return 'fog'
+  if (/rain|storm|drizzle|downpour/.test(t)) return 'rain'
+  return 'dry'
+}
+
+export function themeFromCase(c: { id: string; weather?: string; kind?: string }): CaseTheme {
+  const seed = hashStr(c.id || '')
+  const pair = TINTS[c.kind || 'homicide'] || TINTS.homicide
+  return { seed, weather: weatherFromText(c.weather || ''), tint: pair[seed & 1], tintStrength: 0.16 }
+}
+
+/** Post-paint pass over a freshly painted (static) scene buffer. Composite ops are
+ *  per-pixel, so the pixel-art stays crisp. 'tint' skips the weather treatment
+ *  (exhibits sit on an indoor forensic table). */
+export function applySceneTheme(ctx: CanvasRenderingContext2D, w: number, h: number, mode: 'full' | 'tint'): void {
+  const t = _theme
+  if (t.tint && t.tintStrength > 0) {
+    ctx.globalCompositeOperation = 'overlay'
+    ctx.globalAlpha = t.tintStrength
+    ctx.fillStyle = t.tint
+    ctx.fillRect(0, 0, w, h)
+    ctx.globalAlpha = 1
+    ctx.globalCompositeOperation = 'source-over'
+  }
+  if (mode === 'full' && t.weather === 'fog') {
+    // Wash the color out, then lay dithered haze bands that thicken toward the ground.
+    ctx.globalCompositeOperation = 'saturation'
+    ctx.globalAlpha = 0.45
+    ctx.fillStyle = '#8a949c'
+    ctx.fillRect(0, 0, w, h)
+    ctx.globalAlpha = 1
+    ctx.globalCompositeOperation = 'source-over'
+    ctx.fillStyle = 'rgba(170,185,195,0.32)'
+    for (let b = 0; b < 4; b++) {
+      const y0 = Math.floor(h * (0.34 + b * 0.17))
+      const bh = 3 + b * 2
+      const cover = 0.22 + b * 0.13
+      for (let y = y0; y < Math.min(h, y0 + bh); y++) {
+        for (let x = 0; x < w; x++) {
+          const thr = (BAYER4[y & 3][x & 3] + 0.5) / 16
+          if (thr < cover) ctx.fillRect(x, y, 1, 1)
+        }
+      }
+    }
+  }
+}
+
+/** Per-frame precipitation for animated scenes. Rain matches the legacy overlay
+ *  pixel-for-pixel; sleet falls in slanted two-pixel steps; fog and dry add nothing. */
+export function weatherOverlay(ctx: CanvasRenderingContext2D, w: number, h: number, t: number): void {
+  const wk = _theme.weather
+  if (wk === 'rain') {
+    ctx.fillStyle = 'rgba(176,196,206,0.26)'
+    for (let i = 0; i < 36; i++) {
+      const x = (i * 41 + t * 5) % w
+      const y = (i * 57 + t * 9) % h
+      ctx.fillRect(Math.floor(x), Math.floor(y), 1, 3)
+    }
+  } else if (wk === 'sleet') {
+    ctx.fillStyle = 'rgba(200,210,220,0.30)'
+    for (let i = 0; i < 28; i++) {
+      const x = (i * 47 + t * 6) % w
+      const y = (i * 53 + t * 8) % h
+      ctx.fillRect(Math.floor(x), Math.floor(y), 1, 2)
+      ctx.fillRect(Math.floor(x) + 1, Math.floor(y) + 2, 1, 2)
+    }
+  }
+}

web/src/played.ts

@@ -0,0 +1,32 @@
+// Played-case memory: ids of every case this browser has STARTED, oldest first.
+// Sent with New Case so the server never deals this player a mystery they've seen.
+const KEY = 'cz-played'
+const CAP = 200
+
+interface Stored {
+  v: 1
+  ids: string[]
+}
+
+export function getPlayed(): string[] {
+  try {
+    const raw = localStorage.getItem(KEY)
+    if (!raw) return []
+    const data = JSON.parse(raw) as Stored
+    if (data?.v !== 1 || !Array.isArray(data.ids)) return []
+    return data.ids.filter((x) => typeof x === 'string')
+  } catch {
+    return []
+  }
+}
+
+export function markPlayed(id: string): void {
+  if (!id) return
+  try {
+    const ids = getPlayed().filter((x) => x !== id)
+    ids.push(id) // most recent last; the server uses order for its repeat-of-last-resort
+    localStorage.setItem(KEY, JSON.stringify({ v: 1, ids: ids.slice(-CAP) }))
+  } catch {
+    /* private mode etc. — repeats become possible, nothing breaks */
+  }
+}

web/src/screens/board.tsx

@@ -7,10 +7,12 @@ import { useEffect, useRef, useState } from 'preact/hooks'
 import { useGame } from '../store'
 import type { PublicCase } from '../types'
 import { playSfx } from '../ui/audio'
-import { BottomNav, Btn, EvIcon, Hud, Panel, Portrait, Scene, SuspicionBar } from '../ui/components'
+import { CaseBriefOverlay } from '../ui/case-brief'
+import { Checklist } from '../ui/checklist'
+import { BottomNav, Btn, ExhibitArt, Hud, Panel, Portrait, Scene, SuspicionBar } from '../ui/components'
 import { ThreadLayer, useThreads } from './board-threads'
 
-const CARD_H = 92
+const CARD_H = 120 // polaroid: exhibit photo + caption
 const CARD_W = 150 // desktop
 const CARD_W_M = 132 // mobile — two loose columns at 390px
 const SPOTS: [number, number][] = [
@@ -61,13 +63,17 @@ export function Board() {
         }
       />
       {compact ? (
-        <Corkboard compact connect={connect} setConnect={setConnect} />
+        <>
+          <Checklist slim />
+          <Corkboard compact connect={connect} setConnect={setConnect} />
+        </>
       ) : (
         <div class="board-layout">
           <Corkboard compact={false} connect={connect} setConnect={setConnect} />
           <SuspectRail />
         </div>
       )}
+      <CaseBriefOverlay />
       <BottomNav />
     </div>
   )
@@ -89,8 +95,8 @@ function Corkboard({ compact, connect, setConnect }: { compact: boolean; connect
   const dragCleanup = useRef<(() => void) | null>(null)
   const threads = useThreads(c.id, ['victim', ...c.evidence.map((e) => e.id)])
 
-  // Tall virtual wall on mobile so eight cards breathe at ~400px width.
-  const mobileBoardH = Math.max(900, 200 + c.evidence.length * 115)
+  // Tall virtual wall on mobile so eight polaroid cards breathe at ~400px width.
+  const mobileBoardH = Math.max(980, 220 + c.evidence.length * 145)
 
   // Mode flip: wipe layout (and the measurement that produced it) so cards re-seat
   // on the new wall instead of stranding off-board.
@@ -327,7 +333,7 @@ function BoardDecor({ c, compact }: { c: PublicCase; compact?: boolean }) {
         <div class="wall-clip">
           <div style={{ fontFamily: 'var(--f-display)', fontSize: 9, lineHeight: 1.25, color: '#231f16' }}>{c.city} UNVEILS<br />ITS NEW CROWN</div>
           <div style={{ height: 2, background: '#231f1633', margin: '5px 0' }} />
-          <div style={{ background: '#0d1117', height: 46, marginBottom: 4 }}><Scene name="skyline" w={170} h={46} style={{ width: '100%', height: '100%' }} /></div>
+          <div style={{ background: '#0d1117', height: 46, marginBottom: 4 }}><Scene name={c.district} establishing w={170} h={46} style={{ width: '100%', height: '100%' }} /></div>
           <div class="t-mono" style={{ fontSize: 'calc(11px*var(--mono-scale))', color: '#4a4234', lineHeight: 1.2 }}>{c.victim.name} found dead the night the city came to celebrate.</div>
         </div>
       </WallItem>
@@ -375,8 +381,8 @@ function BoardDecor({ c, compact }: { c: PublicCase; compact?: boolean }) {
       )}
       <WallItem x={compact ? '52%' : '84%'} y={compact ? '82%' : '55%'} rot={3} pin="ox" w={compact ? 130 : 138}>
         <div class="wall-photo">
-          <div style={{ background: '#0d1117', height: 72 }}><Scene name="mezzanine" w={126} h={72} style={{ width: '100%', height: '100%' }} /></div>
-          <div class="t-mono" style={{ fontSize: 'calc(11px*var(--mono-scale))', color: '#6a6150', textAlign: 'center', marginTop: 3 }}>SCENE — RAIL</div>
+          <div style={{ background: '#0d1117', height: 72 }}><Scene name={c.scene} w={126} h={72} style={{ width: '100%', height: '100%' }} /></div>
+          <div class="t-mono" style={{ fontSize: 'calc(11px*var(--mono-scale))', color: '#6a6150', textAlign: 'center', marginTop: 3 }}>SCENE — {(c.scene.split(/[—–]/).pop() || c.scene).trim().toUpperCase().slice(0, 14)}</div>
         </div>
       </WallItem>
       {!compact && <div class="wall-item" style={{ left: '44%', top: '70%', width: 64, height: 64, border: '5px solid rgba(60,40,20,.35)', borderRadius: '50%', boxShadow: 'inset 0 0 8px rgba(60,40,20,.25)' }} />}
@@ -397,7 +403,7 @@ function SuspectRail() {
     <aside class="suspect-rail">
       <div class="suspect-rail__head">
         <div class="t-label" style={{ color: 'var(--amber-2)' }}>PERSONS OF INTEREST</div>
-        <div class="t-body dim" style={{ fontSize: 12, marginTop: 4 }}>Click a suspect, then interrogate.</div>
+        <Checklist />
       </div>
       <div class="suspect-rail__list">
         {c.suspects.map((s) => {
@@ -409,7 +415,7 @@ function SuspectRail() {
               <Panel variant={open ? 'amber' : undefined} style={{ padding: 10 }} onClick={() => setSel(open ? null : s.id)}>
                 <div class="row" style={{ gap: 10, alignItems: 'center' }}>
                   <div style={{ background: 'var(--ink-1)', boxShadow: 'inset 0 0 0 2px var(--ink-0)', padding: 3, flexShrink: 0, position: 'relative' }}>
-                    <Portrait id={s.sprite} px={4} blink={open} gender={s.gender} />
+                    <Portrait id={s.sprite} px={4} blink={open} gender={s.gender} accent={s.accentColor} />
                     {grilled && <span style={{ position: 'absolute', top: -4, right: -4, background: 'var(--slate-2)', color: 'var(--ink-0)', fontFamily: 'var(--f-display)', fontSize: 7, padding: '2px 3px' }}>✓</span>}
                   </div>
                   <div class="col grow" style={{ gap: 4, minWidth: 0 }}>
@@ -444,12 +450,12 @@ function BoardNode({ node, cardW, selected, onSelect }: { node: Node; cardW: num
     const e = c.evidence.find((x) => x.id === node.id)!
     return (
       <div class="pin-note" style={{ width: cardW, cursor: 'pointer', boxShadow: selected ? '0 0 0 3px var(--amber-2), 3px 4px 0 rgba(0,0,0,.4)' : undefined }} onClick={onSelect}>
-        <div class="row" style={{ gap: 8, alignItems: 'center' }}>
-          <div style={{ background: 'var(--ink-1)', padding: 3 }}><EvIcon icon={e.icon} px={2} /></div>
-          <div class="col" style={{ gap: 2, minWidth: 0 }}>
-            <span class="t-display" style={{ fontSize: 7, color: 'var(--ink-1)' }}>{e.name}</span>
-            <span class="t-mono" style={{ fontSize: 'calc(12px*var(--mono-scale))', color: 'var(--ox-2)' }}>{e.time}</span>
-          </div>
+        <div style={{ background: 'var(--ink-1)', boxShadow: 'inset 0 0 0 2px var(--ink-0)', height: 52, marginBottom: 5, overflow: 'hidden' }}>
+          <ExhibitArt e={e} w={96} h={64} style={{ width: '100%', height: '100%', objectFit: 'cover' }} />
+        </div>
+        <div class="col" style={{ gap: 2, minWidth: 0 }}>
+          <span class="t-display" style={{ fontSize: 7, color: 'var(--ink-1)' }}>{e.name}</span>
+          <span class="t-mono" style={{ fontSize: 'calc(12px*var(--mono-scale))', color: 'var(--ox-2)' }}>{e.time}</span>
         </div>
       </div>
     )

web/src/screens/cold.tsx

@@ -65,14 +65,24 @@ export function StoryScreen() {
   const [body, done] = useTypewriter(beat.text, (g.state.tweaks.typeSpeed || 18) + 2, true)
   return (
     <div class="app__view" style={{ position: 'relative', background: 'var(--ink-0)' }}>
-      <Scene name={beat.scene} w={320} h={200} cover deps={[i]} style={{ position: 'absolute', inset: 0, width: '100%', height: '100%', opacity: 0.5 }} />
+      <Scene
+        name={beat.scene}
+        establishing={i === 0}
+        incident={beat.incident ? g.case.kind || 'homicide' : undefined}
+        anim
+        w={320}
+        h={200}
+        cover
+        deps={[i]}
+        style={{ position: 'absolute', inset: 0, width: '100%', height: '100%', opacity: beat.incident ? 0.75 : 0.5 }}
+      />
       <div style={{ position: 'absolute', inset: 0, background: 'linear-gradient(180deg, rgba(8,11,16,.7) 0%, rgba(8,11,16,.35) 38%, rgba(8,11,16,.82) 100%)' }} />
       <div style={{ position: 'relative', zIndex: 2, flex: 1, display: 'flex', flexDirection: 'column' }}>
         <div class="between" style={{ padding: '14px 18px' }}>
           <span class="t-label" style={{ letterSpacing: '.2em', color: 'var(--amber-2)' }}>{beat.kicker}</span>
           <div class="row" style={{ gap: 8 }}>
             <HintButton />
-            <Btn sm variant="ghost" onClick={() => g.nav('briefing')}>Skip ▸</Btn>
+            <Btn sm variant="ghost" onClick={() => g.nav('board')}>Skip ▸</Btn>
           </div>
         </div>
         <div class="grow center" style={{ padding: '12px 22px' }}>
@@ -95,7 +105,7 @@ export function StoryScreen() {
             {!last ? (
               <Btn variant="amber" onClick={() => setI(i + 1)}>Next ▸</Btn>
             ) : (
-              <Btn variant="amber" style={{ padding: '13px 24px' }} onClick={() => g.nav('briefing')}>Open the Case File ▸▸</Btn>
+              <Btn variant="amber" style={{ padding: '13px 24px' }} onClick={() => g.nav('board')}>Start Investigating ▸▸</Btn>
             )}
           </div>
         </div>
@@ -143,7 +153,7 @@ export function BootScreen() {
 
   return (
     <div class="app__view" style={{ position: 'relative', background: 'var(--ink-0)' }}>
-      <Scene name="seawall" w={320} h={200} cover style={{ position: 'absolute', inset: 0, width: '100%', height: '100%', opacity: 0.28 }} />
+      <Scene name={g.case.district} establishing w={320} h={200} cover style={{ position: 'absolute', inset: 0, width: '100%', height: '100%', opacity: 0.28 }} />
       <div style={{ position: 'absolute', inset: 0, background: 'radial-gradient(90% 80% at 30% 40%, transparent 40%, rgba(8,11,16,.7) 100%)' }} />
       <div class="screen-center" style={{ position: 'relative', zIndex: 2 }}>
         <div class="maxw" style={{ maxWidth: 760, display: 'flex', flexDirection: 'column', gap: 22, alignItems: g.mode === 'mobile' ? 'stretch' : 'flex-start' }}>
@@ -293,7 +303,7 @@ function dossierPages(c: PublicCase): { tab: string; render: () => ComponentChil
           <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 12 }}>
             {c.suspects.map((s) => (
               <div key={s.id} class="row" style={{ gap: 10, alignItems: 'center', background: '#00000010', padding: 8, boxShadow: 'inset 0 0 0 1px #211d1522' }}>
-                <div style={{ background: '#0d1117', padding: 3, flexShrink: 0 }}><Portrait id={s.sprite} px={3} gender={s.gender} /></div>
+                <div style={{ background: '#0d1117', padding: 3, flexShrink: 0 }}><Portrait id={s.sprite} px={3} gender={s.gender} accent={s.accentColor} /></div>
                 <div class="col" style={{ gap: 2, minWidth: 0 }}>
                   <span class="dh" style={{ fontSize: 10 }}>{s.name}</span>
                   <span class="dlabel" style={{ color: '#8a3a2c' }}>{s.tag}</span>

web/src/screens/endgame.tsx

@@ -1,244 +1,270 @@
-// Accusation builder · Verdict reveal · Share card. The verdict is computed server-side
-// (the sealed solution is read for the first time at /accuse); the client only displays it.
-import { useEffect, useState } from 'preact/hooks'
-
-import { accuse } from '../api'
-import { useGame } from '../store'
-import type { VerdictResult } from '../types'
-import { playSfx } from '../ui/audio'
-import { Btn, DialoguePanel, EvIcon, Hud, Panel, Portrait, Scene, Stamp, perpNoun } from '../ui/components'
-
-
-export function AccusationScreen() {
-  const g = useGame()
-  const c = g.case
-  const a = g.state.accuse
-  const [submitting, setSubmitting] = useState(false)
-  const [err, setErr] = useState<string | null>(null)
-  const set = (field: 'suspect' | 'motive' | 'evidence', value: unknown) => g.dispatch({ type: 'ACCUSE', field, value })
-  const toggleEv = (id: string) => set('evidence', a.evidence.includes(id) ? a.evidence.filter((x) => x !== id) : [...a.evidence, id])
-  const ready = !!a.suspect && !!a.motive && a.evidence.length >= 1
-
-  const submit = async () => {
-    if (!ready || submitting) return
-    playSfx('accuse')
-    setSubmitting(true)
-    setErr(null)
-    try {
-      const result = await accuse(g.runId, { suspectId: a.suspect!, motiveId: a.motive!, evidenceIds: a.evidence })
-      g.nav('verdict', { result })
-    } catch {
-      setErr('The line dropped. Try closing the case again.')
-      setSubmitting(false)
-    }
-  }
-
-  return (
-    <div class="app__view" style={{ background: 'var(--ink-0)' }}>
-      <Hud title="THE ACCUSATION" sub="THIS CANNOT BE UNDONE" right={<Btn sm variant="ghost" onClick={() => g.nav('board')}>Back</Btn>} />
-      <div style={{ position: 'absolute', inset: 0, top: 56, background: 'radial-gradient(70% 60% at 50% 30%, rgba(135,41,42,.10), transparent 70%)', pointerEvents: 'none' }} />
-      <div class="screen-pad">
-        <div class="maxw" style={{ maxWidth: 1000 }}>
-          <div class="col" style={{ gap: 20 }}>
-            <section>
-              <div class="t-display ox" style={{ fontSize: 13, marginBottom: 10 }}>1 — NAME THE KILLER</div>
-              <div class="grid-4">
-                {c.suspects.map((s) => (
-                  <Panel key={s.id} variant={a.suspect === s.id ? 'ox' : undefined} style={{ padding: 10, cursor: 'pointer', textAlign: 'center' }} onClick={() => set('suspect', s.id)}>
-                    <div class="center" style={{ background: 'var(--ink-1)', boxShadow: 'inset 0 0 0 2px var(--ink-0)', padding: 5, marginBottom: 8 }}><Portrait id={s.sprite} px={4} blink={a.suspect === s.id} gender={s.gender} /></div>
-                    <div class="t-display" style={{ fontSize: 9, color: a.suspect === s.id ? 'var(--ox-3)' : 'var(--bone-3)' }}>{s.name}</div>
-                    <div class="t-label" style={{ marginTop: 3 }}>{s.tag}</div>
-                  </Panel>
-                ))}
-              </div>
-            </section>
-
-            <section>
-              <div class="t-display ox" style={{ fontSize: 13, marginBottom: 10 }}>2 — THE MOTIVE</div>
-              <div class="grid-2">
-                {c.motives.map((m) => (
-                  <Panel key={m.id} variant={a.motive === m.id ? 'amber' : undefined} style={{ padding: 12, cursor: 'pointer' }} onClick={() => set('motive', m.id)}>
-                    <div class="row" style={{ gap: 10, alignItems: 'center' }}>
-                      <span style={{ width: 16, height: 16, flexShrink: 0, background: a.motive === m.id ? 'var(--amber-2)' : 'var(--ink-1)', boxShadow: 'inset 0 0 0 2px var(--ink-0)' }} />
-                      <span class="t-body" style={{ fontSize: 14 }}>{m.text}</span>
-                    </div>
-                  </Panel>
-                ))}
-              </div>
-            </section>
-
-            <section>
-              <div class="t-display ox" style={{ fontSize: 13, marginBottom: 10 }}>3 — ATTACH SUPPORTING EVIDENCE</div>
-              <div class="row wrap" style={{ gap: 10 }}>
-                {c.evidence.map((e) => {
-                  const on = a.evidence.includes(e.id)
-                  return (
-                    <button key={e.id} onClick={() => toggleEv(e.id)} style={{ border: 0, background: 'transparent', padding: 0, cursor: 'pointer' }}>
-                      <Panel variant={on ? 'amber' : undefined} style={{ padding: 8 }}>
-                        <div class="row" style={{ gap: 8, alignItems: 'center' }}>
-                          <div style={{ background: 'var(--ink-1)', padding: 3 }}><EvIcon icon={e.icon} px={2} /></div>
-                          <span class="t-display" style={{ fontSize: 8, color: on ? 'var(--amber-2)' : 'var(--bone-2)' }}>{e.name}</span>
-                          {on && <span class="amber">✓</span>}
-                        </div>
-                      </Panel>
-                    </button>
-                  )
-                })}
-              </div>
-            </section>
-
-            <Panel variant="ox" className="between wrap" style={{ gap: 12, padding: 16 }}>
-              <div class="t-body" style={{ fontSize: 14, maxWidth: 460 }}>
-                {err ? <span class="ox">{err}</span> : ready ? (
-                  <>You are about to charge <span class="ox t-display" style={{ fontSize: 12 }}>{c.suspects.find((s) => s.id === a.suspect)!.name}</span> as the {perpNoun(c.kind)} in the case of {c.victim.name}.</>
-                ) : (
-                  `Select the ${perpNoun(c.kind)}, a motive, and at least one exhibit to proceed.`
-                )}
-              </div>
-              <Btn variant="ox" disabled={!ready || submitting} style={{ fontSize: 13, padding: '15px 26px' }} onClick={submit}>
-                {submitting ? 'Closing…' : 'Close the Case ▸▸'}
-              </Btn>
-            </Panel>
-          </div>
-        </div>
-      </div>
-    </div>
-  )
-}
-
-export function VerdictScreen() {
-  const g = useGame()
-  const c = g.case
-  const result = g.state.payload.result as VerdictResult | undefined
-  const instant = g.state.payload.done === true // returning from Share - show it finished, no replay
-  const [phase, setPhase] = useState(instant ? 2 : 0)
-  useEffect(() => {
-    if (instant) return
-    if (result) playSfx(result.correct ? 'success' : 'fail')
-    const t1 = setTimeout(() => setPhase(1), 700)
-    const t2 = setTimeout(() => setPhase(2), 2200)
-    return () => {
-      clearTimeout(t1)
-      clearTimeout(t2)
-    }
-  }, [])
-
-  if (!result) {
-    return (
-      <div class="app__view screen-center">
-        <Panel className="col center" style={{ gap: 14, padding: 24 }}>
-          <span class="t-display amber">NO ACCUSATION ON FILE</span>
-          <Btn variant="amber" onClick={() => g.nav('accuse')}>Build the accusation ▸</Btn>
-        </Panel>
-      </div>
-    )
-  }
-
-  const correct = result.correct
-  const killer = c.suspects.find((s) => s.id === result.verdict.killerId)
-  const killerSprite = killer?.sprite || c.victim.sprite
-  const killerGender = killer?.gender
-  const stats = result.stats?.length ? result.stats : g.runStats()
-  return (
-    <div class="app__view" style={{ background: 'var(--ink-0)', position: 'relative' }}>
-      <Scene name={c.scene} w={320} h={200} anim cover style={{ position: 'absolute', inset: 0, width: '100%', height: '100%', opacity: 0.5 }} />
-      <div class="fx-scanlines" style={{ position: 'absolute', inset: 0, opacity: 0.4 }} />
-      <div style={{ position: 'absolute', inset: 0, background: 'radial-gradient(80% 70% at 50% 40%, transparent 20%, rgba(8,11,16,.85) 80%)' }} />
-      <div class="screen-center" style={{ position: 'relative', zIndex: 2 }}>
-        <div class="col center" style={{ gap: 20, maxWidth: 720, textAlign: 'center' }}>
-          {phase >= 0 && (
-            <Stamp slam={!instant} style={{ fontSize: 'clamp(16px,4vw,26px)', borderColor: correct ? 'var(--slate-3)' : 'var(--ox-3)', color: correct ? 'var(--slate-3)' : 'var(--ox-3)' }}>
-              {result.verdict.stamp}
-            </Stamp>
-          )}
-          {phase >= 1 && (
-            <div class="col center" style={{ gap: 6 }}>
-              <div style={{ background: 'var(--ink-1)', boxShadow: `inset 0 0 0 3px ${correct ? 'var(--slate-2)' : 'var(--ox-2)'}`, padding: 6 }}><Portrait id={killerSprite} px={5} gender={killerGender} /></div>
-              <span class="t-display amber" style={{ fontSize: 11 }}>{result.verdict.killerName}</span>
-              <span class="t-label">THE {perpNoun(c.kind).toUpperCase()}</span>
-            </div>
-          )}
-          {phase >= 2 && (
-            <>
-              <Panel style={{ maxWidth: 640 }}>
-                <DialoguePanel who={correct ? 'THE TRUTH' : 'THE TRUTH ESCAPES'} text={result.verdict.truth} speed={g.state.tweaks.typeSpeed || 16} tag={correct ? null : 'WRONG'} />
-              </Panel>
-              {result.score && (
-                <div class="t-mono amber" style={{ fontSize: 'calc(18px*var(--mono-scale))' }}>SCORE {result.score.points}/{result.score.max}</div>
-              )}
-              <div class="row wrap center" style={{ gap: 10 }}>
-                {stats.map(([k, v], i) => (
-                  <Panel key={i} style={{ padding: '10px 16px', textAlign: 'center' }}>
-                    <div class="t-mono amber" style={{ fontSize: 'calc(20px*var(--mono-scale))' }}>{v}</div>
-                    <div class="t-label" style={{ marginTop: 3 }}>{k}</div>
-                  </Panel>
-                ))}
-              </div>
-              <div class="row wrap center" style={{ gap: 10 }}>
-                <Btn variant="amber" onClick={() => g.nav('share', { result })}>Share Case Card ▸</Btn>
-                <Btn variant="ghost" onClick={() => g.newCase()}>New Case</Btn>
-              </div>
-            </>
-          )}
-        </div>
-      </div>
-    </div>
-  )
-}
-
-export function ShareScreen() {
-  const g = useGame()
-  const c = g.case
-  const result = g.state.payload.result as VerdictResult | undefined
-  const correct = !!result?.correct
-  const stats = result?.stats?.length ? result.stats : g.runStats()
-  const [copied, setCopied] = useState(false)
-  const copy = () => {
-    try {
-      navigator.clipboard.writeText(c.id)
-    } catch {
-      /* ignore */
-    }
-    setCopied(true)
-    setTimeout(() => setCopied(false), 1600)
-  }
-  return (
-    <div class="app__view screen-center" style={{ background: 'var(--ink-0)' }}>
-      <div class="col center" style={{ gap: 16, width: '100%' }}>
-        <Panel variant="amber" style={{ width: 'min(440px,92vw)', padding: 0, overflow: 'hidden' }}>
-          <div style={{ position: 'relative', height: 140 }}>
-            <Scene name="skyline" w={240} h={140} anim style={{ width: '100%', height: '100%', objectFit: 'cover' }} />
-            <div style={{ position: 'absolute', inset: 0, background: 'linear-gradient(transparent, var(--ink-2))' }} />
-            <div style={{ position: 'absolute', top: 10, left: 12 }}><span class="t-label" style={{ color: 'var(--amber-2)', letterSpacing: '.2em' }}>CASE ZERO</span></div>
-            <div style={{ position: 'absolute', bottom: 8, right: 10 }}><Stamp style={{ fontSize: 12, borderColor: correct ? 'var(--slate-3)' : 'var(--ox-3)', color: correct ? 'var(--slate-3)' : 'var(--ox-3)' }}>{correct ? 'SOLVED' : 'MISTRIAL'}</Stamp></div>
-          </div>
-          <div class="col" style={{ gap: 12, padding: 18 }}>
-            <div class="between">
-              <div class="col" style={{ gap: 3 }}>
-                <span class="t-label">CASE FILE</span>
-                <span class="t-mono" style={{ fontSize: 'calc(24px*var(--mono-scale))', color: 'var(--amber-2)' }}>{c.id}</span>
-              </div>
-              <div style={{ background: 'var(--ink-1)', padding: 4, boxShadow: 'inset 0 0 0 2px var(--ink-0)' }}><Portrait id={c.victim.sprite} px={3} /></div>
-            </div>
-            <hr class="hr-pixel" />
-            <div class="t-body" style={{ fontSize: 14 }}><span class="dim">{c.title}</span> — {c.victim.name}, {c.victim.role.split('—')[0].trim()}.</div>
-            <div class="row" style={{ gap: 8 }}>
-              {stats.map(([k, v], i) => (
-                <div key={i} class="grow" style={{ background: 'var(--ink-1)', padding: '8px 6px', textAlign: 'center', boxShadow: 'inset 0 0 0 2px var(--ink-0)' }}>
-                  <div class="t-mono amber" style={{ fontSize: 'calc(17px*var(--mono-scale))' }}>{v}</div>
-                  <div class="t-label" style={{ fontSize: 7 }}>{k}</div>
-                </div>
-              ))}
-            </div>
-            <div class="t-body amber" style={{ fontSize: 14, textAlign: 'center', fontStyle: 'italic' }}>Same city. Same body. Can you close it faster?</div>
-            <div class="row" style={{ gap: 8 }}>
-              <Btn variant="amber" className="grow" onClick={copy}>{copied ? '✓ ID Copied' : '⧉ Copy Case ID'}</Btn>
-              <Btn variant="ghost" onClick={() => g.nav('verdict', { result, done: true })}>Back</Btn>
-            </div>
-          </div>
-        </Panel>
-        <Btn variant="ghost" sm onClick={() => g.newCase()}>▸ Generate a New Case</Btn>
-      </div>
-    </div>
-  )
-}
+// Accusation builder · Verdict reveal · Share card. The verdict is computed server-side
+// (the sealed solution is read for the first time at /accuse); the client only displays it.
+import { useEffect, useState } from 'preact/hooks'
+
+import { accuse } from '../api'
+import { useGame } from '../store'
+import type { VerdictResult } from '../types'
+import { playSfx } from '../ui/audio'
+import { Btn, Chip, DialoguePanel, EvIcon, Hud, Panel, Portrait, Scene, Stamp, perpNoun } from '../ui/components'
+
+
+export function AccusationScreen() {
+  const g = useGame()
+  const c = g.case
+  const a = g.state.accuse
+  const [submitting, setSubmitting] = useState(false)
+  const [err, setErr] = useState<string | null>(null)
+  const set = (field: 'suspect' | 'motive' | 'evidence', value: unknown) => g.dispatch({ type: 'ACCUSE', field, value })
+  const toggleEv = (id: string) => set('evidence', a.evidence.includes(id) ? a.evidence.filter((x) => x !== id) : [...a.evidence, id])
+  const ready = !!a.suspect && !!a.motive && a.evidence.length >= 1
+
+  // Smart defaults, filled ONCE on mount and only into empty fields: the suspect you
+  // came from (CORNERED chip) and the evidence that actually rattled someone.
+  useEffect(() => {
+    const pre = g.state.payload.suspect as string | undefined
+    if (pre && !a.suspect && c.suspects.some((s) => s.id === pre)) set('suspect', pre)
+    if (!a.evidence.length) {
+      const hits = c.evidence.filter((e) => (g.state.evHits[e.id] || []).length > 0).map((e) => e.id)
+      if (hits.length) set('evidence', hits)
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [])
+
+  const rattledBy = (evId: string): string => {
+    const sids = g.state.evHits[evId] || []
+    if (!sids.length) return ''
+    const first = c.suspects.find((s) => s.id === sids[0])
+    if (!first) return ''
+    const name = first.name.split(' ')[0].toUpperCase()
+    return sids.length > 1 ? `★ RATTLED ${name} +${sids.length - 1}` : `★ RATTLED ${name}`
+  }
+
+  const submit = async () => {
+    if (!ready || submitting) return
+    playSfx('accuse')
+    setSubmitting(true)
+    setErr(null)
+    try {
+      const result = await accuse(g.runId, { suspectId: a.suspect!, motiveId: a.motive!, evidenceIds: a.evidence })
+      g.nav('verdict', { result })
+    } catch {
+      setErr('The line dropped. Try closing the case again.')
+      setSubmitting(false)
+    }
+  }
+
+  return (
+    <div class="app__view" style={{ background: 'var(--ink-0)' }}>
+      <Hud title="THE ACCUSATION" sub="THIS CANNOT BE UNDONE" right={<Btn sm variant="ghost" onClick={() => g.nav('board')}>Back</Btn>} />
+      <div style={{ position: 'absolute', inset: 0, top: 56, background: 'radial-gradient(70% 60% at 50% 30%, rgba(135,41,42,.10), transparent 70%)', pointerEvents: 'none' }} />
+      <div class="screen-pad">
+        <div class="maxw" style={{ maxWidth: 1000 }}>
+          <div class="col" style={{ gap: 20 }}>
+            <section>
+              <div class="t-display ox" style={{ fontSize: 13, marginBottom: 4 }}>1 — NAME THE {perpNoun(c.kind).toUpperCase()}</div>
+              <div class="t-body dim" style={{ fontSize: 12, marginBottom: 10 }}>Who did it?</div>
+              <div class="grid-4">
+                {c.suspects.map((s) => (
+                  <Panel key={s.id} variant={a.suspect === s.id ? 'ox' : undefined} style={{ padding: 10, cursor: 'pointer', textAlign: 'center' }} onClick={() => set('suspect', s.id)}>
+                    <div class="center" style={{ background: 'var(--ink-1)', boxShadow: 'inset 0 0 0 2px var(--ink-0)', padding: 5, marginBottom: 8 }}><Portrait id={s.sprite} px={4} blink={a.suspect === s.id} gender={s.gender} accent={s.accentColor} /></div>
+                    <div class="t-display" style={{ fontSize: 9, color: a.suspect === s.id ? 'var(--ox-3)' : 'var(--bone-3)' }}>{s.name}</div>
+                    <div class="t-label" style={{ marginTop: 3 }}>{s.tag}</div>
+                  </Panel>
+                ))}
+              </div>
+            </section>
+
+            <section>
+              <div class="t-display ox" style={{ fontSize: 13, marginBottom: 4 }}>2 — THE MOTIVE</div>
+              <div class="t-body dim" style={{ fontSize: 12, marginBottom: 10 }}>Why? Pick the motive that fits what you heard.</div>
+              <div class="grid-2">
+                {c.motives.map((m) => (
+                  <Panel key={m.id} variant={a.motive === m.id ? 'amber' : undefined} style={{ padding: 12, cursor: 'pointer' }} onClick={() => set('motive', m.id)}>
+                    <div class="row" style={{ gap: 10, alignItems: 'center' }}>
+                      <span style={{ width: 16, height: 16, flexShrink: 0, background: a.motive === m.id ? 'var(--amber-2)' : 'var(--ink-1)', boxShadow: 'inset 0 0 0 2px var(--ink-0)' }} />
+                      <span class="t-body" style={{ fontSize: 14 }}>{m.text}</span>
+                    </div>
+                  </Panel>
+                ))}
+              </div>
+            </section>
+
+            <section>
+              <div class="t-display ox" style={{ fontSize: 13, marginBottom: 4 }}>3 — ATTACH SUPPORTING EVIDENCE</div>
+              <div class="t-body dim" style={{ fontSize: 12, marginBottom: 10 }}>What proves it? The exhibits that made them crack are pre-checked.</div>
+              <div class="row wrap" style={{ gap: 10 }}>
+                {c.evidence.map((e) => {
+                  const on = a.evidence.includes(e.id)
+                  const badge = rattledBy(e.id)
+                  return (
+                    <button key={e.id} onClick={() => toggleEv(e.id)} style={{ border: 0, background: 'transparent', padding: 0, cursor: 'pointer' }}>
+                      <Panel variant={on ? 'amber' : undefined} style={{ padding: 8 }}>
+                        <div class="row" style={{ gap: 8, alignItems: 'center' }}>
+                          <div style={{ background: 'var(--ink-1)', padding: 3 }}><EvIcon icon={e.icon} px={2} /></div>
+                          <span class="t-display" style={{ fontSize: 8, color: on ? 'var(--amber-2)' : 'var(--bone-2)' }}>{e.name}</span>
+                          {badge && <Chip variant="ox">{badge}</Chip>}
+                          {on && <span class="amber">✓</span>}
+                        </div>
+                      </Panel>
+                    </button>
+                  )
+                })}
+              </div>
+            </section>
+
+            <Panel variant="ox" className="between wrap" style={{ gap: 12, padding: 16 }}>
+              <div class="t-body" style={{ fontSize: 14, maxWidth: 460 }}>
+                {err ? <span class="ox">{err}</span> : ready ? (
+                  <>You are about to charge <span class="ox t-display" style={{ fontSize: 12 }}>{c.suspects.find((s) => s.id === a.suspect)!.name}</span> as the {perpNoun(c.kind)} in the case of {c.victim.name}.</>
+                ) : (
+                  `Select the ${perpNoun(c.kind)}, a motive, and at least one exhibit to proceed.`
+                )}
+              </div>
+              <Btn variant="ox" disabled={!ready || submitting} style={{ fontSize: 13, padding: '15px 26px' }} onClick={submit}>
+                {submitting ? 'Closing…' : 'Close the Case ▸▸'}
+              </Btn>
+            </Panel>
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export function VerdictScreen() {
+  const g = useGame()
+  const c = g.case
+  const result = g.state.payload.result as VerdictResult | undefined
+  const instant = g.state.payload.done === true // returning from Share - show it finished, no replay
+  const [phase, setPhase] = useState(instant ? 2 : 0)
+  useEffect(() => {
+    if (instant) return
+    if (result) playSfx(result.correct ? 'success' : 'fail')
+    const t1 = setTimeout(() => setPhase(1), 700)
+    const t2 = setTimeout(() => setPhase(2), 2200)
+    return () => {
+      clearTimeout(t1)
+      clearTimeout(t2)
+    }
+  }, [])
+
+  if (!result) {
+    return (
+      <div class="app__view screen-center">
+        <Panel className="col center" style={{ gap: 14, padding: 24 }}>
+          <span class="t-display amber">NO ACCUSATION ON FILE</span>
+          <Btn variant="amber" onClick={() => g.nav('accuse')}>Build the accusation ▸</Btn>
+        </Panel>
+      </div>
+    )
+  }
+
+  const correct = result.correct
+  const killer = c.suspects.find((s) => s.id === result.verdict.killerId)
+  const killerSprite = killer?.sprite || c.victim.sprite
+  const killerGender = killer?.gender
+  const stats = result.stats?.length ? result.stats : g.runStats()
+  return (
+    <div class="app__view" style={{ background: 'var(--ink-0)', position: 'relative' }}>
+      <Scene name={c.scene} w={320} h={200} anim cover style={{ position: 'absolute', inset: 0, width: '100%', height: '100%', opacity: 0.5 }} />
+      <div class="fx-scanlines" style={{ position: 'absolute', inset: 0, opacity: 0.4 }} />
+      <div style={{ position: 'absolute', inset: 0, background: 'radial-gradient(80% 70% at 50% 40%, transparent 20%, rgba(8,11,16,.85) 80%)' }} />
+      <div class="screen-center" style={{ position: 'relative', zIndex: 2 }}>
+        <div class="col center" style={{ gap: 20, maxWidth: 720, textAlign: 'center' }}>
+          {phase >= 0 && (
+            <Stamp slam={!instant} style={{ fontSize: 'clamp(16px,4vw,26px)', borderColor: correct ? 'var(--slate-3)' : 'var(--ox-3)', color: correct ? 'var(--slate-3)' : 'var(--ox-3)' }}>
+              {result.verdict.stamp}
+            </Stamp>
+          )}
+          {phase >= 1 && (
+            <div class="col center" style={{ gap: 6 }}>
+              <div style={{ background: 'var(--ink-1)', boxShadow: `inset 0 0 0 3px ${correct ? 'var(--slate-2)' : 'var(--ox-2)'}`, padding: 6 }}><Portrait id={killerSprite} px={5} gender={killerGender} accent={killer?.accentColor} /></div>
+              <span class="t-display amber" style={{ fontSize: 11 }}>{result.verdict.killerName}</span>
+              <span class="t-label">THE {perpNoun(c.kind).toUpperCase()}</span>
+            </div>
+          )}
+          {phase >= 2 && (
+            <>
+              <Panel style={{ maxWidth: 640 }}>
+                <DialoguePanel who={correct ? 'THE TRUTH' : 'THE TRUTH ESCAPES'} text={result.verdict.truth} speed={g.state.tweaks.typeSpeed || 16} tag={correct ? null : 'WRONG'} />
+              </Panel>
+              {result.score && (
+                <div class="t-mono amber" style={{ fontSize: 'calc(18px*var(--mono-scale))' }}>SCORE {result.score.points}/{result.score.max}</div>
+              )}
+              <div class="row wrap center" style={{ gap: 10 }}>
+                {stats.map(([k, v], i) => (
+                  <Panel key={i} style={{ padding: '10px 16px', textAlign: 'center' }}>
+                    <div class="t-mono amber" style={{ fontSize: 'calc(20px*var(--mono-scale))' }}>{v}</div>
+                    <div class="t-label" style={{ marginTop: 3 }}>{k}</div>
+                  </Panel>
+                ))}
+              </div>
+              <div class="row wrap center" style={{ gap: 10 }}>
+                <Btn variant="amber" onClick={() => g.nav('share', { result })}>Share Case Card ▸</Btn>
+                <Btn variant="ghost" onClick={() => g.newCase()}>New Case</Btn>
+              </div>
+            </>
+          )}
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export function ShareScreen() {
+  const g = useGame()
+  const c = g.case
+  const result = g.state.payload.result as VerdictResult | undefined
+  const correct = !!result?.correct
+  const stats = result?.stats?.length ? result.stats : g.runStats()
+  const [copied, setCopied] = useState(false)
+  const copy = () => {
+    try {
+      navigator.clipboard.writeText(c.id)
+    } catch {
+      /* ignore */
+    }
+    setCopied(true)
+    setTimeout(() => setCopied(false), 1600)
+  }
+  return (
+    <div class="app__view screen-center" style={{ background: 'var(--ink-0)' }}>
+      <div class="col center" style={{ gap: 16, width: '100%' }}>
+        <Panel variant="amber" style={{ width: 'min(440px,92vw)', padding: 0, overflow: 'hidden' }}>
+          <div style={{ position: 'relative', height: 140 }}>
+            <Scene name={c.scene} w={240} h={140} anim style={{ width: '100%', height: '100%', objectFit: 'cover' }} />
+            <div style={{ position: 'absolute', inset: 0, background: 'linear-gradient(transparent, var(--ink-2))' }} />
+            <div style={{ position: 'absolute', top: 10, left: 12 }}><span class="t-label" style={{ color: 'var(--amber-2)', letterSpacing: '.2em' }}>CASE ZERO</span></div>
+            <div style={{ position: 'absolute', bottom: 8, right: 10 }}><Stamp style={{ fontSize: 12, borderColor: correct ? 'var(--slate-3)' : 'var(--ox-3)', color: correct ? 'var(--slate-3)' : 'var(--ox-3)' }}>{correct ? 'SOLVED' : 'MISTRIAL'}</Stamp></div>
+          </div>
+          <div class="col" style={{ gap: 12, padding: 18 }}>
+            <div class="between">
+              <div class="col" style={{ gap: 3 }}>
+                <span class="t-label">CASE FILE</span>
+                <span class="t-mono" style={{ fontSize: 'calc(24px*var(--mono-scale))', color: 'var(--amber-2)' }}>{c.id}</span>
+              </div>
+              <div style={{ background: 'var(--ink-1)', padding: 4, boxShadow: 'inset 0 0 0 2px var(--ink-0)' }}><Portrait id={c.victim.sprite} px={3} /></div>
+            </div>
+            <hr class="hr-pixel" />
+            <div class="t-body" style={{ fontSize: 14 }}><span class="dim">{c.title}</span> — {c.victim.name}, {c.victim.role.split('—')[0].trim()}.</div>
+            <div class="row" style={{ gap: 8 }}>
+              {stats.map(([k, v], i) => (
+                <div key={i} class="grow" style={{ background: 'var(--ink-1)', padding: '8px 6px', textAlign: 'center', boxShadow: 'inset 0 0 0 2px var(--ink-0)' }}>
+                  <div class="t-mono amber" style={{ fontSize: 'calc(17px*var(--mono-scale))' }}>{v}</div>
+                  <div class="t-label" style={{ fontSize: 7 }}>{k}</div>
+                </div>
+              ))}
+            </div>
+            <div class="t-body amber" style={{ fontSize: 14, textAlign: 'center', fontStyle: 'italic' }}>Same city. Same body. Can you close it faster?</div>
+            <div class="row" style={{ gap: 8 }}>
+              <Btn variant="amber" className="grow" onClick={copy}>{copied ? '✓ ID Copied' : '⧉ Copy Case ID'}</Btn>
+              <Btn variant="ghost" onClick={() => g.nav('verdict', { result, done: true })}>Back</Btn>
+            </div>
+          </div>
+        </Panel>
+        <Btn variant="ghost" sm onClick={() => g.newCase()}>▸ Generate a New Case</Btn>
+      </div>
+    </div>
+  )
+}

web/src/screens/evidence.tsx

@@ -1,156 +1,158 @@
-// Evidence inspector — per-type layouts. Type is chosen from the payload shape so it
-// generalizes to any generated exhibit.
-import { useEffect, useState } from 'preact/hooks'
-
-import { useGame } from '../store'
-import type { Evidence } from '../types'
-import { BottomNav, Btn, Chip, EvIcon, EvidenceCard, ExhibitArt, Hud, Panel, Scene } from '../ui/components'
-
-function PhoneThread({ e }: { e: Evidence }) {
-  return (
-    <Panel tab="DEVICE — MESSAGES" style={{ maxWidth: 420 }}>
-      <div style={{ background: 'var(--ink-0)', boxShadow: 'inset 0 0 0 3px var(--ink-1)', padding: 12, display: 'flex', flexDirection: 'column', gap: 8 }}>
-        <div class="center t-label" style={{ marginBottom: 4 }}>● ENCRYPTED ●</div>
-        {(e.thread || []).map((m, i) => (
-          <div key={i} style={{ alignSelf: m.from === 'me' ? 'flex-end' : 'flex-start', maxWidth: '82%' }}>
-            <div class="t-mono dim" style={{ fontSize: 'calc(11px*var(--mono-scale))', textAlign: m.from === 'me' ? 'right' : 'left', marginBottom: 2 }}>{m.who} · {m.t}</div>
-            <div class="t-body" style={{ fontSize: 14, padding: '8px 10px', lineHeight: 1.4, background: m.from === 'me' ? 'var(--slate-1)' : 'var(--ink-3)', color: m.from === 'me' ? 'var(--bone-3)' : 'var(--bone-2)', boxShadow: 'inset 0 0 0 2px var(--ink-0)' }}>{m.m}</div>
-          </div>
-        ))}
-      </div>
-    </Panel>
-  )
-}
-
-function Voicemail({ e }: { e: Evidence }) {
-  const [playing, setPlaying] = useState(false)
-  const [t, setT] = useState(0)
-  useEffect(() => {
-    if (!playing) return
-    const id = setInterval(() => setT((v) => { if (v >= 100) { setPlaying(false); return 100 } return v + 2.5 }), 90)
-    return () => clearInterval(id)
-  }, [playing])
-  const bars = 48
-  return (
-    <Panel tab="AUDIO — VOICEMAIL" variant="amber">
-      <div class="row" style={{ gap: 14, alignItems: 'center' }}>
-        <Btn variant="amber" onClick={() => { if (t >= 100) setT(0); setPlaying((p) => !p) }} style={{ fontSize: 16, width: 52, height: 52 }}>{playing ? '❚❚' : '▶'}</Btn>
-        <div class="grow">
-          <div style={{ display: 'flex', alignItems: 'center', gap: 2, height: 44 }}>
-            {Array.from({ length: bars }).map((_, i) => {
-              const h = 8 + Math.abs(Math.sin(i * 0.7) * 30) + (i % 3) * 5
-              const on = (i / bars) * 100 <= t
-              const live = playing && Math.abs((i / bars) * 100 - t) < 6
-              return <span key={i} style={{ flex: 1, height: live ? h + 8 : h, background: on ? 'var(--amber-2)' : 'var(--slate-1)', transition: 'height .08s' }} />
-            })}
-          </div>
-          <div class="between" style={{ marginTop: 6 }}>
-            <span class="t-mono dim" style={{ fontSize: 'calc(13px*var(--mono-scale))' }}>{playing || t > 0 ? '0:' + String(Math.floor((t / 100) * 19)).padStart(2, '0') : '0:00'}</span>
-            <span class="t-mono dim" style={{ fontSize: 'calc(13px*var(--mono-scale))' }}>{e.dur}</span>
-          </div>
-        </div>
-      </div>
-      <hr class="hr-pixel" style={{ margin: '12px 0' }} />
-      <p class="t-body" style={{ fontSize: 14, fontStyle: 'italic', color: t > 30 ? 'var(--bone-3)' : 'var(--bone-1)' }}>{e.transcript}</p>
-    </Panel>
-  )
-}
-
-function KeycardTable({ e }: { e: Evidence }) {
-  return (
-    <Panel tab="ACCESS LOG — RFID" style={{ maxWidth: 560 }}>
-      <div style={{ display: 'grid', gridTemplateColumns: 'auto 1fr auto auto', gap: 0, fontFamily: 'var(--f-mono)', fontSize: 'calc(15px*var(--mono-scale))' }}>
-        {['TIME', 'DOOR', 'CARD', ''].map((h, i) => <div key={i} class="t-label" style={{ padding: '6px 8px', background: 'var(--ink-1)' }}>{h}</div>)}
-        {(e.rows || []).map((r, i) => (
-          <>
-            {r.slice(0, 3).map((cell, j) => <div key={`${i}-${j}`} style={{ padding: '8px', color: r[3] === 'flag' ? 'var(--ox-3)' : 'var(--bone-2)', boxShadow: 'inset 0 2px 0 var(--ink-1)' }}>{cell}</div>)}
-            <div key={`${i}-s`} style={{ padding: '8px', boxShadow: 'inset 0 2px 0 var(--ink-1)' }}>{r[3] === 'flag' ? <Chip variant="ox">⚑</Chip> : <span class="dim">ok</span>}</div>
-          </>
-        ))}
-      </div>
-    </Panel>
-  )
-}
-
-function ImageExhibit({ e, scene, tab, rec }: { e: Evidence; scene: string; tab: string; rec?: boolean }) {
-  return (
-    <Panel tab={tab} variant={rec ? 'ox' : undefined} style={{ maxWidth: 520 }}>
-      <div style={{ position: 'relative', aspectRatio: rec ? '4/3' : '16/10', boxShadow: 'inset 0 0 0 3px var(--ink-0)', border: rec ? undefined : '6px solid var(--bone-2)' }}>
-        <Scene name={scene} w={240} h={180} style={{ width: '100%', height: '100%' }} />
-        <div class="fx-scanlines" style={{ position: 'absolute', inset: 0, opacity: rec ? 0.5 : 0 }} />
-        {rec && <div class="t-mono ox" style={{ position: 'absolute', top: 6, left: 8 }}>● REC {e.time.replace(/[^\d:]/g, '')}</div>}
-        <div class="t-mono" style={{ position: 'absolute', bottom: 8, right: 10, color: 'var(--ox-3)', fontSize: 'calc(13px*var(--mono-scale))' }}>▣ EVIDENCE</div>
-      </div>
-      {e.detail && <p class="t-body" style={{ fontSize: 14, marginTop: 10, whiteSpace: 'pre-line' }}>{e.detail}</p>}
-    </Panel>
-  )
-}
-
-function PaperItem({ e }: { e: Evidence }) {
-  return (
-    <Panel tab="PHYSICAL EXHIBIT" style={{ maxWidth: 440 }}>
-      <div style={{ border: '6px solid var(--bone-2)', boxShadow: '3px 4px 0 rgba(0,0,0,.4)', marginBottom: 14, background: 'var(--ink-0)' }}>
-        <ExhibitArt e={e} style={{ width: '100%', height: 'auto' }} />
-      </div>
-      <div style={{ background: 'var(--bone-2)', color: 'var(--ink-1)', padding: 16, fontFamily: 'var(--f-mono)', fontSize: 'calc(16px*var(--mono-scale))', lineHeight: 1.5, boxShadow: '3px 4px 0 rgba(0,0,0,.4)', whiteSpace: 'pre-wrap', transform: 'rotate(-1deg)' }}>{e.detail}</div>
-    </Panel>
-  )
-}
-
-function EvidenceDetail({ e }: { e: Evidence }) {
-  const g = useGame()
-  if (e.thread) return <PhoneThread e={e} />
-  if (e.transcript) return <Voicemail e={e} />
-  if (e.rows) return <KeycardTable e={e} />
-  if (e.type === 'IMAGE') {
-    const cam = e.icon === 'cctv'
-    return <ImageExhibit e={e} scene={cam ? 'mezzanine' : g.case.scene} tab={cam ? 'CAM — STILL' : 'FORENSIC — SCENE'} rec={cam} />
-  }
-  return <PaperItem e={e} />
-}
-
-export function EvidenceScreen() {
-  const g = useGame()
-  const c = g.case
-  const [focus, setFocus] = useState<string>((g.state.payload.focus as string) || c.evidence[0].id)
-  const e = c.evidence.find((x) => x.id === focus)!
-  const pinned = g.state.pinned.includes(focus)
-  return (
-    <div class="app__view">
-      <Hud title="EVIDENCE LOCKER" sub={`EXHIBIT — ${e.name}`} right={<Btn sm variant="ghost" onClick={() => g.nav('board')}>Board</Btn>} />
-      <div class="interro" style={{ gridTemplateColumns: g.mode === 'mobile' ? '1fr' : '260px 1fr' }}>
-        <div class="interro__right scroll-y" style={{ padding: 12, gap: 8, display: g.mode === 'mobile' ? 'none' : 'flex', flexDirection: 'column' }}>
-          <span class="t-label" style={{ marginBottom: 4 }}>{c.evidence.length} EXHIBITS RECOVERED</span>
-          {c.evidence.map((x) => <EvidenceCard key={x.id} e={x} small active={x.id === focus} onClick={() => setFocus(x.id)} />)}
-        </div>
-        <div class="screen-pad" style={{ background: 'var(--ink-0)' }}>
-          <div class="maxw" style={{ maxWidth: 820 }}>
-            {g.mode === 'mobile' && (
-              <div class="row" style={{ gap: 8, overflowX: 'auto', marginBottom: 12, paddingBottom: 4 }}>
-                {c.evidence.map((x) => <Btn key={x.id} sm variant={x.id === focus ? 'amber' : 'ghost'} onClick={() => setFocus(x.id)}>{x.name.split(' ')[0]}</Btn>)}
-              </div>
-            )}
-            <div class="row between wrap" style={{ marginBottom: 14, gap: 10 }}>
-              <div class="row" style={{ gap: 12, alignItems: 'center' }}>
-                <div style={{ background: 'var(--ink-2)', boxShadow: 'inset 0 0 0 3px var(--ink-0)', padding: 6 }}><EvIcon icon={e.icon} px={4} /></div>
-                <div class="col" style={{ gap: 4 }}>
-                  <h2 class="t-display" style={{ fontSize: 18, color: 'var(--bone-3)' }}>{e.name}</h2>
-                  <div class="row" style={{ gap: 8 }}><Chip variant="amber">{e.type}</Chip><span class="t-mono dim" style={{ fontSize: 'calc(14px*var(--mono-scale))' }}>{e.time}</span></div>
-                </div>
-              </div>
-            </div>
-            <p class="t-body" style={{ marginBottom: 14, color: 'var(--bone-2)' }}>{e.summary}</p>
-            <EvidenceDetail e={e} key={e.id} />
-            <div class="t-label" style={{ margin: '12px 2px' }}>↳ {e.found}</div>
-            <div class="row wrap" style={{ gap: 10, marginTop: 6 }}>
-              <Btn variant={pinned ? 'ghost' : 'amber'} onClick={() => g.dispatch({ type: 'PIN', ev: focus })}>{pinned ? '✓ Pinned to Board' : '▸ Pin to Board'}</Btn>
-              <Btn variant="ox" onClick={() => g.nav('interro', { suspect: c.suspects[0].id })}>Use in Interrogation</Btn>
-              <Btn variant="ghost" onClick={() => g.nav('flashback')}>Reconstruct ▸</Btn>
-            </div>
-          </div>
-        </div>
-      </div>
-      <BottomNav />
-    </div>
-  )
-}
+// Evidence inspector — per-type layouts. Type is chosen from the payload shape so it
+// generalizes to any generated exhibit.
+import { useEffect, useState } from 'preact/hooks'
+
+import { useGame } from '../store'
+import type { Evidence } from '../types'
+import { BottomNav, Btn, Chip, EvIcon, EvidenceCard, ExhibitArt, Hud, Panel, Scene } from '../ui/components'
+
+function PhoneThread({ e }: { e: Evidence }) {
+  return (
+    <Panel tab="DEVICE — MESSAGES" style={{ maxWidth: 420 }}>
+      <div style={{ background: 'var(--ink-0)', boxShadow: 'inset 0 0 0 3px var(--ink-1)', padding: 12, display: 'flex', flexDirection: 'column', gap: 8 }}>
+        <div class="center t-label" style={{ marginBottom: 4 }}>● ENCRYPTED ●</div>
+        {(e.thread || []).map((m, i) => (
+          <div key={i} style={{ alignSelf: m.from === 'me' ? 'flex-end' : 'flex-start', maxWidth: '82%' }}>
+            <div class="t-mono dim" style={{ fontSize: 'calc(11px*var(--mono-scale))', textAlign: m.from === 'me' ? 'right' : 'left', marginBottom: 2 }}>{m.who} · {m.t}</div>
+            <div class="t-body" style={{ fontSize: 14, padding: '8px 10px', lineHeight: 1.4, background: m.from === 'me' ? 'var(--slate-1)' : 'var(--ink-3)', color: m.from === 'me' ? 'var(--bone-3)' : 'var(--bone-2)', boxShadow: 'inset 0 0 0 2px var(--ink-0)' }}>{m.m}</div>
+          </div>
+        ))}
+      </div>
+    </Panel>
+  )
+}
+
+function Voicemail({ e }: { e: Evidence }) {
+  const [playing, setPlaying] = useState(false)
+  const [t, setT] = useState(0)
+  useEffect(() => {
+    if (!playing) return
+    const id = setInterval(() => setT((v) => { if (v >= 100) { setPlaying(false); return 100 } return v + 2.5 }), 90)
+    return () => clearInterval(id)
+  }, [playing])
+  const bars = 48
+  return (
+    <Panel tab="AUDIO — VOICEMAIL" variant="amber">
+      <div class="row" style={{ gap: 14, alignItems: 'center' }}>
+        <Btn variant="amber" onClick={() => { if (t >= 100) setT(0); setPlaying((p) => !p) }} style={{ fontSize: 16, width: 52, height: 52 }}>{playing ? '❚❚' : '▶'}</Btn>
+        <div class="grow">
+          <div style={{ display: 'flex', alignItems: 'center', gap: 2, height: 44 }}>
+            {Array.from({ length: bars }).map((_, i) => {
+              const h = 8 + Math.abs(Math.sin(i * 0.7) * 30) + (i % 3) * 5
+              const on = (i / bars) * 100 <= t
+              const live = playing && Math.abs((i / bars) * 100 - t) < 6
+              return <span key={i} style={{ flex: 1, height: live ? h + 8 : h, background: on ? 'var(--amber-2)' : 'var(--slate-1)', transition: 'height .08s' }} />
+            })}
+          </div>
+          <div class="between" style={{ marginTop: 6 }}>
+            <span class="t-mono dim" style={{ fontSize: 'calc(13px*var(--mono-scale))' }}>{playing || t > 0 ? '0:' + String(Math.floor((t / 100) * 19)).padStart(2, '0') : '0:00'}</span>
+            <span class="t-mono dim" style={{ fontSize: 'calc(13px*var(--mono-scale))' }}>{e.dur}</span>
+          </div>
+        </div>
+      </div>
+      <hr class="hr-pixel" style={{ margin: '12px 0' }} />
+      <p class="t-body" style={{ fontSize: 14, fontStyle: 'italic', color: t > 30 ? 'var(--bone-3)' : 'var(--bone-1)' }}>{e.transcript}</p>
+    </Panel>
+  )
+}
+
+function KeycardTable({ e }: { e: Evidence }) {
+  return (
+    <Panel tab="ACCESS LOG — RFID" style={{ maxWidth: 560 }}>
+      <div style={{ display: 'grid', gridTemplateColumns: 'auto 1fr auto auto', gap: 0, fontFamily: 'var(--f-mono)', fontSize: 'calc(15px*var(--mono-scale))' }}>
+        {['TIME', 'DOOR', 'CARD', ''].map((h, i) => <div key={i} class="t-label" style={{ padding: '6px 8px', background: 'var(--ink-1)' }}>{h}</div>)}
+        {(e.rows || []).map((r, i) => (
+          <>
+            {r.slice(0, 3).map((cell, j) => <div key={`${i}-${j}`} style={{ padding: '8px', color: r[3] === 'flag' ? 'var(--ox-3)' : 'var(--bone-2)', boxShadow: 'inset 0 2px 0 var(--ink-1)' }}>{cell}</div>)}
+            <div key={`${i}-s`} style={{ padding: '8px', boxShadow: 'inset 0 2px 0 var(--ink-1)' }}>{r[3] === 'flag' ? <Chip variant="ox">⚑</Chip> : <span class="dim">ok</span>}</div>
+          </>
+        ))}
+      </div>
+    </Panel>
+  )
+}
+
+function ImageExhibit({ e, scene, tab, rec }: { e: Evidence; scene: string; tab: string; rec?: boolean }) {
+  return (
+    <Panel tab={tab} variant={rec ? 'ox' : undefined} style={{ maxWidth: 520 }}>
+      <div style={{ position: 'relative', aspectRatio: rec ? '4/3' : '16/10', boxShadow: 'inset 0 0 0 3px var(--ink-0)', border: rec ? undefined : '6px solid var(--bone-2)' }}>
+        <Scene name={scene} w={240} h={180} style={{ width: '100%', height: '100%' }} />
+        <div class="fx-scanlines" style={{ position: 'absolute', inset: 0, opacity: rec ? 0.5 : 0 }} />
+        {rec && <div class="t-mono ox" style={{ position: 'absolute', top: 6, left: 8 }}>● REC {e.time.replace(/[^\d:]/g, '')}</div>}
+        <div class="t-mono" style={{ position: 'absolute', bottom: 8, right: 10, color: 'var(--ox-3)', fontSize: 'calc(13px*var(--mono-scale))' }}>▣ EVIDENCE</div>
+      </div>
+      {e.detail && <p class="t-body" style={{ fontSize: 14, marginTop: 10, whiteSpace: 'pre-line' }}>{e.detail}</p>}
+    </Panel>
+  )
+}
+
+function PaperItem({ e }: { e: Evidence }) {
+  return (
+    <Panel tab="PHYSICAL EXHIBIT" style={{ maxWidth: 440 }}>
+      <div style={{ border: '6px solid var(--bone-2)', boxShadow: '3px 4px 0 rgba(0,0,0,.4)', marginBottom: 14, background: 'var(--ink-0)' }}>
+        <ExhibitArt e={e} style={{ width: '100%', height: 'auto' }} />
+      </div>
+      <div style={{ background: 'var(--bone-2)', color: 'var(--ink-1)', padding: 16, fontFamily: 'var(--f-mono)', fontSize: 'calc(16px*var(--mono-scale))', lineHeight: 1.5, boxShadow: '3px 4px 0 rgba(0,0,0,.4)', whiteSpace: 'pre-wrap', transform: 'rotate(-1deg)' }}>{e.detail}</div>
+    </Panel>
+  )
+}
+
+function EvidenceDetail({ e }: { e: Evidence }) {
+  const g = useGame()
+  if (e.thread) return <PhoneThread e={e} />
+  if (e.transcript) return <Voicemail e={e} />
+  if (e.rows) return <KeycardTable e={e} />
+  if (e.type === 'IMAGE') {
+    const cam = e.icon === 'cctv'
+    // CCTV frames show the place the exhibit was recovered from ("Recovered from X.").
+    const loc = (e.found || '').replace(/^Recovered from /i, '').replace(/\.$/, '').trim()
+    return <ImageExhibit e={e} scene={cam ? (loc || g.case.scene) : g.case.scene} tab={cam ? 'CAM — STILL' : 'FORENSIC — SCENE'} rec={cam} />
+  }
+  return <PaperItem e={e} />
+}
+
+export function EvidenceScreen() {
+  const g = useGame()
+  const c = g.case
+  const [focus, setFocus] = useState<string>((g.state.payload.focus as string) || c.evidence[0].id)
+  const e = c.evidence.find((x) => x.id === focus)!
+  const pinned = g.state.pinned.includes(focus)
+  return (
+    <div class="app__view">
+      <Hud title="EVIDENCE LOCKER" sub={`EXHIBIT — ${e.name}`} right={<Btn sm variant="ghost" onClick={() => g.nav('board')}>Board</Btn>} />
+      <div class="interro" style={{ gridTemplateColumns: g.mode === 'mobile' ? '1fr' : '260px 1fr' }}>
+        <div class="interro__right scroll-y" style={{ padding: 12, gap: 8, display: g.mode === 'mobile' ? 'none' : 'flex', flexDirection: 'column' }}>
+          <span class="t-label" style={{ marginBottom: 4 }}>{c.evidence.length} EXHIBITS RECOVERED</span>
+          {c.evidence.map((x) => <EvidenceCard key={x.id} e={x} small active={x.id === focus} onClick={() => setFocus(x.id)} />)}
+        </div>
+        <div class="screen-pad" style={{ background: 'var(--ink-0)' }}>
+          <div class="maxw" style={{ maxWidth: 820 }}>
+            {g.mode === 'mobile' && (
+              <div class="row" style={{ gap: 8, overflowX: 'auto', marginBottom: 12, paddingBottom: 4 }}>
+                {c.evidence.map((x) => <Btn key={x.id} sm variant={x.id === focus ? 'amber' : 'ghost'} onClick={() => setFocus(x.id)}>{x.name.split(' ')[0]}</Btn>)}
+              </div>
+            )}
+            <div class="row between wrap" style={{ marginBottom: 14, gap: 10 }}>
+              <div class="row" style={{ gap: 12, alignItems: 'center' }}>
+                <div style={{ background: 'var(--ink-2)', boxShadow: 'inset 0 0 0 3px var(--ink-0)', padding: 6 }}><EvIcon icon={e.icon} px={4} /></div>
+                <div class="col" style={{ gap: 4 }}>
+                  <h2 class="t-display" style={{ fontSize: 18, color: 'var(--bone-3)' }}>{e.name}</h2>
+                  <div class="row" style={{ gap: 8 }}><Chip variant="amber">{e.type}</Chip><span class="t-mono dim" style={{ fontSize: 'calc(14px*var(--mono-scale))' }}>{e.time}</span></div>
+                </div>
+              </div>
+            </div>
+            <p class="t-body" style={{ marginBottom: 14, color: 'var(--bone-2)' }}>{e.summary}</p>
+            <EvidenceDetail e={e} key={e.id} />
+            <div class="t-label" style={{ margin: '12px 2px' }}>↳ {e.found}</div>
+            <div class="row wrap" style={{ gap: 10, marginTop: 6 }}>
+              <Btn variant={pinned ? 'ghost' : 'amber'} onClick={() => g.dispatch({ type: 'PIN', ev: focus })}>{pinned ? '✓ Pinned to Board' : '▸ Pin to Board'}</Btn>
+              <Btn variant="ox" onClick={() => g.nav('interro', { suspect: c.suspects[0].id })}>Use in Interrogation</Btn>
+              <Btn variant="ghost" onClick={() => g.nav('flashback')}>Reconstruct ▸</Btn>
+            </div>
+          </div>
+        </div>
+      </div>
+      <BottomNav />
+    </div>
+  )
+}

web/src/screens/interro.tsx

@@ -3,10 +3,11 @@
 import { useEffect, useRef, useState } from 'preact/hooks'
 
 import { interrogate } from '../api'
-import { useGame } from '../store'
+import { HOT_SUSPICION, useGame } from '../store'
 import type { Evidence, SuggestedQuestion } from '../types'
 import { playSfx, prepareSpeak, stopSpeak } from '../ui/audio'
 import { Btn, EvIcon, EvidenceCard, Hud, Panel, Portrait, Scene, SuspicionBar, TypeOnce } from '../ui/components'
+import { CrackBanner, DeltaFloater } from '../ui/juice'
 
 interface Pending {
   text: string
@@ -29,6 +30,8 @@ export function Interrogation() {
   const [talking, setTalking] = useState(false)
   const [tray, setTray] = useState(false)
   const [input, setInput] = useState('')
+  const [floater, setFloater] = useState<{ delta: number; id: number } | null>(null)
+  const [crack, setCrack] = useState(false)
   const scroller = useRef<HTMLDivElement>(null)
   const busy = thinking || !!pending
 
@@ -59,6 +62,25 @@ export function Interrogation() {
     try {
       const r = await interrogate(g.runId, sid, body)
       const tag = r.flags?.rattled ? 'RATTLED' : r.flags?.cornered ? 'CRACKING' : null
+      // Feedback moments: record what rattled whom, float the suspicion delta, and
+      // slam the banner the FIRST time this suspect's lie cracks.
+      const flags = r.flags || {}
+      const crackedNow = !!(flags.cornered || flags.contradictionExposed)
+      const firstCrack = crackedNow && !g.state.cracked[sid]
+      if (crackedNow || (flags.rattled && body.presentEvidenceId)) {
+        g.dispatch({
+          type: 'FLAG',
+          sid,
+          evId: body.presentEvidenceId,
+          kind: flags.contradictionExposed ? 'contradiction' : flags.cornered ? 'cornered' : 'rattled',
+        })
+      }
+      if (typeof r.suspicionDelta === 'number' && r.suspicionDelta !== 0) setFloater({ delta: r.suspicionDelta, id: Date.now() })
+      if (firstCrack) {
+        setCrack(true)
+        playSfx('success')
+        setTimeout(() => setCrack(false), 1700)
+      }
       // Synthesize the voice during the "thinking" beat so text + speech start together.
       const voice = await prepareSpeak(g.runId, sid, r.reply, () => setTalking(false))
       // Pace the typewriter to the audio so words land in step with the spoken line.
@@ -103,7 +125,13 @@ export function Interrogation() {
         sub={s.role}
         right={
           <>
-            <div style={{ width: g.mode === 'mobile' ? 96 : 180 }}><SuspicionBar value={susp} /></div>
+            <div class="col" style={{ width: g.mode === 'mobile' ? 96 : 180, position: 'relative' }}>
+              <SuspicionBar value={susp} />
+              {floater && <DeltaFloater key={floater.id} delta={floater.delta} />}
+              {susp >= HOT_SUSPICION && (
+                <button class="accuse-chip" onClick={() => g.nav('accuse', { suspect: sid })}>CORNERED — ACCUSE ▸</button>
+              )}
+            </div>
             <Btn sm variant="ghost" onClick={() => g.nav('board')}>Board</Btn>
           </>
         }
@@ -112,7 +140,8 @@ export function Interrogation() {
         <div class="interro__stage">
           <Scene name="interro" w={220} h={380} style={{ position: 'absolute', inset: 0, width: '100%', height: '100%' }} />
           <div style={{ position: 'absolute', inset: 0, background: 'radial-gradient(55% 45% at 50% 58%, rgba(224,164,76,.12), transparent 72%)' }} />
-          <div class="interro__sprite" style={{ bottom: '7%' }}><Portrait id={sid} px={px} gender={s.gender} talking={talking} /></div>
+          <div class="interro__sprite" style={{ bottom: '7%' }}><Portrait id={s.sprite} px={px} gender={s.gender} accent={s.accentColor} talking={talking} /></div>
+          {crack && <CrackBanner />}
           <div style={{ position: 'absolute', top: 12, left: 12, right: 12, zIndex: 4 }}>
             <Panel style={{ padding: 8, width: 'fit-content', maxWidth: '100%' }}>
               <span class="t-label">{s.tag}</span>

web/src/screens/suspects.tsx

@@ -4,6 +4,7 @@ import { useState } from 'preact/hooks'
 
 import { useGame } from '../store'
 import type { Suspect } from '../types'
+import { Checklist } from '../ui/checklist'
 import { BottomNav, Btn, Hud, Panel, SuspectCard } from '../ui/components'
 import { Board } from './board'
 
@@ -19,6 +20,7 @@ export function SuspectsScreen() {
         sub={`${c.suspects.length} SUSPECTS · TAP, THEN INTERROGATE`}
         right={<Btn sm variant="ghost" onClick={() => g.nav('accuse')}>Accuse</Btn>}
       />
+      <Checklist slim />
       <div class="screen-pad">
         <div class="col" style={{ gap: 10 }}>
           {c.suspects.map((s: Suspect) => {

web/src/store.tsx

@@ -31,10 +31,17 @@ export interface GameState {
   usedQ: Record<string, string[]>
   usedEv: Record<string, string[]>
   pinned: string[]
+  /** Suspects whose lie cracked (cornered / contradiction exposed) at least once. */
+  cracked: Record<string, boolean>
+  /** evidenceId -> suspect ids it rattled or cracked when presented. */
+  evHits: Record<string, string[]>
   accuse: AccuseState
   startedAt: number
 }
 
+/** A suspect at or above this suspicion is "cornered" — ready to accuse. */
+export const HOT_SUSPICION = 75
+
 type Action =
   | { type: 'NAV'; screen: Screen; payload?: Record<string, unknown> }
   | { type: 'SUSP_SET'; sid: string; value: number }
@@ -42,6 +49,7 @@ type Action =
   | { type: 'USEQ'; sid: string; qid: string }
   | { type: 'USEEV'; sid: string; ev: string }
   | { type: 'PIN'; ev: string }
+  | { type: 'FLAG'; sid: string; evId?: string; kind: 'rattled' | 'cornered' | 'contradiction' }
   | { type: 'ACCUSE'; field: keyof AccuseState; value: unknown }
 
 function reducer(s: GameState, a: Action): GameState {
@@ -58,6 +66,15 @@ function reducer(s: GameState, a: Action): GameState {
       return { ...s, usedEv: { ...s.usedEv, [a.sid]: [...(s.usedEv[a.sid] || []), a.ev] } }
     case 'PIN':
       return { ...s, pinned: s.pinned.includes(a.ev) ? s.pinned : [...s.pinned, a.ev] }
+    case 'FLAG': {
+      const cracked = a.kind !== 'rattled' ? { ...s.cracked, [a.sid]: true } : s.cracked
+      let { evHits } = s
+      if (a.evId) {
+        const cur = s.evHits[a.evId] || []
+        if (!cur.includes(a.sid)) evHits = { ...s.evHits, [a.evId]: [...cur, a.sid] }
+      }
+      return { ...s, cracked, evHits }
+    }
     case 'ACCUSE':
       return { ...s, accuse: { ...s.accuse, [a.field]: a.value } }
     default:
@@ -78,6 +95,8 @@ function initialState(c: PublicCase, screen: Screen = 'title'): GameState {
     usedQ: {},
     usedEv: {},
     pinned: [],
+    cracked: {},
+    evHits: {},
     accuse: { suspect: null, motive: null, evidence: [] },
     startedAt: Date.now(),
   }

web/src/styles/layout.css

@@ -356,3 +356,60 @@
     display:-webkit-box; -webkit-box-orient:vertical; -webkit-line-clamp:2;
   }
 }
+
+/* ============================================================
+   GUIDANCE & JUICE — checklist, case brief, feedback moments
+   ============================================================ */
+/* suspicion delta floater (interro hud) */
+.delta-float{
+  position:absolute; right:0; top:-16px; font-family:var(--f-display); font-size:11px;
+  color:var(--amber-2); text-shadow:2px 2px 0 var(--ink-0); pointer-events:none; z-index:30;
+  animation:deltaRise 1.1s steps(7) both;
+}
+.delta-float--big{ font-size:14px; color:var(--ox-3); }
+.delta-float--drop{ color:var(--slate-3); }
+@keyframes deltaRise{
+  0%{ transform:translateY(6px); opacity:0; }
+  15%,70%{ opacity:1; }
+  100%{ transform:translateY(-16px); opacity:0; }
+}
+
+/* "THE LIE CRACKS" banner over the interro stage */
+.crack-banner{ position:absolute; inset:0; z-index:6; display:flex; align-items:center;
+  justify-content:center; pointer-events:none; }
+.crack-banner__flash{ position:absolute; inset:0; background:var(--ox-2); animation:crackFlash .5s steps(3) both; }
+@keyframes crackFlash{ 0%{ opacity:.4; } 100%{ opacity:0; } }
+
+/* cornered CTA chip (under the interro suspicion bar) + pulsing accuse buttons */
+.accuse-chip{
+  font-family:var(--f-display); font-size:8px; letter-spacing:.08em; border:0; margin-top:4px;
+  background:var(--ox-2); color:var(--bone-3); padding:5px 8px; box-shadow:2px 2px 0 var(--ink-0);
+  animation:ctaPulse 1s steps(2) infinite; cursor:pointer; white-space:nowrap;
+}
+.accuse-cta--pulse{ animation:ctaPulse 1s steps(2) infinite; }
+@keyframes ctaPulse{ 50%{ filter:brightness(1.35); } }
+
+/* detective's checklist */
+.checklist{ display:flex; flex-direction:column; gap:4px; margin-top:8px; }
+.checklist__step{
+  display:flex; gap:6px; align-items:baseline;
+  font-family:var(--f-display); font-size:8px; letter-spacing:.06em; color:var(--bone-2);
+}
+.checklist__step--done{ color:var(--slate-3); text-decoration:line-through; }
+.checklist__box{ color:var(--amber-2); flex-shrink:0; }
+.checklist__step--done .checklist__box{ color:var(--slate-3); }
+.checklist--slim{
+  flex-direction:column; margin:0; padding:8px 12px; background:var(--ink-2);
+  box-shadow:inset 0 -3px 0 var(--ink-0); flex-shrink:0; z-index:15;
+}
+.checklist__toggle{
+  display:flex; justify-content:space-between; align-items:center; gap:8px;
+  background:transparent; border:0; padding:0; width:100%;
+}
+
+/* first-visit case brief overlay (board) */
+.brief-veil{
+  position:absolute; inset:0; z-index:25; background:rgba(8,11,16,.78);
+  display:flex; align-items:center; justify-content:center; padding:18px;
+}
+.brief-card{ width:min(380px,92%); animation:slideup .25s steps(6); }

web/src/tips.ts

@@ -0,0 +1,34 @@
+// One-time guidance memory: which partner nudges and per-case brief overlays this
+// browser has already seen. Falls back to an in-memory set in private mode, so
+// everything still fires exactly once per session there.
+const KEY = 'cz-tips'
+const CAP = 100
+
+const mem = new Set<string>()
+
+function stored(): string[] {
+  try {
+    const raw = localStorage.getItem(KEY)
+    if (!raw) return []
+    const data = JSON.parse(raw) as { v: 1; seen: string[] }
+    if (data?.v !== 1 || !Array.isArray(data.seen)) return []
+    return data.seen.filter((x) => typeof x === 'string')
+  } catch {
+    return []
+  }
+}
+
+export function hasSeen(key: string): boolean {
+  return mem.has(key) || stored().includes(key)
+}
+
+export function markSeen(key: string): void {
+  mem.add(key)
+  try {
+    const seen = stored().filter((x) => x !== key)
+    seen.push(key)
+    localStorage.setItem(KEY, JSON.stringify({ v: 1, seen: seen.slice(-CAP) }))
+  } catch {
+    /* private mode — the in-memory set covers this session */
+  }
+}

web/src/types.ts

@@ -1,129 +1,132 @@
-// TS mirror of the server's PUBLIC wire contract (src/case_zero/api/public_view.py).
-
-export interface Victim {
-  name: string
-  role: string
-  age: number
-  sprite: string
-  bio: string
-}
-
-export interface SuggestedQuestion {
-  id: string
-  q: string
-}
-
-export interface Suspect {
-  id: string
-  name: string
-  role: string
-  age: number
-  sprite: string
-  gender: string
-  tag: string
-  baselineSuspicion: number
-  motive: string
-  alibi: string
-  quote: string
-  greet: string
-  suggestedQuestions: SuggestedQuestion[]
-}
-
-export interface ThreadMessage {
-  from: 'me' | 'them'
-  who: string
-  t: string
-  m: string
-}
-
-export interface Evidence {
-  id: string
-  name: string
-  type: string
-  icon: string
-  time: string
-  found: string
-  summary: string
-  thread?: ThreadMessage[]
-  detail?: string
-  transcript?: string
-  dur?: string
-  rows?: string[][]
-}
-
-export interface TimelineBeat {
-  time: string
-  label: string
-  locked: boolean
-  ev?: string | null
-  conflict: boolean
-}
-
-export interface FlashbackAccount {
-  who: string
-  scene: string
-  lines: string[]
-  flags: number[]
-}
-
-export interface Flashback {
-  title: string
-  a: FlashbackAccount
-  b: FlashbackAccount
-}
-
-export interface Motive {
-  id: string
-  text: string
-}
-
-export interface StoryBeat {
-  scene: string
-  kicker: string
-  title: string
-  text: string
-}
-
-export interface PublicCase {
-  id: string
-  city: string
-  district: string
-  title: string
-  tagline: string
-  weather: string
-  victim: Victim
-  scene: string
-  tod: string
-  found: string
-  cause: string
-  // Case-kind display labels (optional on old stored cases; default to homicide wording).
-  kind?: string
-  kindLabel?: string
-  division?: string
-  victimStatus?: string
-  todLabel?: string
-  verdict?: string
-  facts: [string, string][]
-  bootLines: string[]
-  storyBeats: StoryBeat[]
-  suspects: Suspect[]
-  evidence: Evidence[]
-  timeline: TimelineBeat[]
-  flashback: Flashback
-  motives: Motive[]
-}
-
-// --- interrogation / verdict wire shapes ---
-export interface InterrogateResult {
-  reply: string
-  suspicionDelta: number
-  suspicion: number
-  flags: { rattled?: boolean; contradictionExposed?: boolean; cornered?: boolean }
-}
-
-export interface VerdictResult {
-  correct: boolean
-  verdict: { stamp: string; killerId: string; killerName: string; truth: string }
-  score: { points: number; max: number; killerCorrect: boolean; motiveCorrect: boolean; evidenceHits: number }
-  stats: [string, string][]
-}
+// TS mirror of the server's PUBLIC wire contract (src/case_zero/api/public_view.py).
+
+export interface Victim {
+  name: string
+  role: string
+  age: number
+  sprite: string
+  bio: string
+}
+
+export interface SuggestedQuestion {
+  id: string
+  q: string
+}
+
+export interface Suspect {
+  id: string
+  name: string
+  role: string
+  age: number
+  sprite: string
+  gender: string
+  accentColor?: string
+  tag: string
+  baselineSuspicion: number
+  motive: string
+  alibi: string
+  quote: string
+  greet: string
+  suggestedQuestions: SuggestedQuestion[]
+}
+
+export interface ThreadMessage {
+  from: 'me' | 'them'
+  who: string
+  t: string
+  m: string
+}
+
+export interface Evidence {
+  id: string
+  name: string
+  type: string
+  icon: string
+  time: string
+  found: string
+  summary: string
+  thread?: ThreadMessage[]
+  detail?: string
+  transcript?: string
+  dur?: string
+  rows?: string[][]
+}
+
+export interface TimelineBeat {
+  time: string
+  label: string
+  locked: boolean
+  ev?: string | null
+  conflict: boolean
+}
+
+export interface FlashbackAccount {
+  who: string
+  scene: string
+  lines: string[]
+  flags: number[]
+}
+
+export interface Flashback {
+  title: string
+  a: FlashbackAccount
+  b: FlashbackAccount
+}
+
+export interface Motive {
+  id: string
+  text: string
+}
+
+export interface StoryBeat {
+  scene: string
+  kicker: string
+  title: string
+  text: string
+  /** This beat narrates the main action: draw the crime-kind vignette over the scene. */
+  incident?: boolean
+}
+
+export interface PublicCase {
+  id: string
+  city: string
+  district: string
+  title: string
+  tagline: string
+  weather: string
+  victim: Victim
+  scene: string
+  tod: string
+  found: string
+  cause: string
+  // Case-kind display labels (optional on old stored cases; default to homicide wording).
+  kind?: string
+  kindLabel?: string
+  division?: string
+  victimStatus?: string
+  todLabel?: string
+  verdict?: string
+  facts: [string, string][]
+  bootLines: string[]
+  storyBeats: StoryBeat[]
+  suspects: Suspect[]
+  evidence: Evidence[]
+  timeline: TimelineBeat[]
+  flashback: Flashback
+  motives: Motive[]
+}
+
+// --- interrogation / verdict wire shapes ---
+export interface InterrogateResult {
+  reply: string
+  suspicionDelta: number
+  suspicion: number
+  flags: { rattled?: boolean; contradictionExposed?: boolean; cornered?: boolean }
+}
+
+export interface VerdictResult {
+  correct: boolean
+  verdict: { stamp: string; killerId: string; killerName: string; truth: string }
+  score: { points: number; max: number; killerCorrect: boolean; motiveCorrect: boolean; evidenceHits: number }
+  stats: [string, string][]
+}

web/src/ui/assistant.tsx

@@ -1,22 +1,35 @@
-// Det. Hale — your partner on the wire. Contextual, spoiler-safe hints from the server.
+// Det. Hale — your partner on the wire. Contextual, spoiler-safe hints from the server,
+// plus one-time local nudges that introduce each screen to a new player.
 import { useEffect, useState } from 'preact/hooks'
 
 import { getHint } from '../api'
 import { useTypewriter } from '../engine/pixel'
-import { useGame } from '../store'
+import { type Screen, useGame } from '../store'
+import { hasSeen, markSeen } from '../tips'
 import { Portrait } from './components'
 
 const HIDDEN = new Set(['title', 'verdict', 'share', 'boot'])
 const FALLBACK = 'Work the evidence, detective. Find where a statement and a fact disagree, and press there.'
 
+// First-visit nudges (client-local, no server call). Shown once per browser.
+const TIPS: Partial<Record<Screen, string>> = {
+  board: 'Pick a suspect and lean on them. Work the checklist on the rail — question everyone, show them the exhibits.',
+  interro: 'Ask your questions, then hit them with evidence from the tray. Watch that bar climb.',
+  accuse: 'Name them, give me the why, and attach what made them crack.',
+}
+
 export function Assistant() {
   const g = useGame()
   const [open, setOpen] = useState(false)
   const [hint, setHint] = useState('')
+  const [localTip, setLocalTip] = useState<string | null>(null)
   const screen = g.state.screen
 
   useEffect(() => {
-    const t = () => setOpen((o) => !o)
+    const t = () => {
+      setLocalTip(null) // HINT button always fetches the live server hint
+      setOpen((o) => !o)
+    }
     const c = () => setOpen(false)
     window.addEventListener('toggle-hint', t)
     window.addEventListener('close-hint', c)
@@ -26,12 +39,35 @@ export function Assistant() {
     }
   }, [])
 
+  // Screen change: close whatever was open, then fire the one-time nudge for this
+  // screen kind. On the board it waits for the case-brief overlay to be dismissed
+  // so the two never stack.
   useEffect(() => {
     setOpen(false)
+    setLocalTip(null)
+    const tip = TIPS[screen]
+    if (!tip || hasSeen(`tip:${screen}`)) return
+    let timer: ReturnType<typeof setTimeout> | null = null
+    const show = () => {
+      markSeen(`tip:${screen}`)
+      setLocalTip(tip)
+      setOpen(true)
+    }
+    const briefPending = screen === 'board' && !hasSeen(`brief:${g.case.id}`)
+    const onBrief = () => {
+      timer = setTimeout(show, 400)
+    }
+    if (briefPending) window.addEventListener('cz-brief-done', onBrief, { once: true })
+    else timer = setTimeout(show, 700)
+    return () => {
+      if (timer) clearTimeout(timer)
+      window.removeEventListener('cz-brief-done', onBrief)
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [screen])
 
   useEffect(() => {
-    if (!open) return
+    if (!open || localTip) return
     let alive = true
     setHint('')
     getHint(g.runId, screen)
@@ -44,9 +80,9 @@ export function Assistant() {
     return () => {
       alive = false
     }
-  }, [open, screen, g.runId])
+  }, [open, localTip, screen, g.runId])
 
-  const [typed, done] = useTypewriter(open ? hint : '', g.state.tweaks.typeSpeed || 18, open)
+  const [typed, done] = useTypewriter(open ? localTip ?? hint : '', g.state.tweaks.typeSpeed || 18, open)
 
   if (HIDDEN.has(screen) || !open) return null
   return (

web/src/ui/case-brief.tsx

@@ -0,0 +1,42 @@
+// First-visit case brief: a one-card overlay on the board that tells a new player
+// everything they need — who's dead/wronged, and what to do about it. Shown once per
+// case per browser; the full dossier stays one tap away.
+import { useState } from 'preact/hooks'
+
+import { useGame } from '../store'
+import { hasSeen, markSeen } from '../tips'
+import { Btn, Chip, Panel } from './components'
+
+export function CaseBriefOverlay() {
+  const g = useGame()
+  const c = g.case
+  const key = `brief:${c.id}`
+  const [show, setShow] = useState(() => !hasSeen(key))
+  if (!show) return null
+  const done = () => {
+    markSeen(key)
+    setShow(false)
+    window.dispatchEvent(new Event('cz-brief-done'))
+  }
+  return (
+    <div class="brief-veil" onClick={done}>
+      <Panel variant="amber" className="brief-card col" style={{ gap: 12, padding: 18 }} onClick={(e: MouseEvent) => e.stopPropagation()}>
+        <div class="row between" style={{ alignItems: 'center', gap: 8 }}>
+          <span class="t-label" style={{ color: 'var(--amber-2)', letterSpacing: '.2em' }}>CASE {c.id}</span>
+          <Chip variant="ox">{c.kindLabel || 'HOMICIDE'}</Chip>
+        </div>
+        <div class="col" style={{ gap: 4 }}>
+          <span class="t-display" style={{ fontSize: 16, color: 'var(--bone-3)' }}>{c.victim.name}</span>
+          <span class="t-label">{c.victimStatus || 'DECEASED'} · {c.scene}</span>
+        </div>
+        <p class="t-body" style={{ fontSize: 14, lineHeight: 1.5, color: 'var(--bone-2)', margin: 0 }}>
+          One of them is lying. Question the suspects, present evidence, and make the accusation.
+        </p>
+        <div class="col" style={{ gap: 8 }}>
+          <Btn variant="amber" onClick={done}>▸ Start investigating</Btn>
+          <Btn variant="ghost" sm onClick={() => { markSeen(key); setShow(false); g.nav('briefing') }}>Read full case file ▸</Btn>
+        </div>
+      </Panel>
+    </div>
+  )
+}

web/src/ui/checklist.tsx

@@ -0,0 +1,61 @@
+// Detective's checklist: the "what do I do next" rail. Four objectives derived
+// entirely from game state; the ACCUSE step pulses when the player is ready.
+import { useState } from 'preact/hooks'
+
+import { HOT_SUSPICION, useGame } from '../store'
+import { Btn } from './components'
+
+function useObjectives() {
+  const g = useGame()
+  const c = g.case
+  const questioned = c.suspects.filter((s) => (g.state.interrogations[s.id] || []).length > 1).length
+  const presented = Object.values(g.state.usedEv).some((l) => l.length > 0)
+  const crackedAny = Object.values(g.state.cracked).some(Boolean)
+  const hot = Object.values(g.state.suspicion).some((v) => v >= HOT_SUSPICION)
+  const ready = (questioned >= c.suspects.length && presented && crackedAny) || hot
+  return { g, total: c.suspects.length, questioned, presented, crackedAny, ready }
+}
+
+function Step({ done, label }: { done: boolean; label: string }) {
+  return (
+    <div class={'checklist__step' + (done ? ' checklist__step--done' : '')}>
+      <span class="checklist__box">{done ? '■' : '□'}</span>
+      <span>{label}</span>
+    </div>
+  )
+}
+
+export function Checklist({ slim = false }: { slim?: boolean }) {
+  const { g, total, questioned, presented, crackedAny, ready } = useObjectives()
+  const doneCount = (questioned >= total ? 1 : 0) + (presented ? 1 : 0) + (crackedAny ? 1 : 0)
+  const [open, setOpen] = useState(questioned === 0) // collapse once the player gets going
+  const steps = (
+    <>
+      <Step done={questioned >= total} label={`QUESTION EVERY SUSPECT ${questioned}/${total}`} />
+      <Step done={presented} label="PRESENT EVIDENCE" />
+      <Step done={crackedAny} label="CRACK A LIE" />
+      <Btn
+        sm
+        variant={ready ? 'ox' : 'ghost'}
+        className={ready ? 'accuse-cta--pulse' : undefined}
+        style={{ marginTop: 6 }}
+        onClick={() => g.nav('accuse')}
+      >
+        {ready ? '▸ MAKE THE ACCUSATION' : 'Accuse ▸'}
+      </Btn>
+    </>
+  )
+  if (!slim) return <div class="checklist">{steps}</div>
+  return (
+    <div class="checklist checklist--slim">
+      <button class="checklist__toggle" onClick={() => setOpen(!open)}>
+        <span class="t-label" style={{ color: 'var(--amber-2)' }}>OBJECTIVES {doneCount}/3</span>
+        <span class="t-mono dim">{open ? '▾' : '▸'}</span>
+      </button>
+      {open && <div class="col" style={{ gap: 4, paddingTop: 6 }}>{steps}</div>}
+      {!open && ready && (
+        <Btn sm variant="ox" className="accuse-cta--pulse" onClick={() => g.nav('accuse')}>▸ ACCUSE</Btn>
+      )}
+    </div>
+  )
+}

web/src/ui/components.tsx

@@ -3,7 +3,7 @@
 import type { ComponentChildren, JSX } from 'preact'
 import { useEffect, useState } from 'preact/hooks'
 
-import { EV_ICONS, IPAL, bodyFor, exhibitPainter, portraitFor, sceneFor } from '../engine/art'
+import { EV_ICONS, IPAL, bodyFor, exhibitPainter, incidentPainter, portraitFor, sceneFor, sceneForPlace } from '../engine/art'
 import { PixelCanvas, SceneCanvas, useTypewriter } from '../engine/pixel'
 import { useGame } from '../store'
 import type { Evidence, Suspect } from '../types'
@@ -68,8 +68,8 @@ function useMouth(active: boolean): boolean {
   }, [active])
   return open
 }
-export function Portrait({ id, px = 6, blink = true, talking = false, style, className, gender }: SpriteProps & { blink?: boolean; talking?: boolean; gender?: string }) {
-  const p = portraitFor(id, gender)
+export function Portrait({ id, px = 6, blink = true, talking = false, style, className, gender, accent }: SpriteProps & { blink?: boolean; talking?: boolean; gender?: string; accent?: string }) {
+  const p = portraitFor(id, gender, accent)
   const b = useBlink()
   const mouth = useMouth(talking)
   let frame = p.frames[0]
@@ -77,8 +77,8 @@ export function Portrait({ id, px = 6, blink = true, talking = false, style, cla
   else if (blink && b) frame = p.frames[1]
   return <PixelCanvas map={frame} pal={p.pal} px={pxScaled(px)} style={style} className={className} />
 }
-export function Body({ id, px = 6, playing = true, style, className, gender }: SpriteProps & { playing?: boolean; gender?: string }) {
-  const p = bodyFor(id, gender)
+export function Body({ id, px = 6, playing = true, style, className, gender, accent }: SpriteProps & { playing?: boolean; gender?: string; accent?: string }) {
+  const p = bodyFor(id, gender, accent)
   return <PixelCanvas frames={p.frames} pal={p.pal} px={pxScaled(px)} fps={1.1} playing={playing} style={style} className={className} />
 }
 export function EvIcon({ icon, px = 4, style }: { icon: string; px?: number; style?: JSX.CSSProperties }) {
@@ -92,22 +92,29 @@ interface SceneProps {
   anim?: boolean
   full?: boolean
   cover?: boolean
+  /** Resolve the name as a PLACE (building/venue) for an exterior establishing shot. */
+  establishing?: boolean
+  /** Crime kind: draw the main-action vignette (the body, the spill, the flames)
+   *  spotlit over the dimmed scene. */
+  incident?: string
   style?: JSX.CSSProperties
   className?: string
   deps?: unknown[]
 }
-export function Scene({ name, w = 240, h = 135, anim = false, full = false, cover = false, style, className, deps = [] }: SceneProps) {
+export function Scene({ name, w = 240, h = 135, anim = false, full = false, cover = false, establishing = false, incident, style, className, deps = [] }: SceneProps) {
   const st = cover ? { objectFit: 'cover' as const, ...style } : style
+  const base = establishing ? sceneForPlace(name) : sceneFor(name)
   return (
     <SceneCanvas
-      paint={sceneFor(name)}
+      paint={incident ? incidentPainter(incident, base) : base}
       w={w}
       h={h}
       anim={anim}
       full={full}
+      themed="full"
       style={st}
       className={className}
-      deps={[name, anim, full, ...deps]}
+      deps={[name, anim, full, establishing, incident, ...deps]}
     />
   )
 }
@@ -127,6 +134,7 @@ export function ExhibitArt({ e, w = 96, h = 72, style, className }: ExhibitArtPr
       paint={exhibitPainter(e.name, e.summary || '', e.id)}
       w={w}
       h={h}
+      themed="tint"
       style={style}
       className={className}
       deps={[e.id, e.name]}
@@ -215,7 +223,7 @@ export function SuspectCard({ s, onClick, active, mini }: { s: Suspect; onClick?
     >
       <div class="row" style={{ gap: 10, alignItems: 'flex-start' }}>
         <div style={{ background: 'var(--ink-1)', boxShadow: 'inset 0 0 0 2px var(--ink-0)', padding: 3, flexShrink: 0 }}>
-          <Portrait id={s.sprite} px={mini ? 3 : 4} gender={s.gender} />
+          <Portrait id={s.sprite} px={mini ? 3 : 4} gender={s.gender} accent={s.accentColor} />
         </div>
         <div class="col grow" style={{ gap: 5, minWidth: 0 }}>
           <div>

web/src/ui/juice.tsx

@@ -0,0 +1,18 @@
+// Interrogation feedback moments: the floating suspicion delta and the slam-in
+// banner when a suspect's lie cracks for the first time.
+import { Stamp } from './components'
+
+export function DeltaFloater({ delta }: { delta: number }) {
+  const big = Math.abs(delta) >= 12
+  const cls = 'delta-float' + (delta < 0 ? ' delta-float--drop' : big ? ' delta-float--big' : '')
+  return <span class={cls}>{delta > 0 ? `+${delta}` : `${delta}`}</span>
+}
+
+export function CrackBanner() {
+  return (
+    <div class="crack-banner">
+      <div class="crack-banner__flash" />
+      <Stamp slam style={{ fontSize: 'clamp(16px,4vw,26px)' }}>THE LIE CRACKS</Stamp>
+    </div>
+  )
+}