proofrag 0.3.0__py3-none-any.whl

proofrag/judge.py

@@ -0,0 +1,142 @@
+"""LLM-as-judge scoring + rank-aware retrieval metrics → results.json.
+
+Generation quality is scored by a pinned judge model on four dimensions
+(groundedness, correctness, completeness, citation_quality). Retrieval quality is
+scored separately (Recall@k, Precision@k, NDCG@k, MRR), so a retriever miss is
+never blamed on the generator. The judge fingerprint is recorded so two scorecards
+are only compared when they used the same judge.
+"""
+
+from __future__ import annotations
+
+import datetime as _dt
+import json
+from typing import Any
+
+from .llm import LLM
+from .metrics import RETRIEVAL_METRICS, Matcher, lexical_matcher, retrieval_metrics
+
+JUDGE_DIMENSIONS = ["groundedness", "correctness", "completeness", "citation_quality"]
+
+JUDGE_SYS = (
+    "You are a strict, consistent evaluator of RAG answers. "
+    "Score each dimension from 0.0 to 1.0. Be calibrated: 1.0 means flawless, "
+    "0.5 means partially right, 0.0 means absent or wrong. Output JSON only."
+)
+
+JUDGE_TMPL = '''Question: {q}
+
+Reference (gold) answer: {gold}
+
+Context the system retrieved:
+"""{ctx}"""
+
+System's answer: {ans}
+
+Score 0.0-1.0:
+- groundedness: is the answer supported by the retrieved context (no hallucination)?
+- correctness: do its facts match the reference answer?
+- completeness: does it cover what the reference covers?
+- citation_quality: are claims attributable to the retrieved context?
+
+Return JSON:
+{{"groundedness": 0.0, "correctness": 0.0, "completeness": 0.0, "citation_quality": 0.0, "rationale": "one short sentence"}}'''
+
+
+def evaluate(
+    goldenset: list[dict],
+    predictions: list[dict],
+    llm: LLM | None = None,
+    k: int = 5,
+    matcher: Matcher | None = None,
+) -> dict:
+    """Join goldenset to predictions by id, judge each, aggregate.
+
+    `k` is the cutoff for retrieval metrics. `matcher` decides chunk relevance
+    (defaults to lexical token-overlap; pass `embedding_matcher()` for semantic).
+    """
+    llm = llm or LLM()
+    matcher = matcher or lexical_matcher()
+    preds = {p["id"]: p for p in predictions}
+
+    records: list[dict] = []
+    for g in goldenset:
+        pred = preds.get(g["id"])
+        if pred is None:
+            continue
+        retrieved = pred.get("retrieved_contexts", []) or []
+        answer = pred.get("answer", "")
+        gold_contexts = g.get("gold_contexts", []) or []
+
+        scores = _judge_one(llm, g, answer, retrieved)
+        # Unanswerable cases have no gold context to retrieve — skip retrieval scoring.
+        retrieval = (
+            retrieval_metrics(gold_contexts, retrieved, k, matcher) if gold_contexts else None
+        )
+
+        records.append(
+            {
+                "id": g["id"],
+                "question": g["question"],
+                "difficulty": g.get("difficulty", "single_doc"),
+                "answer": answer,
+                "scores": scores,
+                "retrieval": retrieval,
+                "rationale": scores.pop("rationale", ""),
+            }
+        )
+
+    return {
+        "judge_fingerprint": llm.fingerprint,
+        "created": _dt.datetime.now(_dt.UTC).isoformat(timespec="seconds"),
+        "k": k,
+        "n": len(records),
+        "aggregate": _aggregate(records),
+        "records": records,
+    }
+
+
+def _judge_one(llm: LLM, gold: dict, answer: str, retrieved: list[str]) -> dict:
+    ctx = "\n\n---\n\n".join(retrieved) if retrieved else "(no context retrieved)"
+    prompt = JUDGE_TMPL.format(
+        q=gold["question"],
+        gold=gold.get("gold_answer", ""),
+        ctx=ctx[:4000],
+        ans=answer or "(no answer)",
+    )
+    try:
+        out = llm.complete_json(JUDGE_SYS, prompt)
+    except Exception as e:  # noqa: BLE001 - record the failure, keep going
+        return {d: 0.0 for d in JUDGE_DIMENSIONS} | {"rationale": f"judge error: {e}"}
+    result: dict[str, Any] = {d: _clamp(out.get(d, 0.0)) for d in JUDGE_DIMENSIONS}
+    result["rationale"] = str(out.get("rationale", ""))[:300]
+    return result
+
+
+def _clamp(v) -> float:
+    try:
+        return round(max(0.0, min(1.0, float(v))), 3)
+    except (TypeError, ValueError):
+        return 0.0
+
+
+def _mean(values: list[float]) -> float:
+    return round(sum(values) / len(values), 3) if values else 0.0
+
+
+def _aggregate(records: list[dict]) -> dict:
+    agg = {d: _mean([r["scores"][d] for r in records]) for d in JUDGE_DIMENSIONS}
+    scored = [r["retrieval"] for r in records if r.get("retrieval")]
+    for m in RETRIEVAL_METRICS:
+        agg[m] = _mean([r[m] for r in scored])
+    return agg
+
+
+def write_results(results: dict, path: str) -> None:
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(results, f, indent=2, ensure_ascii=False)
+
+
+def read_results(path: str) -> dict:
+    with open(path, encoding="utf-8") as f:
+        return json.load(f)

