Evidence icons: 16 new pixel icons, name-first relevance matching

- art.ts: EV_ICONS grows from 7 to 23 procedural 12x16 pixel icons
(fingerprint, tumbler, thread spool, envelope, bottle, knife, pocket
watch, ring, cigarette, bootprint, book, skeleton key, lit match,
pen, banknotes, magnifier) in the existing IPAL palette
- case_adapter.py: icon keyword rules rewritten and reordered (knife
before "letter", footprints before "prints", keycard before "key");
the clue NAME decides first and the reveal text only breaks ties, so
a fingerprint whose description mentions a blade stays a fingerprint
- Unmatched clues now fall back by discovery method (forensic ->
fingerprint, document -> receipt, search -> photo, interrogation ->
voicemail) instead of a blind 3-icon rotation
- Applies to prebaked AND AI-generated cases (both flow through
casefile_to_public at serve time); golden seed cases keep their
hand-authored icons
- Verified: every prebaked clue maps to a relevant icon (15 distinct
icons across the pool, was effectively 3-4); backend icon names
cross-checked 1:1 against EV_ICONS keys
- COMPLIANCE.md: Off-Brand blurb updated for the icon set, the
Connect the Dots mode, and the mobile corkboard

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

COMPLIANCE.md

@@ -1,105 +1,108 @@
-# Case Zero - Hackathon Compliance
-
-Built for the **Build Small Hackathon** ("Small models, big adventure").
-
-Case Zero is a **Gradio application**: the whole app is one `gradio.Server` (Gradio 6
-"Server mode" - a FastAPI subclass launched through Gradio, with Gradio API endpoints
-registered via `@server.api`). It is deployed as a **Hugging Face Space** on **CPU** (no
-GPU). It ships via the Docker SDK purely so llama.cpp compiles on a stable base image - the
-app itself is Gradio, served end to end by `gradio.Server`.
-
-## Core requirements
-
-| Requirement | Status |
-|---|---|
-| Total model params <= 32B | ✓ ~1.6B (see budget below) |
-| Built in Gradio | ✓ one `gradio.Server`, with `@server.api` endpoints (`new_case`, `interrogate`) |
-| Hosted as a Hugging Face Space | ✓ `build-small-hackathon/case0` (Docker SDK, `app_port: 7860`) |
-| Demo video | ☐ to record (warmup -> interrogate -> present evidence -> alibi cracks -> accuse -> verdict) |
-| Social-media post | ☐ to post |
-
-## Parameter budget (<= 32B total)
-
-Every model is open-weights and self-run. **No third-party AI service is ever called.**
-
-| Component | Model | Open? | Params | Runs |
-|---|---|---|---|---|
-| Reasoning + dialogue (the whole game) | Qwen2.5-1.5B-Instruct (Q4_K_M GGUF) | Apache-2.0 | **1.5B** | in-process llama.cpp on CPU |
-| Suspect voices | Supertonic (ONNX) | open | ~0.1B | local ONNX Runtime (CPU) |
-| Portraits / scenes / props | Procedural canvas - no model | n/a | 0B | client-side |
-| Music + SFX | Pre-made / procedural audio - no model | n/a | 0B | playback only |
-| Embeddings / vector RAG | none | n/a | 0B | - |
-
-**Total runtime parameters: ~1.6B** - far under 32B (and under 4B, eligible for the
-**Tiny Titan** special award).
-
-## Merit badges
-
-### Earned by the build (verifiable on the Space)
-
-- **Off the Grid** - *"No cloud APIs. The whole thing runs on the model in front of you."*
-  The LLM is in-process llama.cpp; the voices are a local ONNX model; the pixel art is
-  rendered client-side on canvas; the music is a bundled CC-BY track. The open weights are
-  baked into the Docker image at build time, so the running container makes **no AI network
-  calls at all**. Proof: `python scripts/net_audit.py` runs a full playthrough under a
-  socket guard and asserts **zero non-loopback connections**. ✓
-- **Llama Champion** - *"Your model runs through the llama.cpp runtime."* The LLM runs
-  through `llama-cpp-python` (in-process, on the CPU) - no server, no GPU, no remote
-  endpoint. ✓
-- **Off-Brand** - *"A custom frontend that pushes past the default Gradio look."* The front
-  end is **not** stock Gradio. It is a hand-built **pixel-art noir SPA (Preact + Vite,
-  TypeScript)** - 12 screens, a custom pixel design system (self-hosted Silkscreen /
-  Pixelify Sans fonts, beveled 9-slice panels, inventory-slot evidence cards, a ruled-paper
-  dossier with page-flips), a draggable corkboard, a live interrogation stage with a
-  voiced suspect, procedural canvas art and rain FX, and a full client audio layer. The
-  built bundle is served as static files by the same `gradio.Server` that exposes the
-  `/api` routes - one process, no separate frontend host. ✓
-
-### Targeted / in progress
-
-- **Field Notes** - *"Write a blog post or report about your project."*
-  [`docs/FIELD_NOTES.md`](docs/FIELD_NOTES.md), shipped with the Space.
-- **Sharing is Caring** - *"You shared your agent trace on the Hub for everyone to learn
-  from."* Real traces (the exact prompts + raw completions of a full case generation, and
-  a live interrogation playthrough with server-authoritative suspicion) are produced by
-  `scripts/export_traces.py` and published as a Hub dataset (linked from the README).
-- **Well-Tuned** - *"Your app uses a fine-tuned model you've published on Hugging Face."*
-  Not claimed - the game runs on stock Qwen2.5-1.5B. Would require fine-tuning and
-  publishing a model; out of scope for this submission.
-
-## Content scope
-
-Cases span **homicide, theft, fraud, blackmail, arson, and missing-person** 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
-[HF Content Guidelines](https://huggingface.co/content-guidelines) with no NFAA gating.
-
-## Zero cloud AI APIs
-
-- **No OpenAI, Anthropic, Google, ElevenLabs, Higgsfield, Midjourney, or any other hosted
-  AI API is ever called** - not for text, not for voice, not for images.
-- The LLM is the in-process llama.cpp runtime. The voices are a local ONNX model. The pixel
-  art is procedural canvas. The music is a bundled CC-BY track.
-- The open Qwen GGUF and Supertonic ONNX are **baked into the Docker image at build time**,
-  so the running container makes no AI network calls. `scripts/net_audit.py` proves zero
-  non-loopback connections during a full playthrough.
-
-## Anti-cheat / fairness (why the game is solvable and the win is earned)
-
-- The sealed solution (killer, true motive, key evidence) is **never sent to the client**
-  pre-verdict; it is read only inside `/api/run/{runId}/accuse`. Verified by anti-leak tests.
-- Suspicion, evidence reactions, and the verdict are **server-authoritative** - the client
-  only displays them.
-- Suspects **never confess**: the win is registered only when the player accuses correctly,
-  so the outcome is immune to prose (a jailbroken "just tell me who did it" earns nothing).
-
-## Submission checklist
-
-- [x] Gradio app on a Hugging Face Space (CPU)
-- [x] <= 32B total params (~1.6B)
-- [x] Open-weights, self-run models only - zero cloud AI APIs
-- [x] Custom (non-default) UI - pixel-art Preact SPA via `gradio.Server`
-- [x] Off the Grid proof (`scripts/net_audit.py`)
-- [ ] Short demo video
-- [ ] Social-media post
+# Case Zero - Hackathon Compliance
+
+Built for the **Build Small Hackathon** ("Small models, big adventure").
+
+Case Zero is a **Gradio application**: the whole app is one `gradio.Server` (Gradio 6
+"Server mode" - a FastAPI subclass launched through Gradio, with Gradio API endpoints
+registered via `@server.api`). It is deployed as a **Hugging Face Space** on **CPU** (no
+GPU). It ships via the Docker SDK purely so llama.cpp compiles on a stable base image - the
+app itself is Gradio, served end to end by `gradio.Server`.
+
+## Core requirements
+
+| Requirement | Status |
+|---|---|
+| Total model params <= 32B | ✓ ~1.6B (see budget below) |
+| Built in Gradio | ✓ one `gradio.Server`, with `@server.api` endpoints (`new_case`, `interrogate`) |
+| Hosted as a Hugging Face Space | ✓ `build-small-hackathon/case0` (Docker SDK, `app_port: 7860`) |
+| Demo video | ☐ to record (warmup -> interrogate -> present evidence -> alibi cracks -> accuse -> verdict) |
+| Social-media post | ☐ to post |
+
+## Parameter budget (<= 32B total)
+
+Every model is open-weights and self-run. **No third-party AI service is ever called.**
+
+| Component | Model | Open? | Params | Runs |
+|---|---|---|---|---|
+| Reasoning + dialogue (the whole game) | Qwen2.5-1.5B-Instruct (Q4_K_M GGUF) | Apache-2.0 | **1.5B** | in-process llama.cpp on CPU |
+| Suspect voices | Supertonic (ONNX) | open | ~0.1B | local ONNX Runtime (CPU) |
+| Portraits / scenes / props | Procedural canvas - no model | n/a | 0B | client-side |
+| Music + SFX | Pre-made / procedural audio - no model | n/a | 0B | playback only |
+| Embeddings / vector RAG | none | n/a | 0B | - |
+
+**Total runtime parameters: ~1.6B** - far under 32B (and under 4B, eligible for the
+**Tiny Titan** special award).
+
+## Merit badges
+
+### Earned by the build (verifiable on the Space)
+
+- **Off the Grid** - *"No cloud APIs. The whole thing runs on the model in front of you."*
+  The LLM is in-process llama.cpp; the voices are a local ONNX model; the pixel art is
+  rendered client-side on canvas; the music is a bundled CC-BY track. The open weights are
+  baked into the Docker image at build time, so the running container makes **no AI network
+  calls at all**. Proof: `python scripts/net_audit.py` runs a full playthrough under a
+  socket guard and asserts **zero non-loopback connections**. ✓
+- **Llama Champion** - *"Your model runs through the llama.cpp runtime."* The LLM runs
+  through `llama-cpp-python` (in-process, on the CPU) - no server, no GPU, no remote
+  endpoint. ✓
+- **Off-Brand** - *"A custom frontend that pushes past the default Gradio look."* The front
+  end is **not** stock Gradio. It is a hand-built **pixel-art noir SPA (Preact + Vite,
+  TypeScript)** - 13 screens, a custom pixel design system (self-hosted Silkscreen /
+  Pixelify Sans fonts, beveled 9-slice panels, inventory-slot evidence cards with 23
+  procedural pixel icons keyword-matched to each exhibit, a ruled-paper dossier with
+  page-flips), a draggable corkboard with a red-yarn **"Connect the Dots"** mode (tie
+  evidence together with sagging SVG threads, on desktop and on the scrollable mobile
+  wall), a live interrogation stage with a voiced suspect, procedural canvas art and rain
+  FX, and a full client audio layer. The built bundle is served as static files by the
+  same `gradio.Server` that exposes the `/api` routes - one process, no separate frontend
+  host. ✓
+
+### Targeted / in progress
+
+- **Field Notes** - *"Write a blog post or report about your project."*
+  [`docs/FIELD_NOTES.md`](docs/FIELD_NOTES.md), shipped with the Space.
+- **Sharing is Caring** - *"You shared your agent trace on the Hub for everyone to learn
+  from."* Real traces (the exact prompts + raw completions of a full case generation, and
+  a live interrogation playthrough with server-authoritative suspicion) are produced by
+  `scripts/export_traces.py` and published as a Hub dataset (linked from the README).
+- **Well-Tuned** - *"Your app uses a fine-tuned model you've published on Hugging Face."*
+  Not claimed - the game runs on stock Qwen2.5-1.5B. Would require fine-tuning and
+  publishing a model; out of scope for this submission.
+
+## Content scope
+
+Cases span **homicide, theft, fraud, blackmail, arson, and missing-person** 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
+[HF Content Guidelines](https://huggingface.co/content-guidelines) with no NFAA gating.
+
+## Zero cloud AI APIs
+
+- **No OpenAI, Anthropic, Google, ElevenLabs, Higgsfield, Midjourney, or any other hosted
+  AI API is ever called** - not for text, not for voice, not for images.
+- The LLM is the in-process llama.cpp runtime. The voices are a local ONNX model. The pixel
+  art is procedural canvas. The music is a bundled CC-BY track.
+- The open Qwen GGUF and Supertonic ONNX are **baked into the Docker image at build time**,
+  so the running container makes no AI network calls. `scripts/net_audit.py` proves zero
+  non-loopback connections during a full playthrough.
+
+## Anti-cheat / fairness (why the game is solvable and the win is earned)
+
+- The sealed solution (killer, true motive, key evidence) is **never sent to the client**
+  pre-verdict; it is read only inside `/api/run/{runId}/accuse`. Verified by anti-leak tests.
+- Suspicion, evidence reactions, and the verdict are **server-authoritative** - the client
+  only displays them.
+- Suspects **never confess**: the win is registered only when the player accuses correctly,
+  so the outcome is immune to prose (a jailbroken "just tell me who did it" earns nothing).
+
+## Submission checklist
+
+- [x] Gradio app on a Hugging Face Space (CPU)
+- [x] <= 32B total params (~1.6B)
+- [x] Open-weights, self-run models only - zero cloud AI APIs
+- [x] Custom (non-default) UI - pixel-art Preact SPA via `gradio.Server`
+- [x] Off the Grid proof (`scripts/net_audit.py`)
+- [ ] Short demo video
+- [ ] Social-media post

src/case_zero/api/case_adapter.py

@@ -1,264 +1,297 @@
-"""Project a generated ``CaseFile`` into the PUBLIC wire view (the same contract the
-golden case uses). Deterministic: it synthesizes the display surface from the case's
-own fields. Nothing from the sealed solution (culprit, true motive id, breaker chain)
-is exposed; the true motive's *text* appears only as one option among the decoys.
-
-Generated evidence renders as paper exhibits (reveal_text); richer per-type payloads
-(threads, keycard tables, voicemail) and authored tags/quotes are a later enhancement.
-"""
-
-from __future__ import annotations
-
-import re
-
-from ..generator.crime_profiles import CrimeProfile, profile_for
-from ..schemas.case import CaseFile
-from ..schemas.clue import Clue
-from .public_view import (
-    FlashbackAccount,
-    PublicCase,
-    PublicEvidence,
-    PublicFlashback,
-    PublicMotive,
-    PublicSuspect,
-    PublicVictim,
-    StoryBeat,
-    SuggestedQuestion,
-    TimelineBeat,
-)
-from .questions import FIXED_QUESTIONS
-
-_SCENES = ("skyline", "atrium", "interro", "seawall", "mezzanine", "desk")
-_WEATHER = (
-    "Rain, and a wind off the water.", "Fog thick enough to lean on.",
-    "A dry cold that gets into the joints.", "Sleet against every window.",
-)
-_GREETS = (
-    "Detective. Let's get this over with.",
-    "I already told the others everything I know.",
-    "Ask what you came to ask.",
-    "I have nothing to hide, if that's what you think.",
-)
-_APPARENT = (
-    "Was close enough to the victim to have a reason - and a chance.",
-    "Had more to lose tonight than they're letting on.",
-    "Their story has a seam in it, if you pull the right thread.",
-    "Stood to gain from a death no one saw coming.",
-)
-_DECOY_MOTIVES = (
-    "To bury a debt that was about to surface.",
-    "Jealousy that had festered for years.",
-    "To keep a buried secret buried.",
-    "To settle an old score, finally.",
-    "Fear of being exposed and ruined.",
-)
-# Keyword-matched icons so a letter looks like paper and a keycard like a key -
-# never a phone icon on a bloodied letter. First match wins; unmatched rotate.
-_ICON_RULES: tuple[tuple[re.Pattern[str], str], ...] = (
-    (re.compile(r"photo|polaroid|snapshot|portrait|negative|film", re.I), "photoEv"),
-    (re.compile(r"cctv|camera|footage|surveillance|still\b", re.I), "cctv"),
-    (re.compile(r"voicemail|recording|tape|audio|cylinder|dictaphone", re.I), "voicemail"),
-    (re.compile(r"phone|telephone|telegram|message|wire\b", re.I), "phone"),
-    (re.compile(r"key\b|keys\b|keycard|access|badge|pass\b|lock\b", re.I), "keycard"),
-    (re.compile(r"receipt|ticket|ledger|letter|note\b|paper|document|contract|deed|cheque|"
-                r"check\b|bill\b|pawn|invoice|book\b|journal|diary|stub", re.I), "receipt"),
-    (re.compile(r"map\b|compass|route|itinerary|timetable|schedule", re.I), "compass"),
-)
-_ICONS = ("photoEv", "receipt", "compass")
-
-
-def _icon_for(name: str, reveal: str, idx: int) -> str:
-    hay = f"{name} {reveal}"
-    for rule, icon in _ICON_RULES:
-        if rule.search(hay):
-            return icon
-    return _ICONS[idx % len(_ICONS)]
-# Noir city names so CITY reads as an actual city, not the venue (the venue goes in SCENE).
-_CITIES = (
-    "Graymoor", "Blackport", "Ashmoor", "Harrowgate", "Duskwater", "Coldhaven",
-    "Ravenreach", "Mortlake", "Greyharbor", "Thornehaven", "Mistport", "Hollowmere",
-    "Saltmarsh", "Ironhaven", "Blackwater", "Fellgate",
-)
-
-
-def _hash(s: str) -> int:
-    h = 0
-    for ch in s:
-        h = (h * 31 + ord(ch)) & 0x7FFFFFFF
-    return h
-
-
-def _clock(minute: int) -> str:
-    h = (minute // 60) % 24
-    m = minute % 60
-    suffix = "AM" if h < 12 else "PM"
-    h12 = h % 12 or 12
-    return f"{h12}:{m:02d} {suffix}"
-
-
-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 _suspect_public(case: CaseFile, idx: int) -> PublicSuspect:
-    s = case.suspects[idx]
-    seed = _hash(s.sus_id)
-    role_word = (s.role.split()[-1] if s.role else "").strip(".,").upper()
-    tag = f"THE {role_word}" if role_word else "PERSON OF INTEREST"
-    quote = (s.persona_summary.split(".")[0] + ".") if s.persona_summary else "I've nothing to hide."
-    gender = "female" if ((s.visual.gender if s.visual else "") or "").lower().startswith("f") else "male"
-    return PublicSuspect(
-        id=s.sus_id,
-        name=s.name,
-        role=s.role,
-        age=30 + (seed % 35),
-        sprite=s.sus_id,
-        gender=gender,
-        tag=tag[:22],
-        baseline_suspicion=25 + (seed % 16),
-        motive=_APPARENT[idx % len(_APPARENT)],
-        alibi=s.stated_alibi.claim_text,
-        quote=quote,
-        greet=_GREETS[idx % len(_GREETS)],
-        suggested_questions=tuple(SuggestedQuestion(id=q, q=text) for q, text in FIXED_QUESTIONS),
-    )
-
-
-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(
-        id=clue.clue_id,
-        name=clue.name.upper(),
-        type=clue.discovery_method.value.upper(),
-        icon=_icon_for(clue.name, clue.reveal_text, idx),
-        time=time,
-        found=f"Recovered from {_loc_name(case, clue.discoverable_at_loc_id)}.",
-        summary=clue.reveal_text,
-        detail=clue.reveal_text,
-    )
-
-
-def _timeline(case: CaseFile, profile: CrimeProfile) -> tuple[TimelineBeat, ...]:
-    beats: list[TimelineBeat] = []
-    w = case.setting.murder_window
-    beats.append(TimelineBeat(time=_clock(w.start_min), label="The evening is under way; everyone is in the house.", locked=True))
-    culprit = case.culprit.sus_id
-    for i, clue in enumerate(case.clues):
-        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)
-        t = at if at is not None else w.start_min + 7 * (i + 1)
-        conflict = clue.contradicts_alibi_of == culprit
-        beats.append(TimelineBeat(time=_clock(t), label=clue.reveal_text[:80], ev=clue.clue_id, conflict=conflict))
-    incident = profile.timeline_line.format(
-        name=case.victim.name, instrument=case.weapon.name,
-        room=_loc_name(case, case.victim.found_at_loc_id),
-    )
-    beats.append(TimelineBeat(time=_clock(case.victim.time_of_death.start_min), label=incident, locked=True))
-    beats.sort(key=lambda b: b.time)
-    return tuple(beats)
-
-
-def _flashback(case: CaseFile) -> PublicFlashback:
-    culprit = next((s for s in case.suspects if s.sus_id == case.culprit.sus_id), case.suspects[0])
-    claimed = _loc_name(case, case.culprit.alibi_lie.claimed_loc_id)
-    crime = _loc_name(case, case.victim.found_at_loc_id)
-    breakers = [c for c in case.clues if c.contradicts_alibi_of == culprit.sus_id][:3]
-    return PublicFlashback(
-        title="TWO ACCOUNTS",
-        a=FlashbackAccount(
-            who=f"{culprit.name} SAYS",
-            scene=claimed,
-            lines=(culprit.stated_alibi.claim_text, f"I was in {claimed} the whole time.", "I never went near it."),
-            flags=(),
-        ),
-        b=FlashbackAccount(
-            who="THE EVIDENCE SAYS",
-            scene=crime,
-            lines=tuple(c.reveal_text[:90] for c in breakers) or ("The evidence places someone at the scene.",),
-            flags=tuple(range(len(breakers))),
-        ),
-    )
-
-
-def _motives(case: CaseFile, seed: int) -> tuple[PublicMotive, ...]:
-    true_text = case.culprit.true_motive.summary
-    decoys = [d for d in _DECOY_MOTIVES if d.lower() != true_text.lower()]
-    chosen = [PublicMotive(id="M1", text=true_text)]
-    for i in range(3):
-        chosen.append(PublicMotive(id=f"MD{i + 1}", text=decoys[(seed + i) % len(decoys)]))
-    # stable shuffle by seed so the true option isn't always first
-    rot = seed % len(chosen)
-    return tuple(chosen[rot:] + chosen[:rot])
-
-
-def _story_beats(case: CaseFile, profile: CrimeProfile, scene: str) -> tuple[StoryBeat, ...]:
-    """Each beat's backdrop is the place its text describes: the city for the call, the
-    REAL crime scene for the incident, another room of the same building for the cast,
-    and the detective's desk for the hand-off."""
-    v = case.victim
-    crime_loc = case.victim.found_at_loc_id
-    building = case.setting.name
-    other_room = next(
-        (loc.name for loc in case.setting.locations if loc.loc_id != crime_loc),
-        _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}"),
-        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",
-                  text="One of them is lying to your face. Find the crack in the account and follow it down."),
-    )
-
-
-def casefile_to_public(case: CaseFile) -> PublicCase:
-    seed = case.seed
-    profile = profile_for(case.crime_kind)
-    tod = case.victim.time_of_death.start_min
-    building = case.setting.name
-    room = _loc_name(case, case.victim.found_at_loc_id)
-    scene = f"{building} — {room}"  # building + room; the painter keys off the room
-    city = _CITIES[seed % len(_CITIES)]
-    return PublicCase(
-        id=case.case_id,
-        city=city,
-        district=building,
-        title=case.title,
-        tagline="Detective, your presence is required.",
-        weather=_WEATHER[seed % len(_WEATHER)],
-        victim=PublicVictim(name=case.victim.name, role=case.victim.role, age=40 + (seed % 30), sprite="victim", bio=case.briefing),
-        scene=scene,
-        tod=_clock(tod),
-        found=f"{profile.found_verb} {scene} at {_clock(case.victim.found_at_min)}.",
-        cause=case.victim.cause_of_death,
-        kind=profile.kind.value,
-        kind_label=profile.kind_label,
-        division=profile.division,
-        victim_status=profile.victim_status,
-        tod_label=profile.tod_label,
-        verdict=profile.verdict,
-        facts=(
-            ("CITY", city),
-            ("VICTIM", f"{case.victim.name}"),
-            ("SCENE", scene),
-            (profile.tod_label, _clock(tod)),
-            ("WHAT HAPPENED", case.victim.cause_of_death),
-            ("VERDICT", profile.verdict),
-        ),
-        boot_lines=(
-            "The phone drags you up out of half a sleep.",
-            f"{case.setting.name}. {profile.boot_line}",
-            f"{case.victim.name} - {case.victim.role}.",
-            "They're holding the scene. It's yours now, detective.",
-        ),
-        story_beats=_story_beats(case, profile, scene),
-        suspects=tuple(_suspect_public(case, i) for i in range(len(case.suspects))),
-        evidence=tuple(_evidence_public(case, c, i) for i, c in enumerate(case.clues)),
-        timeline=_timeline(case, profile),
-        flashback=_flashback(case),
-        motives=_motives(case, seed),
-    )
+"""Project a generated ``CaseFile`` into the PUBLIC wire view (the same contract the
+golden case uses). Deterministic: it synthesizes the display surface from the case's
+own fields. Nothing from the sealed solution (culprit, true motive id, breaker chain)
+is exposed; the true motive's *text* appears only as one option among the decoys.
+
+Generated evidence renders as paper exhibits (reveal_text); richer per-type payloads
+(threads, keycard tables, voicemail) and authored tags/quotes are a later enhancement.
+"""
+
+from __future__ import annotations
+
+import re
+
+from ..generator.crime_profiles import CrimeProfile, profile_for
+from ..schemas.case import CaseFile
+from ..schemas.clue import Clue
+from .public_view import (
+    FlashbackAccount,
+    PublicCase,
+    PublicEvidence,
+    PublicFlashback,
+    PublicMotive,
+    PublicSuspect,
+    PublicVictim,
+    StoryBeat,
+    SuggestedQuestion,
+    TimelineBeat,
+)
+from .questions import FIXED_QUESTIONS
+
+_SCENES = ("skyline", "atrium", "interro", "seawall", "mezzanine", "desk")
+_WEATHER = (
+    "Rain, and a wind off the water.", "Fog thick enough to lean on.",
+    "A dry cold that gets into the joints.", "Sleet against every window.",
+)
+_GREETS = (
+    "Detective. Let's get this over with.",
+    "I already told the others everything I know.",
+    "Ask what you came to ask.",
+    "I have nothing to hide, if that's what you think.",
+)
+_APPARENT = (
+    "Was close enough to the victim to have a reason - and a chance.",
+    "Had more to lose tonight than they're letting on.",
+    "Their story has a seam in it, if you pull the right thread.",
+    "Stood to gain from a death no one saw coming.",
+)
+_DECOY_MOTIVES = (
+    "To bury a debt that was about to surface.",
+    "Jealousy that had festered for years.",
+    "To keep a buried secret buried.",
+    "To settle an old score, finally.",
+    "Fear of being exposed and ruined.",
+)
+# Keyword-matched icons so a letter looks like an envelope, a tumbler like a glass and a
+# bloodied letter opener like a blade - never a phone icon on a fingerprint. First match
+# wins, so the order is deliberate: specific objects (knife before "letter", footprints
+# before "prints", keycard before "key") come before the generic paper/photo buckets.
+_ICON_RULES: tuple[tuple[re.Pattern[str], str], ...] = (
+    (re.compile(r"cctv|camera|footage|surveillance|still\b", re.I), "cctv"),
+    (re.compile(r"photo|polaroid|snapshot|portrait|negative|film\b", re.I), "photoEv"),
+    (re.compile(r"knife|blade|dagger|razor|scissors?|shears|opener|stilett?o", re.I), "knife"),
+    (re.compile(r"voicemail|recording|tape\b|audio|cylinder|dictaphone|phonograph", re.I), "voicemail"),
+    (re.compile(r"phone|telephone|message|\bwire\b|\bcall\b|\btext\b", re.I), "phone"),
+    (re.compile(r"keycard|key card|access|badge|\bpass\b|swipe", re.I), "keycard"),
+    (re.compile(r"\bkey\b|\bkeys\b|keychain|keyring|latchkey|\block\b|padlock", re.I), "key"),
+    (re.compile(r"footprint|bootprint|\bboot\b|shoe|\bsole\b|tread|scuff|heel", re.I), "bootprint"),
+    (re.compile(r"fingerprint|thumbprint|handprint|prints?\b", re.I), "fingerprint"),
+    (re.compile(r"tumbler|glass\b|goblet|wine|whisky|whiskey|brandy|champagne|cocktail", re.I), "tumbler"),
+    (re.compile(r"bottle|vial|flask|perfume|poison|decanter|tonic|arsenic|cyanide|sedative", re.I), "bottle"),
+    (re.compile(r"match(es|box|book)?\b|lighter|accelerant|gasoline|petrol|kerosene|"
+                r"\bfuel\b|scorch|charred|\bburn(t|ed)?\b|ember|\bash\b|flame", re.I), "flame"),
+    (re.compile(r"cigar|cigarette|tobacco|ashtray", re.I), "cigarette"),
+    (re.compile(r"clock|\bwatch\b|timepiece|hourglass|pendulum", re.I), "clock"),
+    (re.compile(r"cufflink|jewell?|diamond|brooch|necklace|pendant|earring|locket|"
+                r"bracelet|\bgem\b|\bring\b|tiara|pearl|sapphire|ruby|emerald", re.I), "jewel"),
+    (re.compile(r"thread|fib(er|re)|cloth\b|fabric|handkerchief|scarf|glove|wool|silk|"
+                r"snag|button\b|lace\b", re.I), "thread"),
+    (re.compile(r"\bpen\b|\bnib\b|quill|fountain pen|inkwell|\bink\b", re.I), "pen"),
+    (re.compile(r"letter\b|envelope|telegram|postcard|\bnote\b|correspondence|\bmemo\b", re.I), "envelope"),
+    (re.compile(r"\bbook\b|journal|diary|ledger|notebook|manuscript|novel", re.I), "book"),
+    (re.compile(r"\bcash\b|banknote|money|wallet|billfold|currency|\bcoins?\b|bribe|payout", re.I), "cash"),
+    (re.compile(r"magnif|\blens\b|loupe", re.I), "magnifier"),
+    (re.compile(r"receipt|ticket|\bstub\b|paper|document|contract|deed|cheque|\bcheck\b|"
+                r"\bbill\b|pawn|invoice|agreement|statement|certificate|affidavit|\bwill\b|"
+                r"\bfile\b|\bform\b|register", re.I), "receipt"),
+    (re.compile(r"\bmap\b|compass|route|itinerary|timetable|schedule", re.I), "compass"),
+)
+# No keyword hit: fall back to how the clue is FOUND, which is always known - forensics
+# read as a print, documents as paper, searches as a scene photo, testimony as a voice.
+_METHOD_ICONS = {
+    "forensic": "fingerprint",
+    "document": "receipt",
+    "search": "photoEv",
+    "interrogation": "voicemail",
+}
+_ICONS = ("photoEv", "receipt", "compass", "envelope", "fingerprint")
+
+
+def _icon_for(name: str, reveal: str, idx: int, method: str = "") -> str:
+    # The NAME names the object itself, so it decides first; the reveal text only breaks
+    # a tie when the name says nothing (it describes context and loves false positives -
+    # a fingerprint whose reveal mentions "the blade" is still a fingerprint).
+    for hay in (name, reveal):
+        for rule, icon in _ICON_RULES:
+            if rule.search(hay):
+                return icon
+    return _METHOD_ICONS.get(method, _ICONS[idx % len(_ICONS)])
+# Noir city names so CITY reads as an actual city, not the venue (the venue goes in SCENE).
+_CITIES = (
+    "Graymoor", "Blackport", "Ashmoor", "Harrowgate", "Duskwater", "Coldhaven",
+    "Ravenreach", "Mortlake", "Greyharbor", "Thornehaven", "Mistport", "Hollowmere",
+    "Saltmarsh", "Ironhaven", "Blackwater", "Fellgate",
+)
+
+
+def _hash(s: str) -> int:
+    h = 0
+    for ch in s:
+        h = (h * 31 + ord(ch)) & 0x7FFFFFFF
+    return h
+
+
+def _clock(minute: int) -> str:
+    h = (minute // 60) % 24
+    m = minute % 60
+    suffix = "AM" if h < 12 else "PM"
+    h12 = h % 12 or 12
+    return f"{h12}:{m:02d} {suffix}"
+
+
+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 _suspect_public(case: CaseFile, idx: int) -> PublicSuspect:
+    s = case.suspects[idx]
+    seed = _hash(s.sus_id)
+    role_word = (s.role.split()[-1] if s.role else "").strip(".,").upper()
+    tag = f"THE {role_word}" if role_word else "PERSON OF INTEREST"
+    quote = (s.persona_summary.split(".")[0] + ".") if s.persona_summary else "I've nothing to hide."
+    gender = "female" if ((s.visual.gender if s.visual else "") or "").lower().startswith("f") else "male"
+    return PublicSuspect(
+        id=s.sus_id,
+        name=s.name,
+        role=s.role,
+        age=30 + (seed % 35),
+        sprite=s.sus_id,
+        gender=gender,
+        tag=tag[:22],
+        baseline_suspicion=25 + (seed % 16),
+        motive=_APPARENT[idx % len(_APPARENT)],
+        alibi=s.stated_alibi.claim_text,
+        quote=quote,
+        greet=_GREETS[idx % len(_GREETS)],
+        suggested_questions=tuple(SuggestedQuestion(id=q, q=text) for q, text in FIXED_QUESTIONS),
+    )
+
+
+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(
+        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),
+        time=time,
+        found=f"Recovered from {_loc_name(case, clue.discoverable_at_loc_id)}.",
+        summary=clue.reveal_text,
+        detail=clue.reveal_text,
+    )
+
+
+def _timeline(case: CaseFile, profile: CrimeProfile) -> tuple[TimelineBeat, ...]:
+    beats: list[TimelineBeat] = []
+    w = case.setting.murder_window
+    beats.append(TimelineBeat(time=_clock(w.start_min), label="The evening is under way; everyone is in the house.", locked=True))
+    culprit = case.culprit.sus_id
+    for i, clue in enumerate(case.clues):
+        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)
+        t = at if at is not None else w.start_min + 7 * (i + 1)
+        conflict = clue.contradicts_alibi_of == culprit
+        beats.append(TimelineBeat(time=_clock(t), label=clue.reveal_text[:80], ev=clue.clue_id, conflict=conflict))
+    incident = profile.timeline_line.format(
+        name=case.victim.name, instrument=case.weapon.name,
+        room=_loc_name(case, case.victim.found_at_loc_id),
+    )
+    beats.append(TimelineBeat(time=_clock(case.victim.time_of_death.start_min), label=incident, locked=True))
+    beats.sort(key=lambda b: b.time)
+    return tuple(beats)
+
+
+def _flashback(case: CaseFile) -> PublicFlashback:
+    culprit = next((s for s in case.suspects if s.sus_id == case.culprit.sus_id), case.suspects[0])
+    claimed = _loc_name(case, case.culprit.alibi_lie.claimed_loc_id)
+    crime = _loc_name(case, case.victim.found_at_loc_id)
+    breakers = [c for c in case.clues if c.contradicts_alibi_of == culprit.sus_id][:3]
+    return PublicFlashback(
+        title="TWO ACCOUNTS",
+        a=FlashbackAccount(
+            who=f"{culprit.name} SAYS",
+            scene=claimed,
+            lines=(culprit.stated_alibi.claim_text, f"I was in {claimed} the whole time.", "I never went near it."),
+            flags=(),
+        ),
+        b=FlashbackAccount(
+            who="THE EVIDENCE SAYS",
+            scene=crime,
+            lines=tuple(c.reveal_text[:90] for c in breakers) or ("The evidence places someone at the scene.",),
+            flags=tuple(range(len(breakers))),
+        ),
+    )
+
+
+def _motives(case: CaseFile, seed: int) -> tuple[PublicMotive, ...]:
+    true_text = case.culprit.true_motive.summary
+    decoys = [d for d in _DECOY_MOTIVES if d.lower() != true_text.lower()]
+    chosen = [PublicMotive(id="M1", text=true_text)]
+    for i in range(3):
+        chosen.append(PublicMotive(id=f"MD{i + 1}", text=decoys[(seed + i) % len(decoys)]))
+    # stable shuffle by seed so the true option isn't always first
+    rot = seed % len(chosen)
+    return tuple(chosen[rot:] + chosen[:rot])
+
+
+def _story_beats(case: CaseFile, profile: CrimeProfile, scene: str) -> tuple[StoryBeat, ...]:
+    """Each beat's backdrop is the place its text describes: the city for the call, the
+    REAL crime scene for the incident, another room of the same building for the cast,
+    and the detective's desk for the hand-off."""
+    v = case.victim
+    crime_loc = case.victim.found_at_loc_id
+    building = case.setting.name
+    other_room = next(
+        (loc.name for loc in case.setting.locations if loc.loc_id != crime_loc),
+        _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}"),
+        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",
+                  text="One of them is lying to your face. Find the crack in the account and follow it down."),
+    )
+
+
+def casefile_to_public(case: CaseFile) -> PublicCase:
+    seed = case.seed
+    profile = profile_for(case.crime_kind)
+    tod = case.victim.time_of_death.start_min
+    building = case.setting.name
+    room = _loc_name(case, case.victim.found_at_loc_id)
+    scene = f"{building} — {room}"  # building + room; the painter keys off the room
+    city = _CITIES[seed % len(_CITIES)]
+    return PublicCase(
+        id=case.case_id,
+        city=city,
+        district=building,
+        title=case.title,
+        tagline="Detective, your presence is required.",
+        weather=_WEATHER[seed % len(_WEATHER)],
+        victim=PublicVictim(name=case.victim.name, role=case.victim.role, age=40 + (seed % 30), sprite="victim", bio=case.briefing),
+        scene=scene,
+        tod=_clock(tod),
+        found=f"{profile.found_verb} {scene} at {_clock(case.victim.found_at_min)}.",
+        cause=case.victim.cause_of_death,
+        kind=profile.kind.value,
+        kind_label=profile.kind_label,
+        division=profile.division,
+        victim_status=profile.victim_status,
+        tod_label=profile.tod_label,
+        verdict=profile.verdict,
+        facts=(
+            ("CITY", city),
+            ("VICTIM", f"{case.victim.name}"),
+            ("SCENE", scene),
+            (profile.tod_label, _clock(tod)),
+            ("WHAT HAPPENED", case.victim.cause_of_death),
+            ("VERDICT", profile.verdict),
+        ),
+        boot_lines=(
+            "The phone drags you up out of half a sleep.",
+            f"{case.setting.name}. {profile.boot_line}",
+            f"{case.victim.name} - {case.victim.role}.",
+            "They're holding the scene. It's yours now, detective.",
+        ),
+        story_beats=_story_beats(case, profile, scene),
+        suspects=tuple(_suspect_public(case, i) for i in range(len(case.suspects))),
+        evidence=tuple(_evidence_public(case, c, i) for i, c in enumerate(case.clues)),
+        timeline=_timeline(case, profile),
+        flashback=_flashback(case),
+        motives=_motives(case, seed),
+    )

web/src/engine/art.ts

@@ -290,6 +290,22 @@ export const EV_ICONS: Record<string, string[]> = {
   keycard: ['............', '.kkkkkkkkkk.', '.kssssssssk.', '.ksbbbbbbsk.', '.ksbaaaabsk.', '.ksbaWWabsk.', '.ksbaaaabsk.', '.ksbbbbbbsk.', '.ksssssssk..', '.kswwwwsssk.', '.kswwwwsssk.', '.kssssssssk.', '.kkkkkkkkkk.', '......kk....', '.....kgggk..', '............'],
   photoEv: ['.wwwwwwwwww.', '.wkkkkkkkkw.', '.wkdddddd kw', '.wkdaa..d.kw', '.wkd.aa..dkw', '.wkd..aa.dkw', '.wkd...aadkw', '.wkdGG..adkw', '.wkdddddddkw', '.wkdGGGGGdkw', '.wkddddddd kw', '.wkkkkkkkkw.', '.wwwwwwwwww.', '...ka.ak....', '..k.aa.k....', '............'],
   compass: ['......a.....', '.....aAa....', '....a.a.a...', '...a..a..a..', '..a...a...a.', '.a....a....a', 'a....aAa... a', '.aaaaaAaaaaa', 'a....aAa....a', '.a...a.a...a.', '..a..a.a..a..', '...a.a.a.a...', '....aa.aa....', '.....aAa.....', '......a......', '............'],
+  fingerprint: ['............', '...kkkkkk...', '..kGGGGGGk..', '.kGkkkkkkGk.', '.kGkGGGGkGk.', '.kGkGkkGkGk.', '.kGkGkGkkGk.', '.kGkGkGkGGk.', '.kGkGkkGkGk.', '.kGkGGGGkGk.', '.kGkkkkkkGk.', '..kGGGGGGk..', '...kkkkkk...', '............', '............', '............'],
+  tumbler: ['............', '.kkkkkkkkkk.', '.kwWWWWWWwk.', '.kw......wk.', '.kw....xxwk.', '.kw...x..wk.', '.kw......wk.', '.kwAAAAAAwk.', '.kwaaaaaawk.', '.kwaaaaaawk.', '.kwaaaaaawk.', '.kwwwwwwwwk.', '.kkkkkkkkkk.', '............', '............', '............'],
+  thread: ['............', '..kkkkkkkk..', '.kmmmmmmmmk.', '..kkkkkkkk..', '..kGgGgGgk..', '..kgGgGgGk..', '..kGgGgGgk..', '..kgGgGgGk..', '..kGgGgGgk..', '..kkkkkkkk..', '.kmmmmmmmmk.', '..kkkkkkkk..', '.......G....', '......G.....', '.......G....', '............'],
+  envelope: ['............', '............', '.kkkkkkkkkk.', '.kWkWWWWkWk.', '.kWWkWWkWWk.', '.kWWWkkWWWk.', '.kWWWWWWWWk.', '.kWWWxxWWWk.', '.kWWWxxWWWk.', '.kWWWWWWWWk.', '.kkkkkkkkkk.', '............', '............', '............', '............', '............'],
+  bottle: ['....kkkk....', '....kmmk....', '....kwwk....', '....kwwk....', '...kkwwkk...', '..kwggggwk..', '.kwggggggwk.', '.kwgWWWWgwk.', '.kwgWxxWgwk.', '.kwgWWWWgwk.', '.kwggggggwk.', '.kwggggggwk.', '..kwggggwk..', '...kkkkkk...', '............', '............'],
+  knife: ['.....kk.....', '....kWWk....', '....kWwk....', '....kWwk....', '....kWwk....', '....kWwk....', '....kWwk....', '....kWwk....', '...kkkkkk...', '..kmmmmmmk..', '...kkddkk...', '....kddk....', '....kddk....', '....kddk....', '....kkkk....', '............'],
+  clock: ['.....kk.....', '....kaak....', '..kkkkkkkk..', '.kaWWWWWWak.', 'kaWWWkWWWWak', 'kaWWWkWWWWak', 'kaWWWkkkWWak', 'kaWWWWWWWWak', 'kaWWWWWWWWak', '.kaWWWWWWak.', '..kkkkkkkk..', '............', '............', '............', '............', '............'],
+  jewel: ['............', '.....kk.....', '....kGGk....', '...kGWWGk...', '...kGGGGk...', '....kkkk....', '...kaaaak...', '..kak..kak..', '..ka....ak..', '..kak..kak..', '...kaaaak...', '....kkkk....', '............', '............', '............', '............'],
+  cigarette: ['.......g....', '......g.....', '.......g....', '......g.....', '.......g....', '............', '.kkkkkkkkkk.', '.kmmWWWWaAk.', '.kmmWWWWaxk.', '.kkkkkkkkkk.', '............', '............', '............', '............', '............', '............'],
+  bootprint: ['............', '...kkkkk....', '..kdddddk...', '..kdkdkdk...', '..kdddddk...', '..kdkdkdk...', '..kdddddk...', '...kkkkk....', '............', '...kkkk.....', '..kddddk....', '..kdkkdk....', '..kddddk....', '...kkkk.....', '............', '............'],
+  book: ['............', '..kkkkkkkk..', '.kexxxxxxWk.', '.kexxxxxxWk.', '.kexaaaaxWk.', '.kexaaaaxWk.', '.kexxxxxxWk.', '.kexxxxxxWk.', '.kexxxxxxWk.', '.kexxxxxxWk.', '.kexxxxxxWk.', '..kkkkkkkk..', '............', '............', '............', '............'],
+  key: ['............', '...kkkk.....', '..ka..ak....', '..ka..ak....', '...kaak.....', '....kak.....', '....kak.....', '....kak.....', '....kak.....', '....kaak....', '....kak.....', '....kaak....', '....kkk.....', '............', '............', '............'],
+  flame: ['....kaak....', '...kaAAak...', '...kaAAak...', '...kaAAak...', '....kaak....', '.....xx.....', '.....mm.....', '.....mm.....', '.....mm.....', '.....mm.....', '.....mm.....', '.....mm.....', '.....kk.....', '............', '............', '............'],
+  pen: ['....kkkk....', '....kxxk....', '....kxxk....', '....kxxk....', '....kxxk....', '....kxxk....', '....kxxk....', '....kaak....', '....kWWk....', '....kWWk....', '.....kWk....', '.....kk.....', '............', '............', '............', '............'],
+  cash: ['............', '............', '.kkkkkkkkkk.', '.kgaggggggk.', '.kgagGGgggk.', '.kgagGGgggk.', '.kgaggggggk.', '.kkkkkkkkkk.', '..kggggggk..', '..kkkkkkkk..', '............', '............', '............', '............', '............', '............'],
+  magnifier: ['...kkkk.....', '..kGGGGk....', '.kGWGGGGk...', '.kGGGGGGk...', '.kGGGGGGk...', '..kGGGGk....', '...kkkkk....', '......kkk...', '.......kmk..', '........kmk.', '.........kk.', '............', '............', '............', '............', '............'],
 }
 
 // ---- scene painters ----