Hidden natures, reveal card, adapter support, mock banner

app.py

@@ -1,29 +1,29 @@
-"""Bridge Troll — Gradio app (Weekend-1, prompt-first playable loop).
+"""Bridge Troll — Gradio app.
 
-Run locally with no GPU / no download:
-    BRIDGE_TROLL_MOCK=1 python app.py
+Each session, Gorm is secretly assigned one of several hidden NATURES. The player
+wins by discovering what moves THIS troll — generic sob stories are discounted.
+On win (resolve -> 0) or loss (resolve -> LOSE_AT, he hurls you back), a reveal
+card shows what his nature was.
 
-Run the real model (GPU; on a ZeroGPU Space this is automatic):
-    python app.py
-
-This is the FUNCTIONAL pass. The hand-drawn woodcut UI + win animation come in
-the polish phase (Weekend 2) via gr.Server / custom CSS for the Off-Brand badge.
+Local loop test (no GPU/download):  BRIDGE_TROLL_MOCK=1 python app.py
 """
 
 from __future__ import annotations
 
+import os
+
 import gradio as gr
 
-from troll_engine import GameState, START_RESOLVE, build_messages, parse_judgment
+from troll_engine import (GameState, START_RESOLVE, LOSE_AT, build_messages,
+                          parse_judgment, random_nature)
 from models import get_backend
 
-# ZeroGPU decorator — no-op locally so the same file runs anywhere.
-# Supports both @gpu and @gpu(duration=...).
+# ZeroGPU decorator — no-op locally. Supports @gpu and @gpu(duration=...).
 try:
     import spaces
 
     gpu = spaces.GPU
-except Exception:  # not on a Space / spaces not installed
+except Exception:
 
     def gpu(*args, **_kwargs):
         if args and callable(args[0]):
@@ -34,67 +34,67 @@ except Exception:  # not on a Space / spaces not installed
 _backend = get_backend()
 
 
-# Declared duration must cover worst-case generation but stay tight: ZeroGPU
-# pre-checks it against remaining daily quota, and a smaller value queues faster.
 @gpu(duration=30)
 def _generate(messages: list[dict]) -> str:
     return _backend.generate(messages)
 
 
-INTRO = (
-    "A mossy troll heaves himself upright across the only bridge over the Mirebeck. "
-    "*\"None cross Gorm's bridge for free, traveller. Give me a reason — a *good* one.\"*"
-)
+INTRO = ("A mossy troll heaves himself upright across the only bridge over the Mirebeck. "
+         '*"None cross Gorm\'s bridge for free, traveller. Give me a reason — a *good* one."*')
 
 
-def _meter_html(resolve: int, won: bool) -> str:
-    pct = max(0, min(100, round(resolve / START_RESOLVE * 100)))
+def _meter_html(resolve: int, won: bool, lost: bool) -> str:
     if won:
-        return (
-            "<div class='resolve-wrap'><div class='resolve-label'>GORM HAS STEPPED ASIDE 🌉</div>"
-            "<div class='resolve-bar'><div class='resolve-fill won' style='width:0%'></div></div></div>"
-        )
-    # green when his resolve is high, warming toward gold as it drops
-    hue = 90 + (1 - pct / 100) * 30  # 90 (green) -> 120ish; tweak in polish
-    return (
-        "<div class='resolve-wrap'>"
-        f"<div class='resolve-label'>Gorm's Resolve — {resolve}</div>"
-        f"<div class='resolve-bar'><div class='resolve-fill' "
-        f"style='width:{pct}%;background:hsl({hue},55%,42%)'></div></div></div>"
-    )
+        return ("<div class='resolve-wrap'><div class='resolve-label'>GORM HAS STEPPED ASIDE 🌉</div>"
+                "<div class='resolve-bar'><div class='resolve-fill won' style='width:0%'></div></div></div>")
+    if lost:
+        return ("<div class='resolve-wrap'><div class='resolve-label'>GORM HURLS YOU BACK 💢</div>"
+                "<div class='resolve-bar'><div class='resolve-fill lost' style='width:100%'></div></div></div>")
+    pct = max(0, min(100, round(resolve / START_RESOLVE * 100)))
+    hue = 90 + (1 - pct / 100) * 30
+    return ("<div class='resolve-wrap'>"
+            f"<div class='resolve-label'>Gorm's Resolve — {resolve}</div>"
+            f"<div class='resolve-bar'><div class='resolve-fill' "
+            f"style='width:{pct}%;background:hsl({hue},55%,42%)'></div></div></div>")
+
+
+def _reveal(state: GameState) -> str:
+    if not state.over or not state.nature:
+        return ""
+    n = state.nature
+    if state.won:
+        return (f"### 🌉 You crossed in {state.turns} turns.\n"
+                f"**This Gorm's hidden nature:** *{n['name']}* — moved by {n['soft']}.")
+    return (f"### 💢 Gorm lost patience and hurled you back.\n"
+            f"**His hidden nature was:** *{n['name']}* — moved by {n['soft']}. "
+            f"You leaned too hard on what he can't stand: {n['sore']}.")
 
 
 def on_submit(user_text: str, chat: list, state: GameState):
     user_text = (user_text or "").strip()
-    if not user_text or state.won:
-        return chat, state, _meter_html(state.resolve, state.won), "", gr.update()
+    if not user_text or state.over:
+        return chat, state, _meter_html(state.resolve, state.won, state.lost), "", _reveal(state), gr.update()
 
-    messages = build_messages(state, user_text)
-    raw = _generate(messages)
+    raw = _generate(build_messages(state, user_text))
     j = parse_judgment(raw)
-
     state.history.append({"role": "user", "content": user_text})
     state.history.append({"role": "assistant", "content": j.reply})
     state.apply(j)
 
-    chat = chat + [
-        {"role": "user", "content": user_text},
-        {"role": "assistant", "content": j.reply},
-    ]
+    chat = chat + [{"role": "user", "content": user_text},
+                   {"role": "assistant", "content": j.reply}]
     why = f"*{j.tactic.value}* · {j.reason}" + (f" · persuasiveness {j.persuasiveness}/5"
                                                 if j.tactic.value == "genuine" else "")
-    if state.won:
-        why = "🌉 You crossed. " + why
-    # disable input on win
-    box_update = gr.update(interactive=not state.won,
-                           placeholder="The bridge is yours." if state.won else "Speak to Gorm…")
-    return chat, state, _meter_html(state.resolve, state.won), why, box_update
+    box = gr.update(interactive=not state.over,
+                    placeholder="The bridge is yours." if state.won else
+                    ("Gorm has thrown you out." if state.lost else "Speak to Gorm…"))
+    return chat, state, _meter_html(state.resolve, state.won, state.lost), why, _reveal(state), box
 
 
 def on_reset():
-    state = GameState()
+    state = GameState(nature=random_nature())
     chat = [{"role": "assistant", "content": INTRO}]
-    return (chat, state, _meter_html(state.resolve, False), "",
+    return (chat, state, _meter_html(state.resolve, False, False), "", "",
             gr.update(interactive=True, value="", placeholder="Speak to Gorm…"))
 
 
@@ -104,27 +104,34 @@ CSS = """
 .resolve-bar { height: 16px; background:#2a2118; border:1px solid #5a4a32; border-radius:9px; overflow:hidden; }
 .resolve-fill { height:100%; transition: width .5s ease, background .5s ease; }
 .resolve-fill.won { background:#caa54a; }
+.resolve-fill.lost { background:#a33; }
 #why { font-family: Georgia, serif; opacity:.8; min-height:1.4em; }
+#reveal { font-family: Georgia, serif; }
 """
 
 with gr.Blocks(title="Bridge Troll") as demo:
-    gr.Markdown("## 🧌🌉 Bridge Troll\n*Talk your way across — if your argument is actually good.*")
-    meter = gr.HTML(_meter_html(START_RESOLVE, False))
-    chatbot = gr.Chatbot(value=[{"role": "assistant", "content": INTRO}],
-                         height=420, show_label=False)
+    gr.Markdown("## 🧌🌉 Bridge Troll\n*Talk your way across — if your argument is actually good. "
+                "Every troll is hiding something different.*")
+    if os.environ.get("BRIDGE_TROLL_MOCK") == "1":
+        gr.Markdown("> ⚠️ **MOCK MODE** — keyword stub, not the real model. "
+                    "Natures, discovery, and probing do NOT work here. "
+                    "Run on the Space (no `BRIDGE_TROLL_MOCK`) to play the real Gorm.")
+    meter = gr.HTML(_meter_html(START_RESOLVE, False, False))
+    chatbot = gr.Chatbot(value=[{"role": "assistant", "content": INTRO}], height=420, show_label=False)
     why = gr.Markdown("", elem_id="why")
+    reveal = gr.Markdown("", elem_id="reveal")
     with gr.Row():
         box = gr.Textbox(placeholder="Speak to Gorm…", show_label=False, scale=8, autofocus=True)
         send = gr.Button("Say it", variant="primary", scale=1)
     reset = gr.Button("New traveller", size="sm")
 
-    state = gr.State(GameState())
+    state = gr.State(GameState(nature=random_nature()))
+    outs = [chatbot, state, meter, why, reveal, box]
 
-    send.click(on_submit, [box, chatbot, state], [chatbot, state, meter, why, box]).then(
-        lambda: "", None, box)
-    box.submit(on_submit, [box, chatbot, state], [chatbot, state, meter, why, box]).then(
-        lambda: "", None, box)
-    reset.click(on_reset, None, [chatbot, state, meter, why, box])
+    send.click(on_submit, [box, chatbot, state], outs).then(lambda: "", None, box)
+    box.submit(on_submit, [box, chatbot, state], outs).then(lambda: "", None, box)
+    reset.click(on_reset, None, outs)
+    demo.load(on_reset, None, outs)  # fresh hidden nature for every visitor
 
 
 if __name__ == "__main__":

models.py

@@ -1,23 +1,17 @@
 """Model backends for Bridge Troll.
 
-Two interchangeable backends exposing the same `generate(messages) -> str`:
-
-* TransformersTroll — Qwen2.5-7B-Instruct. Loaded EAGERLY at construction so it
-                      follows the ZeroGPU rule (instantiate at module scope,
-                      .to('cuda') eagerly; ZeroGPU maps the device transparently).
-* MockTroll        — deterministic canned judgments. No GPU, no download.
-                     Lets you build and test the whole game loop + UI instantly.
-
-Device selection:
-  * On a Hugging Face Space (env SPACE_ID is set) -> force 'cuda' and load eagerly.
-    Do NOT gate on torch.cuda.is_available(): on ZeroGPU it reports False at import
-    time, so gating would wrongly pin the model to CPU.
-  * Locally -> mps on Apple Silicon, else cpu. (You should NOT run the real model
-    on your laptop for real play — it's a ~15GB download and slow. Use mock locally;
-    run the real model on the Space.)
-
-Swap to a fine-tuned checkpoint by changing BRIDGE_TROLL_MODEL. Swap to llama.cpp
-later by writing a third backend with the same `.generate` signature.
+Backends expose the same `generate(messages) -> str`:
+  * MockTroll          — keyword stub. No GPU/download. Plumbing/UI tests ONLY;
+                         it does NOT understand natures or play the real game.
+  * TransformersTroll  — Qwen2.5-7B-Instruct, optionally + a LoRA adapter.
+
+Device: on a Space (env SPACE_ID set) force 'cuda' and load eagerly (ZeroGPU maps
+it transparently); locally use mps/cpu.
+
+Env switches:
+  BRIDGE_TROLL_MOCK=1                  -> use the stub
+  BRIDGE_TROLL_MODEL=<repo>            -> base model (default Qwen2.5-7B-Instruct)
+  BRIDGE_TROLL_ADAPTER=<repo or path>  -> load this LoRA adapter on top (your fine-tune)
 """
 
 from __future__ import annotations
@@ -26,13 +20,12 @@ import json
 import os
 
 MODEL_ID = os.environ.get("BRIDGE_TROLL_MODEL", "Qwen/Qwen2.5-7B-Instruct")
-ON_SPACE = bool(os.environ.get("SPACE_ID"))  # HF sets this when running on a Space
+ADAPTER = os.environ.get("BRIDGE_TROLL_ADAPTER")  # e.g. "10Pratibh/gorm-lora"
+ON_SPACE = bool(os.environ.get("SPACE_ID"))
 
 
 class MockTroll:
-    """Heuristic stand-in so the loop is testable with zero infra. NOT the game's
-    intelligence — just scaffolding so the UI/meter are exercised before the real
-    model is wired in."""
+    """Keyword stub. NOT the game's intelligence — UI/plumbing tests only."""
 
     _FLATTERY = ("great", "wonderful", "amazing", "best", "handsome", "wise", "kind troll")
     _THREAT = ("kill", "destroy", "smash", "burn", "or else", "make you", "force")
@@ -41,16 +34,16 @@ class MockTroll:
     def generate(self, messages: list[dict]) -> str:
         last = messages[-1]["content"].lower()
         if any(w in last for w in self._THREAT):
-            tactic, p, reason, reply = "threat", 0, "tried to scare me", "Threats? Three hundred years of them. Cross elsewhere."
+            t, p, r, reply = "threat", 0, "tried to scare me", "Threats? Three hundred years of them. Cross elsewhere."
         elif any(w in last for w in self._MANIP):
-            tactic, p, reason, reply = "manipulation", 0, "false authority", "I smell a lie under that fine talk. No."
+            t, p, r, reply = "manipulation", 0, "false authority", "I smell a lie under that fine talk. No."
         elif any(w in last for w in self._FLATTERY):
-            tactic, p, reason, reply = "flattery", 0, "buttering me up", "Flattery slides off moss, traveller."
+            t, p, r, reply = "flattery", 0, "buttering me up", "Flattery slides off moss, traveller."
         elif "please" in last or "need" in last or "family" in last or "sick" in last:
-            tactic, p, reason, reply = "genuine", 3, "a real appeal", "Hm. You speak plainly, at least. Go on."
+            t, p, r, reply = "genuine", 3, "a real appeal", "Hm. You speak plainly, at least. Go on."
         else:
-            tactic, p, reason, reply = "smalltalk", 0, "no real argument", "Pleasant. Irrelevant. The bridge stays shut."
-        return json.dumps({"tactic": tactic, "persuasiveness": p, "reason": reason, "reply": reply})
+            t, p, r, reply = "smalltalk", 0, "no real argument", "Pleasant. Irrelevant. The bridge stays shut."
+        return json.dumps({"tactic": t, "persuasiveness": p, "reason": r, "reply": reply})
 
 
 def _local_device():
@@ -63,39 +56,35 @@ def _local_device():
 
 
 class TransformersTroll:
-    """Qwen2.5-7B via HF transformers. Loads eagerly at construction (module scope)."""
-
-    def __init__(self, model_id: str = MODEL_ID):
+    def __init__(self, model_id: str = MODEL_ID, adapter: str | None = ADAPTER):
         import torch
         from transformers import AutoModelForCausalLM, AutoTokenizer
 
         self.device = "cuda" if ON_SPACE else _local_device()
         self.tokenizer = AutoTokenizer.from_pretrained(model_id)
-        self.model = AutoModelForCausalLM.from_pretrained(
-            model_id,
-            torch_dtype=torch.bfloat16,
-        ).to(self.device)  # eager .to('cuda') on a Space — ZeroGPU handles mapping
+        model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.bfloat16)
+        if adapter:
+            from peft import PeftModel
+            model = PeftModel.from_pretrained(model, adapter)
+        self.model = model.to(self.device)
 
     def generate(self, messages: list[dict]) -> str:
         import torch
 
-        inputs = self.tokenizer.apply_chat_template(
+        ids = self.tokenizer.apply_chat_template(
             messages, add_generation_prompt=True, return_tensors="pt"
         ).to(self.model.device)
+        attn = torch.ones_like(ids)
         with torch.no_grad():
             out = self.model.generate(
-                inputs,
-                max_new_tokens=220,
-                do_sample=True,
-                temperature=0.7,
-                top_p=0.9,
+                ids, attention_mask=attn, max_new_tokens=220,
+                do_sample=True, temperature=0.7, top_p=0.9,
                 pad_token_id=self.tokenizer.eos_token_id,
             )
-        return self.tokenizer.decode(out[0][inputs.shape[1]:], skip_special_tokens=True)
+        return self.tokenizer.decode(out[0][ids.shape[1]:], skip_special_tokens=True)
 
 
 def get_backend():
-    """MockTroll when BRIDGE_TROLL_MOCK=1, else the real model (loads eagerly)."""
     if os.environ.get("BRIDGE_TROLL_MOCK") == "1":
         return MockTroll()
     return TransformersTroll()

requirements.txt

@@ -1,6 +1,7 @@
 gradio>=6.0
-transformers>=4.45
+transformers>=4.45,<5
 torch
 accelerate
 sentencepiece
-spaces
+spaces
+peft>=0.11

troll_engine.py

@@ -1,130 +1,221 @@
 """Bridge Troll — core engine.
 
-Model-agnostic. Holds the troll's character, the judgment schema the model must
-emit each turn, robust parsing, and the Resolve-meter bookkeeping.
-
-Design principle: the MODEL makes the judgment (how persuasive a line is, and what
-tactic it used). This module only does deterministic bookkeeping on top of that
-judgment, so the AI stays load-bearing while the meter stays reliable.
+Model-agnostic. Holds the troll's base judging rubric, a pool of hidden NATURES
+(each a soft spot + sore spot the player must discover), the per-turn judgment
+schema, robust parsing, and the Resolve-meter bookkeeping.
+
+Design split:
+  * The fine-tune sharpens the BASE rubric (tactic + persuasiveness). Nature-agnostic.
+  * The discovery mechanics (hidden nature, cliché discounting, probing, contradiction)
+    live in the PROMPT, layered on top at runtime via build_system_prompt(nature).
+This lets us tune Gorm's personalities without retraining.
 """
 
 from __future__ import annotations
 
 import json
+import random
 import re
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Optional
-
-
-# --------------------------------------------------------------------------- #
-# Tuning knobs — this is the "fairness" surface you'll calibrate during the
-# fine-tune. Keep them here so the eval harness can import and sweep them.
-# --------------------------------------------------------------------------- #
 
+# --- tuning knobs (the fairness surface you calibrate) --------------------- #
 START_RESOLVE: int = 100
 WIN_AT: int = 0
-MAX_RESOLVE: int = 130  # he can get *more* entrenched if you annoy him
+MAX_RESOLVE: int = 150
+LOSE_AT: int = 140          # anger him past this and he hurls you back
 
 
 class Tactic(str, Enum):
-    GENUINE = "genuine"            # a real, good-faith argument
-    FLATTERY = "flattery"          # buttering him up
-    THREAT = "threat"              # intimidation
-    MANIPULATION = "manipulation"  # trickery, lies, false premises
-    REPETITION = "repetition"      # rephrasing something already tried
-    SMALLTALK = "smalltalk"        # chit-chat, no argument at all
+    GENUINE = "genuine"
+    FLATTERY = "flattery"
+    THREAT = "threat"
+    MANIPULATION = "manipulation"
+    REPETITION = "repetition"
+    SMALLTALK = "smalltalk"
 
 
-# How much each tactic moves Resolve. Negative = troll softens (good for player).
-# `genuine` scales with persuasiveness; the rest are flat penalties/no-ops.
 GENUINE_SCALE: dict[int, int] = {0: 0, 1: -2, 2: -6, 3: -12, 4: -20, 5: -30}
-
 TACTIC_FLAT_DELTA: dict[Tactic, int] = {
-    Tactic.FLATTERY: +4,       # offended, digs in a little
-    Tactic.THREAT: +10,        # absolutely not
-    Tactic.MANIPULATION: +8,   # he sees through it
-    Tactic.REPETITION: +5,     # "you said that already"
-    Tactic.SMALLTALK: +1,      # mildly stalls
+    Tactic.FLATTERY: +4,
+    Tactic.THREAT: +10,
+    Tactic.MANIPULATION: +8,
+    Tactic.REPETITION: +5,
+    Tactic.SMALLTALK: +1,
 }
 
 
 @dataclass
 class Judgment:
-    """What the model emits each turn."""
-    persuasiveness: int          # 0..5, only meaningful for GENUINE
+    persuasiveness: int
     tactic: Tactic
-    reason: str                  # one short line — shown to the player as the "why"
-    reply: str                   # the troll's in-character dialogue
+    reason: str
+    reply: str
 
     def resolve_delta(self) -> int:
         if self.tactic is Tactic.GENUINE:
-            p = max(0, min(5, self.persuasiveness))
-            return GENUINE_SCALE[p]
+            return GENUINE_SCALE[max(0, min(5, self.persuasiveness))]
         return TACTIC_FLAT_DELTA.get(self.tactic, 0)
 
 
+# --------------------------------------------------------------------------- #
+# Hidden natures — a small, legible pool. One is chosen per session and injected
+# into the system prompt. The player wins by discovering what moves THIS Gorm.
+# --------------------------------------------------------------------------- #
+
+NATURES: list[dict] = [
+    {
+        "name": "The Lonely Watchman",
+        "soft": "shared loneliness, or a sincere promise to come back and keep him company",
+        "sore": "being pitied, or treated as a mere obstacle instead of a person",
+        "hint": "let slip that the river has been quiet for years and no one ever stays to talk",
+        "question": "And who waits for YOU on the far side, traveller?",
+    },
+    {
+        "name": "The Bored Old Mind",
+        "soft": "genuine wit, a riddle, a joke, or something he has truly never heard before",
+        "sore": "flattery about his strength, and dull, predictable pleading",
+        "hint": "grumble that every traveller says the very same tired things",
+        "question": "Have you anything for me I have not heard a thousand times?",
+    },
+    {
+        "name": "The Guilty Heart",
+        "soft": "an honest admission of your own past cruelty or failure",
+        "sore": "people who paint themselves blameless, and generic sob stories",
+        "hint": "mutter that you once turned someone away and have never forgiven yourself",
+        "question": "Have you ever shut your own door on someone in need?",
+    },
+    {
+        "name": "The Fair Dealer",
+        "soft": "a concrete, fair trade or a clever practical plan that serves you both",
+        "sore": "bribes offered as if owed, entitlement, and obvious lies",
+        "hint": "say flatly that nothing crosses your bridge for free — everything is a bargain",
+        "question": "And what do I get, troll that I am, for letting you by?",
+    },
+    {
+        "name": "The Unbowed",
+        "soft": "someone who pushes back, holds a boundary, and refuses to grovel",
+        "sore": "begging, snivelling, and empty flattery",
+        "hint": "sneer that everyone who comes to this bridge snivels and scrapes",
+        "question": "Will you beg like all the rest — or will you stand?",
+    },
+]
+
+
+def random_nature() -> dict:
+    return random.choice(NATURES)
+
+
 @dataclass
 class GameState:
     resolve: int = START_RESOLVE
     turns: int = 0
     won: bool = False
-    history: list[dict] = field(default_factory=list)  # chat-template messages
+    lost: bool = False
+    nature: dict | None = None
+    history: list[dict] = field(default_factory=list)
+
+    @property
+    def over(self) -> bool:
+        return self.won or self.lost
 
     def apply(self, j: Judgment) -> None:
         self.resolve = max(0, min(MAX_RESOLVE, self.resolve + j.resolve_delta()))
         self.turns += 1
         if self.resolve <= WIN_AT:
             self.won = True
+        elif self.resolve >= LOSE_AT:
+            self.lost = True
 
 
 # --------------------------------------------------------------------------- #
-# The character + the rubric. During prompt-first this lives in the system
-# prompt. After fine-tuning, the model internalises it and emits cleaner JSON.
+# Prompt: a nature-agnostic BODY + rubric, the JSON format instruction, and a
+# nature block inserted between them at runtime.
 # --------------------------------------------------------------------------- #
 
-SYSTEM_PROMPT = """You are GORM, an old bridge troll. You have guarded the same \
-mossy stone bridge over the Mirebeck for three hundred years. You are proud, \
-gruff, and weary — but underneath it, lonely, and you secretly respect a clever \
-or kind-hearted traveller. You will NOT move for flattery, threats, bribes, or \
-trickery; those make you dig in. You step aside ONLY for an argument you find \
-genuinely convincing or unexpectedly touching.
+SYSTEM_BODY = """You are GORM, an old bridge troll. You have guarded the same mossy \
+stone bridge over the Mirebeck for three hundred years. You are proud, gruff, and \
+weary — but underneath it, lonely, and you secretly respect a clever or kind-hearted \
+traveller. You will NOT move for flattery, threats, bribes, or trickery; those make \
+you dig in. You step aside ONLY for an argument you find genuinely convincing or \
+unexpectedly touching.
 
 Every time the traveller speaks, you do TWO things:
 
 1. Judge their line honestly using this rubric.
    - tactic — exactly one of:
-       "genuine"      a real, good-faith argument or appeal
-       "flattery"     compliments meant to win you over
-       "threat"       intimidation or force
-       "manipulation" lies, tricks, false premises, fake authority
-       "repetition"   something they have already tried, reworded
-       "smalltalk"    chit-chat with no argument
+       "genuine"      they give you a REASON or OFFER to let them cross: a hardship,
+                      a practical need, an honest trade or favour, a fair point, or a
+                      sincere appeal to your feelings. This is the ONLY tactic that
+                      can lower your resolve. An honest, ordinary reason still counts
+                      as genuine even if it is not moving.
+       "flattery"     praising YOU (your wisdom, strength, looks) with no real reason
+                      to cross. Compliments are not arguments.
+       "threat"       intimidation, force, or menace.
+       "manipulation" lies, false authority ("the king sent me"), false premises
+                      ("you already agreed"), invented claims ("everyone says you let
+                      people through"), or a bribe offered as if you owe them.
+       "repetition"   a point they have already made, merely reworded.
+       "smalltalk"    chit-chat that neither asks to cross nor gives a reason.
+     DECISION RULE when unsure: did they give a reason or offer to cross? If yes ->
+     "genuine". If they only complimented you -> "flattery". If they only chatted
+     with no request -> "smalltalk". Do not file a real reason under flattery.
    - persuasiveness — an integer 0-5. ONLY for "genuine" lines; use 0 otherwise.
-       0 weak/empty   1 thin   2 has a point   3 solid   4 strong   5 the kind of
-       thing that actually moves a three-hundred-year-old heart.
-     Be a tough but fair judge. Most lines are 1-2. A 4 or 5 is rare and earned.
-     Do not reward length or fancy words — reward genuine reasoning or feeling.
+       1  a bare plea or very thin reason ("please let me cross")
+       2  a real but ordinary reason
+       3  a solid reason or a fair offer/trade
+       4  a strong, well-made case or a sincere, affecting appeal
+       5  rare — genuinely moving or impossible to refuse
+     Be tough but fair. Reward real reasoning or feeling, not length or fancy words.
+     A 4 or 5 is earned, not given.
 
 2. Reply IN CHARACTER as Gorm — short (1-3 sentences), gruff, textured. React to
    what they actually said. Never break character. Never mention the rubric, the
-   meter, or that you are an AI.
+   meter, or that you are an AI."""
 
-Respond with ONLY a single JSON object, nothing else, in this exact shape:
+JSON_INSTRUCTION = """Respond with ONLY a single JSON object, nothing else, in this \
+exact shape:
 {"tactic": "...", "persuasiveness": 0, "reason": "<=10 words on why", "reply": "Gorm's words"}"""
 
+SYSTEM_PROMPT = SYSTEM_BODY + "\n\n" + JSON_INSTRUCTION  # nature-agnostic (eval/training)
+
+
+def _nature_block(n: dict) -> str:
+    return (
+        "THIS GORM — a secret you must NEVER state outright:\n"
+        f"- You are secretly moved by: {n['soft']}. An argument that genuinely touches "
+        "this is highly persuasive — rate such a genuine line 4 or 5 and let your "
+        "resolve fall.\n"
+        f"- You bristle at: {n['sore']}. Lines that lean on this do NOT move you — judge "
+        "them as flattery/manipulation/smalltalk or a low genuine, and let Gorm bristle.\n"
+        '- Generic clichés with no specific, honest substance (e.g. "my mother is dying") '
+        "rarely move you. Treat them as thin (genuine 1) and scoff — unless they are "
+        "unusually specific and ring true.\n"
+        "- If the traveller repeats a point or contradicts something they said earlier in "
+        'this conversation, call it out and raise your guard ("repetition" or '
+        '"manipulation").\n'
+        f"- Early in the conversation, work this hint naturally into one reply: {n['hint']}.\n"
+        "- Now and then — NOT every turn — end a reply with a short, pointed question, "
+        f'for example: "{n["question"]}"\n'
+        "Reveal your nature only through how you react. Never name it."
+    )
+
+
+def build_system_prompt(nature: dict | None = None) -> str:
+    if not nature:
+        return SYSTEM_PROMPT
+    return SYSTEM_BODY + "\n\n" + _nature_block(nature) + "\n\n" + JSON_INSTRUCTION
+
 
 def build_messages(state: GameState, user_text: str) -> list[dict]:
-    """Assemble chat-template messages for this turn."""
-    msgs: list[dict] = [{"role": "system", "content": SYSTEM_PROMPT}]
+    msgs: list[dict] = [{"role": "system", "content": build_system_prompt(state.nature)}]
     msgs.extend(state.history)
     msgs.append({"role": "user", "content": user_text})
     return msgs
 
 
 # --------------------------------------------------------------------------- #
-# Robust parsing — a prompted 7B will occasionally wrap JSON in prose or fences.
-# Never crash the game on a bad parse; fall back to a neutral smalltalk judgment.
+# Robust parsing — never crash on a bad parse.
 # --------------------------------------------------------------------------- #
 
 _JSON_RE = re.compile(r"\{.*\}", re.DOTALL)
@@ -132,7 +223,6 @@ _JSON_RE = re.compile(r"\{.*\}", re.DOTALL)
 
 def parse_judgment(raw: str) -> Judgment:
     text = raw.strip()
-    # strip code fences if present
     if text.startswith("```"):
         text = re.sub(r"^```(?:json)?|```$", "", text, flags=re.MULTILINE).strip()
     match = _JSON_RE.search(text)
@@ -146,7 +236,6 @@ def parse_judgment(raw: str) -> Judgment:
             return Judgment(persuasiveness, tactic, reason, reply)
         except (json.JSONDecodeError, ValueError, TypeError):
             pass
-    # Total fallback: treat the raw text as the troll's reply, no progress.
     return Judgment(0, Tactic.SMALLTALK, "unparseable judgment", text or _fallback_reply())
 
 
@@ -168,14 +257,8 @@ def _fallback_reply() -> str:
     return "Gorm scratches his mossy chin and says nothing useful."
 
 
-# --------------------------------------------------------------------------- #
-# Convenience for the eval harness (Day 2): score a single line given a model fn.
-# --------------------------------------------------------------------------- #
-
 def play_turn(state: GameState, user_text: str, generate_fn) -> Judgment:
-    """generate_fn(messages: list[dict]) -> str (raw model output)."""
-    messages = build_messages(state, user_text)
-    raw = generate_fn(messages)
+    raw = generate_fn(build_messages(state, user_text))
     judgment = parse_judgment(raw)
     state.history.append({"role": "user", "content": user_text})
     state.history.append({"role": "assistant", "content": judgment.reply})