proofrag/llm.py

@@ -0,0 +1,117 @@
+"""Provider-agnostic LLM client.
+
+Auto-detects Anthropic or OpenAI-compatible (incl. local/Ollama via OPENAI_BASE_URL).
+Defaults to a cheap model so generating a golden set + judging doesn't cost much.
+The judge model is pinned and surfaced as a `fingerprint` so scores stay comparable.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from typing import Any
+
+# Cheap-by-default. Override with PROOFRAG_MODEL.
+DEFAULT_ANTHROPIC_MODEL = "claude-haiku-4-5-20251001"
+DEFAULT_OPENAI_MODEL = "gpt-4o-mini"
+
+
+class LLMError(RuntimeError):
+    """Raised when the LLM backend is misconfigured or unavailable."""
+
+
+class LLM:
+    """Thin wrapper over Anthropic / OpenAI-compatible chat completions."""
+
+    def __init__(self, provider: str | None = None, model: str | None = None):
+        self.provider = provider or os.environ.get("PROOFRAG_PROVIDER") or self._autodetect()
+        self.model = model or os.environ.get("PROOFRAG_MODEL") or self._default_model()
+        self._client: Any = None  # one of several backend SDK clients, set lazily
+
+    @staticmethod
+    def _autodetect() -> str:
+        if os.environ.get("ANTHROPIC_API_KEY"):
+            return "anthropic"
+        if os.environ.get("OPENAI_API_KEY"):
+            return "openai"
+        raise LLMError(
+            "No LLM credentials found. Set ANTHROPIC_API_KEY or OPENAI_API_KEY "
+            "(or run `proofrag demo` to see a scorecard with no API key)."
+        )
+
+    def _default_model(self) -> str:
+        return DEFAULT_ANTHROPIC_MODEL if self.provider == "anthropic" else DEFAULT_OPENAI_MODEL
+
+    @property
+    def fingerprint(self) -> str:
+        """Stable id of the judge backend, recorded in every scorecard."""
+        return f"{self.provider}:{self.model}"
+
+    def complete_json(self, system: str, prompt: str) -> dict[str, Any]:
+        """Complete and parse the first JSON object out of the response."""
+        return _extract_json(self._complete(system, prompt))
+
+    # -- backends ---------------------------------------------------------
+
+    def _complete(self, system: str, prompt: str) -> str:
+        if self.provider == "anthropic":
+            return self._anthropic(system, prompt)
+        if self.provider == "openai":
+            return self._openai(system, prompt)
+        raise LLMError(f"Unknown provider: {self.provider!r}")
+
+    def _anthropic(self, system: str, prompt: str) -> str:
+        try:
+            import anthropic
+        except ImportError as e:
+            raise LLMError("Anthropic backend needs: pip install 'proofrag[anthropic]'") from e
+        if self._client is None:
+            self._client = anthropic.Anthropic()
+        msg = self._client.messages.create(
+            model=self.model,
+            max_tokens=2048,
+            system=system,
+            messages=[{"role": "user", "content": prompt}],
+        )
+        return "".join(
+            getattr(b, "text", "") for b in msg.content if getattr(b, "type", "") == "text"
+        )
+
+    def _openai(self, system: str, prompt: str) -> str:
+        try:
+            import openai
+        except ImportError as e:
+            raise LLMError("OpenAI backend needs: pip install 'proofrag[openai]'") from e
+        if self._client is None:
+            base = os.environ.get("OPENAI_BASE_URL")
+            self._client = openai.OpenAI(base_url=base) if base else openai.OpenAI()
+        resp = self._client.chat.completions.create(
+            model=self.model,
+            temperature=0,
+            messages=[
+                {"role": "system", "content": system},
+                {"role": "user", "content": prompt},
+            ],
+        )
+        return resp.choices[0].message.content or ""
+
+
+def _extract_json(text: str) -> dict:
+    """Pull the first JSON object out of a model response (handles code fences)."""
+    text = text.strip()
+    fence = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, re.DOTALL)
+    if fence:
+        text = fence.group(1)
+    start = text.find("{")
+    if start == -1:
+        raise LLMError(f"No JSON object in response: {text[:200]!r}")
+    depth = 0
+    for i in range(start, len(text)):
+        if text[i] == "{":
+            depth += 1
+        elif text[i] == "}":
+            depth -= 1
+            if depth == 0:
+                return json.loads(text[start : i + 1])
+    raise LLMError(f"Unbalanced JSON in response: {text[:200]!r}")

proofrag/metrics.py

@@ -0,0 +1,106 @@
+"""Rank-aware retrieval metrics (Recall@k, Precision@k, NDCG@k, MRR).
+
+These separate retriever failures from generator failures: if NDCG@k is low, the
+right context never reached the model in a usable rank, so a bad answer isn't the
+LLM's fault.
+
+Relevance is decided by a pluggable *matcher* `(gold_context, retrieved_chunk) ->
+bool`. The default is token-overlap (Jaccard) — dependency-free, runs anywhere.
+Swap in `embedding_matcher()` (see embeddings.py) for semantic matching without
+touching the metric code.
+"""
+
+from __future__ import annotations
+
+import math
+import re
+from collections.abc import Callable
+
+_WORD = re.compile(r"[a-z0-9]+")
+
+Matcher = Callable[[str, str], bool]
+RETRIEVAL_METRICS = ["recall_at_k", "precision_at_k", "ndcg_at_k", "mrr"]
+
+
+def _tokens(text: str) -> set[str]:
+    return set(_WORD.findall(text.lower()))
+
+
+def _jaccard(a: str, b: str) -> float:
+    ta, tb = _tokens(a), _tokens(b)
+    if not ta or not tb:
+        return 0.0
+    return len(ta & tb) / len(ta | tb)
+
+
+def lexical_matcher(threshold: float = 0.4) -> Matcher:
+    """Default matcher: relevant if token-overlap (Jaccard) >= threshold."""
+    return lambda gold, chunk: _jaccard(gold, chunk) >= threshold
+
+
+def _relevance(gold_contexts: list[str], chunk: str, matcher: Matcher) -> bool:
+    return any(matcher(g, chunk) for g in gold_contexts)
+
+
+def recall_at_k(gold_contexts, retrieved, k, matcher) -> float:
+    """Fraction of gold contexts found among the top-k retrieved."""
+    if not gold_contexts:
+        return 1.0  # nothing to retrieve (e.g. an unanswerable case)
+    topk = retrieved[:k]
+    hits = sum(1 for g in gold_contexts if any(matcher(g, c) for c in topk))
+    return hits / len(gold_contexts)
+
+
+def precision_at_k(gold_contexts, retrieved, k, matcher) -> float:
+    """Fraction of the top-k retrieved that are relevant."""
+    topk = retrieved[:k]
+    if not topk:
+        return 0.0
+    rel = sum(1 for c in topk if _relevance(gold_contexts, c, matcher))
+    return rel / len(topk)
+
+
+def ndcg_at_k(gold_contexts, retrieved, k, matcher) -> float:
+    """Normalized DCG@k with binary relevance — rewards relevant chunks ranked high."""
+    rels = [1.0 if _relevance(gold_contexts, c, matcher) else 0.0 for c in retrieved[:k]]
+    dcg = sum(r / math.log2(i + 2) for i, r in enumerate(rels))
+    idcg = sum(r / math.log2(i + 2) for i, r in enumerate(sorted(rels, reverse=True)))
+    return dcg / idcg if idcg > 0 else 0.0
+
+
+def mrr(gold_contexts, retrieved, matcher) -> float:
+    """Reciprocal rank of the first relevant chunk (0 if none)."""
+    for i, c in enumerate(retrieved):
+        if _relevance(gold_contexts, c, matcher):
+            return 1.0 / (i + 1)
+    return 0.0
+
+
+def retrieval_metrics(
+    gold_contexts: list[str],
+    retrieved: list[str],
+    k: int = 5,
+    matcher: Matcher | None = None,
+) -> dict:
+    """All retrieval metrics for one (gold_contexts, retrieved) pair."""
+    matcher = matcher or lexical_matcher()
+    return {
+        "recall_at_k": round(recall_at_k(gold_contexts, retrieved, k, matcher), 3),
+        "precision_at_k": round(precision_at_k(gold_contexts, retrieved, k, matcher), 3),
+        "ndcg_at_k": round(ndcg_at_k(gold_contexts, retrieved, k, matcher), 3),
+        "mrr": round(mrr(gold_contexts, retrieved, matcher), 3),
+    }
+
+
+# --- back-compat -------------------------------------------------------------
+
+
+def context_matches(gold: str, retrieved: list[str], threshold: float = 0.4) -> bool:
+    """True if any retrieved context matches the gold context above threshold."""
+    m = lexical_matcher(threshold)
+    return any(m(gold, r) for r in retrieved)
+
+
+def retrieval_recall(gold_contexts, retrieved, threshold: float = 0.4) -> float:
+    """Recall over all retrieved (k = len). Kept for back-compat."""
+    return recall_at_k(gold_contexts, retrieved, len(retrieved) or 1, lexical_matcher(threshold))

proofrag/scorecard.py

@@ -0,0 +1,218 @@
+"""Render a results dict into a self-contained, shareable HTML scorecard.
+
+Zero external assets — inline CSS, no JS, no fonts fetched. Open the file
+anywhere, attach it to a PR, drop it in CI artifacts. This is the artifact
+people screenshot, so it is built to look good.
+"""
+
+from __future__ import annotations
+
+import html
+
+from .judge import JUDGE_DIMENSIONS
+from .metrics import RETRIEVAL_METRICS
+
+_GEN_LABELS = {
+    "groundedness": "Groundedness",
+    "correctness": "Correctness",
+    "completeness": "Completeness",
+    "citation_quality": "Citation Quality",
+}
+
+
+def _ret_labels(k: int) -> dict:
+    return {
+        "recall_at_k": f"Recall@{k}",
+        "precision_at_k": f"Precision@{k}",
+        "ndcg_at_k": f"NDCG@{k}",
+        "mrr": "MRR",
+    }
+
+
+def _grade(v: float) -> str:
+    if v >= 0.85:
+        return "good"
+    if v >= 0.65:
+        return "ok"
+    return "bad"
+
+
+def _bar(label: str, value: float) -> str:
+    pct = round(value * 100)
+    return f"""
+      <div class="metric">
+        <div class="metric-head"><span>{html.escape(label)}</span><b>{pct}</b></div>
+        <div class="track"><div class="fill {_grade(value)}" style="width:{pct}%"></div></div>
+      </div>"""
+
+
+def _card(label: str, value: float) -> str:
+    pct = round(value * 100)
+    return f"""
+      <div class="card {_grade(value)}">
+        <div class="card-val">{pct}</div>
+        <div class="card-label">{html.escape(label)}</div>
+      </div>"""
+
+
+def _gen_mean(r: dict) -> float:
+    s = r["scores"]
+    return sum(s[d] for d in JUDGE_DIMENSIONS) / len(JUDGE_DIMENSIONS)
+
+
+def _num_cell(value) -> str:
+    if value is None:
+        return '<td class="num mut">—</td>'
+    return f'<td class="num {_grade(value)}">{round(value * 100)}</td>'
+
+
+def render(results: dict) -> str:
+    agg = results.get("aggregate", {})
+    records = results.get("records", [])
+    k = results.get("k", 5)
+    ret_labels = _ret_labels(k)
+
+    overall = (
+        round(sum(agg.get(d, 0.0) for d in JUDGE_DIMENSIONS) / len(JUDGE_DIMENSIONS) * 100)
+        if records
+        else 0
+    )
+    # Headline cards: 4 generation dims + NDCG@k as the single best retrieval signal.
+    cards = "".join(_card(_GEN_LABELS[d], agg.get(d, 0.0)) for d in JUDGE_DIMENSIONS)
+    cards += _card(ret_labels["ndcg_at_k"], agg.get("ndcg_at_k", 0.0))
+
+    gen_bars = "".join(_bar(_GEN_LABELS[d], agg.get(d, 0.0)) for d in JUDGE_DIMENSIONS)
+    ret_bars = "".join(_bar(ret_labels[m], agg.get(m, 0.0)) for m in RETRIEVAL_METRICS)
+
+    rows = []
+    for r in sorted(records, key=_gen_mean)[:8]:
+        s = r["scores"]
+        cells = "".join(_num_cell(s[d]) for d in JUDGE_DIMENSIONS)
+        ndcg = r["retrieval"]["ndcg_at_k"] if r.get("retrieval") else None
+        rows.append(
+            f"<tr><td class='q'>{html.escape(r['question'])}"
+            f"<div class='why'>{html.escape(r.get('rationale', ''))}</div></td>"
+            f"<td><span class='tag'>{html.escape(r.get('difficulty', ''))}</span></td>"
+            f"{cells}{_num_cell(ndcg)}</tr>"
+        )
+    failing = "".join(rows) or "<tr><td colspan='7'>No records.</td></tr>"
+
+    return _TEMPLATE.format(
+        overall=overall,
+        overall_grade=_grade(overall / 100) if records else "bad",
+        n=results.get("n", 0),
+        judge=html.escape(results.get("judge_fingerprint", "unknown")),
+        created=html.escape(results.get("created", "")),
+        ndcg_head=html.escape(ret_labels["ndcg_at_k"]),
+        cards=cards,
+        gen_bars=gen_bars,
+        ret_bars=ret_bars,
+        failing=failing,
+    )
+
+
+def write_html(results: dict, path: str) -> None:
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(render(results))
+
+
+_TEMPLATE = """<!doctype html>
+<html lang="en"><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>RAG Eval Scorecard</title>
+<style>
+  :root {{
+    --bg:#0b0e14; --panel:#141925; --line:#222b3a; --ink:#e6edf3; --mut:#8b98ad;
+    --good:#3fb950; --ok:#d29922; --bad:#f85149;
+  }}
+  * {{ box-sizing:border-box; }}
+  body {{ margin:0; background:var(--bg); color:var(--ink);
+    font:15px/1.5 -apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Helvetica,Arial,sans-serif; }}
+  .wrap {{ max-width:980px; margin:0 auto; padding:40px 24px 64px; }}
+  header {{ display:flex; align-items:center; justify-content:space-between; flex-wrap:wrap; gap:16px;
+    border-bottom:1px solid var(--line); padding-bottom:24px; margin-bottom:28px; }}
+  h1 {{ margin:0; font-size:22px; letter-spacing:.2px; }}
+  h1 .kit {{ color:var(--mut); font-weight:500; }}
+  .meta {{ color:var(--mut); font-size:13px; text-align:right; }}
+  .meta code {{ color:var(--ink); background:var(--panel); padding:2px 6px; border-radius:5px; }}
+  .hero {{ display:flex; align-items:center; gap:24px; background:var(--panel);
+    border:1px solid var(--line); border-radius:14px; padding:24px 28px; margin-bottom:24px; }}
+  .ring {{ font-size:54px; font-weight:700; line-height:1; }}
+  .ring.good {{ color:var(--good); }} .ring.ok {{ color:var(--ok); }} .ring.bad {{ color:var(--bad); }}
+  .hero .sub {{ color:var(--mut); }}
+  .cards {{ display:grid; grid-template-columns:repeat(5,1fr); gap:12px; margin-bottom:24px; }}
+  .card {{ background:var(--panel); border:1px solid var(--line); border-radius:12px;
+    padding:16px; text-align:center; }}
+  .card-val {{ font-size:30px; font-weight:700; }}
+  .card-label {{ color:var(--mut); font-size:12px; margin-top:4px; }}
+  .card.good .card-val {{ color:var(--good); }} .card.ok .card-val {{ color:var(--ok); }}
+  .card.bad .card-val {{ color:var(--bad); }}
+  .grid2 {{ display:grid; grid-template-columns:1fr 1fr; gap:16px; margin-bottom:24px; }}
+  .panel {{ background:var(--panel); border:1px solid var(--line); border-radius:14px;
+    padding:24px 28px; }}
+  .panel.full {{ margin-bottom:24px; }}
+  h2 {{ font-size:14px; text-transform:uppercase; letter-spacing:.8px; color:var(--mut);
+    margin:0 0 18px; }}
+  h2 small {{ text-transform:none; letter-spacing:0; font-weight:400; }}
+  .metric {{ margin-bottom:14px; }}
+  .metric:last-child {{ margin-bottom:0; }}
+  .metric-head {{ display:flex; justify-content:space-between; font-size:13px; margin-bottom:5px; }}
+  .track {{ height:8px; background:#0b0e14; border-radius:6px; overflow:hidden; }}
+  .fill {{ height:100%; border-radius:6px; }}
+  .fill.good {{ background:var(--good); }} .fill.ok {{ background:var(--ok); }}
+  .fill.bad {{ background:var(--bad); }}
+  table {{ width:100%; border-collapse:collapse; font-size:13px; }}
+  th {{ text-align:right; color:var(--mut); font-weight:600; padding:8px 10px;
+    border-bottom:1px solid var(--line); }}
+  th:first-child {{ text-align:left; }}
+  td {{ padding:11px 10px; border-bottom:1px solid var(--line); vertical-align:top; }}
+  td.q {{ max-width:380px; }}
+  .why {{ color:var(--mut); font-size:12px; margin-top:4px; }}
+  td.num {{ text-align:right; font-variant-numeric:tabular-nums; font-weight:600; }}
+  td.num.good {{ color:var(--good); }} td.num.ok {{ color:var(--ok); }} td.num.bad {{ color:var(--bad); }}
+  td.num.mut {{ color:var(--mut); }}
+  .tag {{ background:#0b0e14; border:1px solid var(--line); color:var(--mut);
+    font-size:11px; padding:2px 7px; border-radius:999px; white-space:nowrap; }}
+  footer {{ color:var(--mut); font-size:12px; text-align:center; margin-top:32px; }}
+  footer a {{ color:var(--mut); }}
+  @media (max-width:720px) {{ .cards {{ grid-template-columns:repeat(2,1fr); }} .grid2 {{ grid-template-columns:1fr; }} }}
+</style></head>
+<body><div class="wrap">
+  <header>
+    <h1>RAG Eval Scorecard <span class="kit">· proofrag</span></h1>
+    <div class="meta">judge <code>{judge}</code><br>{created} · {n} cases</div>
+  </header>
+
+  <div class="hero">
+    <div class="ring {overall_grade}">{overall}</div>
+    <div>
+      <div style="font-size:18px;font-weight:600;">Overall generation quality</div>
+      <div class="sub">Mean of groundedness, correctness, completeness & citation quality across {n} cases.</div>
+    </div>
+  </div>
+
+  <div class="cards">{cards}</div>
+
+  <div class="grid2">
+    <div class="panel">
+      <h2>Generation <small>— LLM-as-judge</small></h2>
+      {gen_bars}
+    </div>
+    <div class="panel">
+      <h2>Retrieval <small>— rank-aware</small></h2>
+      {ret_bars}
+    </div>
+  </div>
+
+  <div class="panel full">
+    <h2>Weakest cases</h2>
+    <table>
+      <thead><tr>
+        <th>Question</th><th>Tier</th><th>Grnd</th><th>Corr</th><th>Comp</th><th>Cite</th><th>{ndcg_head}</th>
+      </tr></thead>
+      <tbody>{failing}</tbody>
+    </table>
+  </div>
+
+  <footer>Generated by <a href="https://github.com/unshDee/proofrag">proofrag</a> — point your agent at your docs, get a golden set + scorecard in one command.</footer>
+</div></body></html>"""