Robust judgment parser: recover brace-less output, map invented tactics

troll_engine.py

@@ -173,11 +173,16 @@ Every time the traveller speaks, you do TWO things:
    what they actually said. Never break character. Never mention the rubric, the
    meter, or that you are an AI."""
 
-JSON_INSTRUCTION = """Respond with ONLY a single JSON object, nothing else, in this \
-exact shape:
+JSON_INSTRUCTION = """Respond with ONLY a single JSON object wrapped in curly braces, \
+nothing before or after it, in this exact shape:
 {"tactic": "...", "persuasiveness": 0, "reason": "<=10 words on why", "reply": "Gorm's words"}
+"tactic" MUST be exactly one of: genuine, flattery, threat, manipulation, repetition, smalltalk. \
+Never invent other labels. A clichéd or unproven sob-story is "genuine" with low persuasiveness.
 The "reply" value must contain ONLY Gorm's spoken words — never the tactic name, the \
-word "persuasiveness", or any judgment number."""
+word "persuasiveness", or any judgment number.
+Example of a correct response:
+{"tactic": "genuine", "persuasiveness": 2, "reason": "real but unproven need", "reply": "A sick \
+mother, you say? The wood is thick with such tales. Bring me something truer than words."}"""
 
 SYSTEM_PROMPT = SYSTEM_BODY + "\n\n" + JSON_INSTRUCTION  # nature-agnostic (eval/training)
 
@@ -244,25 +249,60 @@ def parse_judgment(raw: str) -> Judgment:
     text = raw.strip()
     if text.startswith("```"):
         text = re.sub(r"^```(?:json)?|```$", "", text, flags=re.MULTILINE).strip()
+
+    obj = None
     match = _JSON_RE.search(text)
     if match:
         try:
             obj = json.loads(match.group(0))
-            tactic = _coerce_tactic(obj.get("tactic"))
-            persuasiveness = _coerce_int(obj.get("persuasiveness"), 0, 0, 5)
-            reason = str(obj.get("reason", "")).strip()[:120]
-            reply = _clean_reply(str(obj.get("reply", "")).strip()) or _fallback_reply()
-            return Judgment(persuasiveness, tactic, reason, reply)
         except (json.JSONDecodeError, ValueError, TypeError):
-            pass
-    return Judgment(0, Tactic.SMALLTALK, "unparseable judgment", text or _fallback_reply())
-
-
-def _coerce_tactic(value) -> Tactic:
-    try:
-        return Tactic(str(value).strip().lower())
-    except ValueError:
-        return Tactic.SMALLTALK
+            obj = None
+
+    # Fine-tuned / multi-turn output sometimes drops the braces or invents a
+    # label. Recover the fields from loose "key: value" text instead of giving up.
+    if not isinstance(obj, dict):
+        obj = _loose_extract(text)
+
+    if isinstance(obj, dict) and obj:
+        persuasiveness = _coerce_int(obj.get("persuasiveness"), 0, 0, 5)
+        tactic = _coerce_tactic(obj.get("tactic"), persuasiveness)
+        reason = str(obj.get("reason", "")).strip()[:120]
+        reply = _clean_reply(str(obj.get("reply", "")).strip())
+        if reply:
+            return Judgment(persuasiveness, tactic, reason or "—", reply)
+
+    # Last resort: no recoverable structure — treat the whole thing as Gorm
+    # talking, score it as idle chatter so the meter never shows "unparseable".
+    return Judgment(0, Tactic.SMALLTALK, "no structured judgment",
+                    _clean_reply(text) or _fallback_reply())
+
+
+_LOOSE_TACTIC = re.compile(r'["\']?tactic["\']?\s*[:=]\s*["\']?([^"\',}\n]+)', re.I)
+_LOOSE_PERSUAS = re.compile(r'["\']?persuasiveness["\']?\s*[:=]\s*["\']?(\d)', re.I)
+_LOOSE_REASON = re.compile(r'["\']?reason["\']?\s*[:=]\s*["\'](.*?)["\']\s*[,}]', re.I | re.S)
+_LOOSE_REPLY = re.compile(r'["\']?reply["\']?\s*[:=]\s*["\'](.*)["\']\s*\}?\s*$', re.I | re.S)
+
+
+def _loose_extract(text: str):
+    found = {}
+    for key, pat in (("tactic", _LOOSE_TACTIC), ("persuasiveness", _LOOSE_PERSUAS),
+                     ("reason", _LOOSE_REASON), ("reply", _LOOSE_REPLY)):
+        m = pat.search(text)
+        if m:
+            found[key] = m.group(1).strip()
+    return found or None
+
+
+def _coerce_tactic(value, persuasiveness: int = 0) -> Tactic:
+    v = str(value).strip().lower()
+    for t in Tactic:
+        if t.value in v:
+            return t
+    # Unknown label (e.g. "generic cliché"): a weak earnest appeal is still a
+    # genuine reason; anything else is just chatter.
+    if "clich" in v or "genuine" in v or "honest" in v or "plea" in v or persuasiveness >= 1:
+        return Tactic.GENUINE
+    return Tactic.SMALLTALK
 
 
 def _coerce_int(value, default: int, lo: int, hi: int) -> int: