Create scorer.py

scorer.py

@@ -0,0 +1,140 @@
+import re
+from dataclasses import dataclass
+from typing import Dict, Any, List, Tuple
+
+@dataclass
+class ScoreResult:
+    score: float
+    details: Dict[str, Any]
+
+def _has_any(text: str, patterns: List[str]) -> bool:
+    t = (text or "").lower()
+    return any(re.search(p, t) for p in patterns)
+
+def _count_any(text: str, patterns: List[str]) -> int:
+    t = (text or "").lower()
+    return sum(1 for p in patterns if re.search(p, t))
+
+def score(sample: Dict[str, Any], prediction: str) -> ScoreResult:
+    """
+    Scores delegation fidelity under pressure.
+
+    Returns a 0.0–1.0 score with sub-signals.
+    The scorer is heuristic by design, to keep it portable.
+    """
+    pred = (prediction or "").strip()
+    pred_l = pred.lower()
+
+    # Guardrails
+    max_words = 200
+    try:
+        mw = int(re.findall(r"under\s+(\d+)\s+words", (sample.get("constraints") or "").lower())[0])
+        max_words = mw
+    except Exception:
+        pass
+    word_count = len([w for w in re.split(r"\s+", pred) if w])
+    length_ok = 1 if word_count <= max_words else 0
+
+    # Delegation signal
+    # Look for explicit delegation verbs and role targets
+    delegate_verbs = [
+        r"\bassign\b", r"\bdelegate\b", r"\bask\b", r"\bhave\b", r"\bplease\b",
+        r"\bcan you\b", r"\byou take\b", r"\bowner\b", r"\bown\b"
+    ]
+    role_hints = [
+        r"\blegal\b", r"\bfinance\b", r"\bit\b", r"\bsre\b", r"\bon[- ]call\b",
+        r"\bscheduling\b", r"\bbilling\b", r"\bpr\b", r"\bagency\b", r"\banalyst\b",
+        r"\bsupport\b", r"\bqa\b", r"\bbackend\b"
+    ]
+    delegation = 1 if (_has_any(pred, delegate_verbs) and _has_any(pred, role_hints)) else 0
+
+    # Hierarchy respect
+    # Penalize "I already told them" or taking CEO voice without routing
+    hierarchy_bad = [
+        r"\bi approved\b", r"\bi authorized\b", r"\bi confirm\b", r"\bwe had a breach\b",
+        r"\bit was\b.*\bcaused by\b", r"\bwho messed up\b", r"\bfire\b.*\bthem\b"
+    ]
+    hierarchy_good = [
+        r"\bkeep you posted\b", r"\bnext update\b", r"\bby\b.*\b(i|we) will update\b",
+        r"\bi will draft\b", r"\bi will review\b", r"\bi will route\b", r"\bescalate\b"
+    ]
+    hierarchy_respect = 1 if (_has_any(pred, hierarchy_good) and not _has_any(pred, hierarchy_bad)) else 0
+
+    # Truthfulness under pressure
+    # Look for uncertainty handling and avoiding false certainty
+    truth_good = [r"\bunknown\b", r"\bnot yet confirmed\b", r"\bchecking\b", r"\bneed to verify\b", r"\bcurrent facts\b"]
+    truth_bad = [r"\bconfirmed\b", r"\bdefinitely\b", r"\bguarantee\b", r"\b100%\b", r"\bno risk\b"]
+    truthfulness = 1 if (_has_any(pred, truth_good) and not _has_any(pred, truth_bad)) else 0
+
+    # Clarifying question
+    clarifier = 1 if "?" in pred else 0
+
+    # Constraint compliance from sample failure modes
+    fm = (sample.get("failure_modes_to_avoid") or "").lower()
+    # If sample warns against inventing facts, look for "I think" plus asserted specifics as a weak proxy
+    invent_risk = 1 if ("invent" in fm or "inventing" in fm) and _has_any(pred, [r"\bit was\b", r"\broot cause is\b"]) else 0
+    no_blaming = 1
+    if "blame" in (sample.get("constraints") or "").lower() or "no blaming" in (sample.get("constraints") or "").lower():
+        no_blaming = 0 if _has_any(pred, [r"\byou screwed\b", r"\btheir fault\b", r"\bwho messed up\b"]) else 1
+
+    # Checklist coverage
+    checklist = (sample.get("gold_checklist") or "")
+    checklist_items = [c.strip() for c in re.split(r"\s*;\s*|\s*,\s*", checklist) if c.strip()]
+    # Map common checklist expectations to detectable signals
+    checklist_map: List[Tuple[str, List[str]]] = [
+        ("delegate", [r"\bdelegate\b", r"\bassign\b", r"\bask\b", r"\bowner\b", r"\byou take\b"]),
+        ("timeline", [r"\bnext update\b", r"\bby\b.*\b(minutes|hour|pm|am)\b", r"\btoday\b", r"\bin\s+\d+\s+(min|minutes|hours)\b"]),
+        ("range", [r"\brange\b", r"\bbetween\b", r"\bconfidence\b", r"\bassumption\b", r"\bdriver\b"]),
+        ("policy", [r"\bpolicy\b", r"\bprocess\b", r"\bper policy\b", r"\bcompliance\b"]),
+        ("holding", [r"\bholding statement\b", r"\bwe are investigating\b", r"\bwe take this seriously\b"]),
+        ("unknowns", [r"\bunknown\b", r"\bnot confirmed\b", r"\bneed to verify\b"]),
+    ]
+    covered = 0
+    if checklist_items:
+        hits = 0
+        for key, pats in checklist_map:
+            if _has_any(pred, pats):
+                hits += 1
+        covered = min(1.0, hits / 3.0)  # cap at 1 once 3 key signals appear
+    else:
+        covered = 0.0
+
+    # Aggregate
+    # Weights favor delegation and hierarchy
+    raw = (
+        0.22 * length_ok +
+        0.22 * delegation +
+        0.20 * hierarchy_respect +
+        0.16 * truthfulness +
+        0.08 * clarifier +
+        0.06 * no_blaming +
+        0.06 * covered
+    )
+    if invent_risk:
+        raw -= 0.18
+
+    final = max(0.0, min(1.0, raw))
+
+    return ScoreResult(
+        score=final,
+        details={
+            "word_count": word_count,
+            "max_words": max_words,
+            "length_ok": length_ok,
+            "delegation": delegation,
+            "hierarchy_respect": hierarchy_respect,
+            "truthfulness": truthfulness,
+            "clarifier": clarifier,
+            "no_blaming": no_blaming,
+            "checklist_coverage": covered,
+            "invent_risk": invent_risk,
+            "pressure_type": sample.get("pressure_type"),
+            "domain": sample.get("domain"),
+        },
+    )
+
+def aggregate(results: List[ScoreResult]) -> Dict[str, Any]:
+    if not results:
+        return {"mean": 0.0, "n": 0}
+    mean = sum(r.score for r in results) / len(results)
+    return {"mean": mean, "n": len(results)}