compass-kb-validation 2.8.0__tar.gz → 2.9.0__tar.gz

{compass_kb_validation-2.8.0 → compass_kb_validation-2.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compass-kb-validation
-Version: 2.8.0
+Version: 2.9.0
 Summary: Knowledge-base readiness validation for RAG & AI agents — config-driven, deterministic pipeline integrity checks.
 Author: COMPASS
 License: MIT

{compass_kb_validation-2.8.0 → compass_kb_validation-2.9.0}/compass_kb_validation.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compass-kb-validation
-Version: 2.8.0
+Version: 2.9.0
 Summary: Knowledge-base readiness validation for RAG & AI agents — config-driven, deterministic pipeline integrity checks.
 Author: COMPASS
 License: MIT

{compass_kb_validation-2.8.0 → compass_kb_validation-2.9.0}/compass_kb_validation.egg-info/SOURCES.txt

@@ -49,6 +49,7 @@ ingestion_validation/report/__init__.py
 ingestion_validation/report/_report_css.py
 ingestion_validation/report/_report_js.py
 ingestion_validation/report/analysis.py
+ingestion_validation/report/audit.py
 ingestion_validation/report/export.py
 ingestion_validation/report/shell.py
 ingestion_validation/utils/__init__.py

{compass_kb_validation-2.8.0 → compass_kb_validation-2.9.0}/discover_and_validate.py

@@ -33,6 +33,9 @@ def parse_args(argv=None) -> argparse.Namespace:
     p.add_argument("--env", default="dev", help="Environment")
     p.add_argument("--folder", help="Filter to a specific storage subfolder")
     p.add_argument("--limit", type=int, help="Max documents to validate")
+    p.add_argument("--with-evidence", nargs="?", type=int, const=0, default=None, metavar="N",
+                   help="Also run `compass evidence` and embed live proof in each document's modal "
+                        "(extra KB queries). Optional N caps the documents probed (default: config).")
     p.add_argument("--dry-run", action="store_true", help="List documents without validating")
     p.add_argument("--output-format", choices=["html", "json", "junit", "all"], default="html")
     p.add_argument("--include-graphdb", action="store_true", help="Also validate graph metadata")
@@ -550,8 +553,29 @@ def main(argv=None) -> int:
     passed = sum(1 for r in results if r["result"].all_passed)
     failed = len(results) - passed
     base = f"reports/{args.project}-discovery-report"
+
+    # Optional: run `compass evidence` and embed live proof per document (query surface; extra KB
+    # queries). Keyed by document name so the doc modal renders the proof. Never fails the run.
+    evidence_by_doc = None
+    if args.with_evidence is not None:
+        try:
+            from ingestion_validation import evidence as _ev
+            from dataclasses import asdict as _asdict
+            ev_limit = args.with_evidence or settings.evidence.sample_size
+            print(f"\n  Gathering evidence (up to {ev_limit} document(s))...")
+            payload = _ev.gather_evidence(settings, list(_ev.ALL_CHECKS), limit=ev_limit)
+            if payload.get("error"):
+                print(f"    evidence skipped: {payload['error']}")
+            else:
+                evidence_by_doc = {}
+                for r in payload.get("results", []):
+                    evidence_by_doc.setdefault(r.document, []).append(_asdict(r))
+                print(f"    embedded proof for {len(evidence_by_doc)} document(s).")
+        except Exception as exc:  # noqa: BLE001 - evidence must never break the validation run
+            print(f"    evidence skipped: {exc}")
+
     if args.output_format in ("html", "all"):
-        print(f"\n  HTML report: {generate_batch_dashboard(results, base + '.html', project=args.project, environment=args.env, run_id=run_id, trends=trend_rows, corpus=corpus, mode='Discovery', profile=profile_data, wall_seconds=wall_seconds, concurrency=concurrency)}")
+        print(f"\n  HTML report: {generate_batch_dashboard(results, base + '.html', project=args.project, environment=args.env, run_id=run_id, trends=trend_rows, corpus=corpus, mode='Discovery', profile=profile_data, wall_seconds=wall_seconds, concurrency=concurrency, evidence=evidence_by_doc)}")
     if args.output_format in ("json", "all"):
         print(f"  JSON report: {export_json(results, base + '.json')}")
     if args.output_format in ("junit", "all"):

{compass_kb_validation-2.8.0 → compass_kb_validation-2.9.0}/ingestion_validation/__init__.py

@@ -5,4 +5,4 @@ end-to-end: API upload -> object storage -> knowledge graph -> vector store ->
 retrieval quality, plus cross-store consistency.
 """
 
-__version__ = "2.8.0"
+__version__ = "2.9.0"

{compass_kb_validation-2.8.0 → compass_kb_validation-2.9.0}/ingestion_validation/cli.py

@@ -1266,8 +1266,9 @@ def cmd_evidence(argv: list[str]) -> int:
     p.add_argument("--document", "-d", default="", help="Only probe documents whose name contains this.")
     p.add_argument("--limit", "-l", type=int, default=0, help="Max documents to probe (default: config sample_size).")
     p.add_argument("--quick", action="store_true", help="Probe a single document.")
-    p.add_argument("--format", "-f", choices=["markdown", "json"], default="markdown")
-    p.add_argument("--output", "-o", help="Write to a file (default: stdout).")
+    p.add_argument("--format", "-f", choices=["markdown", "json", "html"], default="markdown")
+    p.add_argument("--output", "-o", help="Write to a file (default: stdout for md/json; reports/ for html).")
+    p.add_argument("--open", action="store_true", help="Open the HTML report in a browser.")
     args = p.parse_args(argv)
 
     try:
@@ -1314,14 +1315,23 @@ def cmd_evidence(argv: list[str]) -> int:
         print(f"  {payload['error']}")
         return 1
 
-    body = ev.format_json(payload, args.project or "") if args.format == "json" \
-        else ev.format_markdown(payload, args.project or "")
-    if args.output:
-        Path(args.output).parent.mkdir(parents=True, exist_ok=True)
-        Path(args.output).write_text(body + "\n", encoding="utf-8")
-        print(f"  Wrote {args.output}")
+    if args.format == "html":
+        from ingestion_validation.report.audit import generate_evidence_report
+        out = generate_evidence_report(payload, args.output or f"reports/evidence-{args.project or 'kb'}.html",
+                                       project=args.project or "")
+        print(f"  HTML report: {out}")
+        if args.open:
+            import webbrowser
+            webbrowser.open(Path(out).resolve().as_uri())
     else:
-        print(body)
+        body = ev.format_json(payload, args.project or "") if args.format == "json" \
+            else ev.format_markdown(payload, args.project or "")
+        if args.output:
+            Path(args.output).parent.mkdir(parents=True, exist_ok=True)
+            Path(args.output).write_text(body + "\n", encoding="utf-8")
+            print(f"  Wrote {args.output}")
+        else:
+            print(body)
     counts: dict[str, int] = {}
     for r in payload["results"]:
         counts[r.verdict] = counts.get(r.verdict, 0) + 1
@@ -1469,8 +1479,9 @@ def cmd_grounding_audit(argv: list[str]) -> int:
     g.add_argument("--eval-results", metavar="FILE",
                    help="Batch: JSONL (one object per line) or a JSON array - both accepted. "
                         "`compass ask --format eval` emits a compatible file.")
-    p.add_argument("--format", choices=["markdown", "json"], default="markdown")
-    p.add_argument("--output", help="Write the report to a file (default: stdout).")
+    p.add_argument("--format", choices=["markdown", "json", "html"], default="markdown")
+    p.add_argument("--output", help="Write the report to a file (default: stdout for md/json; reports/ for html).")
+    p.add_argument("--open", action="store_true", help="Open the HTML report in a browser.")
     p.add_argument("--fail-on-fabrication", action="store_true",
                    help="Exit non-zero if any verifiable claim disagrees with the KB.")
     args = p.parse_args(argv)
@@ -1547,18 +1558,26 @@ def cmd_grounding_audit(argv: list[str]) -> int:
     doc_exists = _graph_doc_exists(settings) if getattr(settings.eval, "citation_graph_ask", "") else None
     results = [run_audit(rec, adapter, settings.eval, doc_exists=doc_exists) for rec in records]
 
-    if args.format == "json":
-        from dataclasses import asdict
-        body = _json.dumps([asdict(r) for r in results], indent=2, default=str)
-    else:
-        body = ("\n\n".join(render_report(r, project=args.project or "") for r in results))
-
-    if args.output:
-        Path(args.output).parent.mkdir(parents=True, exist_ok=True)
-        Path(args.output).write_text(body + "\n", encoding="utf-8")
-        print(f"  Wrote {args.output}")
+    if args.format == "html":
+        from ingestion_validation.report.audit import generate_grounding_report
+        out = generate_grounding_report(results, args.output or f"reports/grounding-{args.project or 'kb'}.html",
+                                        project=args.project or "")
+        print(f"  HTML report: {out}")
+        if args.open:
+            import webbrowser
+            webbrowser.open(Path(out).resolve().as_uri())
     else:
-        print(body)
+        if args.format == "json":
+            from dataclasses import asdict
+            body = _json.dumps([asdict(r) for r in results], indent=2, default=str)
+        else:
+            body = ("\n\n".join(render_report(r, project=args.project or "") for r in results))
+        if args.output:
+            Path(args.output).parent.mkdir(parents=True, exist_ok=True)
+            Path(args.output).write_text(body + "\n", encoding="utf-8")
+            print(f"  Wrote {args.output}")
+        else:
+            print(body)
 
     if not results:
         if args.format != "json":

{compass_kb_validation-2.8.0 → compass_kb_validation-2.9.0}/ingestion_validation/report/__init__.py

@@ -112,20 +112,9 @@ li .check-hint{margin:4px 0 0 0;display:block;}
 .metric-chip b{color:var(--ink);font-variant-numeric:tabular-nums;}
 .exec-interp-title{font-size:12px;text-transform:uppercase;letter-spacing:.07em;color:var(--muted);font-weight:700;margin-bottom:6px;}
 .exec-narrative{font-size:13.5px;line-height:1.6;color:var(--ink);margin:0 0 10px;padding:9px 12px;background:var(--chip-bg);border-radius:8px;border-left:3px solid var(--accent);}
-.subsys-rollup{padding:14px 16px 18px;display:flex;flex-direction:column;gap:8px;border-bottom:1px solid var(--line);}
-.subsys-head{font-size:11px;text-transform:uppercase;letter-spacing:.06em;color:var(--muted);font-weight:700;margin-bottom:4px;}
 .rec-list{padding:14px 16px 16px;display:flex;flex-direction:column;gap:10px;}
-.rec-card{border:1px solid var(--line);border-left:3px solid var(--muted);border-radius:8px;padding:10px 14px;background:var(--chip-bg);}
-.rec-card.bad{border-left-color:var(--bad);}.rec-card.warn{border-left-color:var(--warn);}
-.rec-head{display:flex;align-items:center;gap:8px;flex-wrap:wrap;font-size:13px;margin-bottom:4px;}
-.rec-impact{margin-left:auto;font-size:11px;color:var(--muted);font-variant-numeric:tabular-nums;}
 .rec-fix{font-size:12.5px;line-height:1.55;color:var(--ink);}
 .rec-more{font-size:12px;color:var(--muted);padding:4px 2px;}
-.subsys-row{display:grid;grid-template-columns:160px 1fr auto;align-items:center;gap:12px;font-size:12px;}
-.subsys-name{font-weight:700;color:var(--ink);}
-.subsys-bar{height:10px;background:var(--line);border-radius:5px;overflow:hidden;}
-.subsys-bar i{display:block;height:100%;border-radius:5px;}
-.subsys-meta{color:var(--muted);white-space:nowrap;font-variant-numeric:tabular-nums;}
 @media(max-width:600px){.subsys-row{grid-template-columns:1fr;gap:3px;}}
 .exec-bullets{margin:0 0 4px;padding-left:18px;font-size:13.5px;line-height:1.75;color:var(--ink);}
 .exec-bullets li{margin:0;}
@@ -1773,6 +1762,19 @@ function renderDoc(idx){
     html+='<div class="section-title" style="margin-top:24px">Checks by Category</div><div class="table-card"><div class="table-wrap"><table>'+
       '<thead><tr><th>Category</th><th class="num">Total</th><th class="num">Passed</th><th class="num">Failed</th><th class="num">Pass Rate</th><th>Coverage</th></tr></thead><tbody>'+catRows+'</tbody></table></div></div>';
   }
+  // Evidence (present only with `discover --with-evidence`): concrete live proof for THIS doc.
+  var evAll=(typeof REPORT!=='undefined'&&REPORT.evidence)?REPORT.evidence:null;
+  var ev=evAll?(evAll[d.file]||evAll[d.documentId]||null):null;
+  if(ev&&ev.length){
+    var _vc={CONFIRMED:['bad','Confirmed'],WEAK:['warn','Weak'],NOT_REPRODUCED:['ok','Not reproduced'],ERROR:['warn','Error']};
+    var _pre='white-space:pre-wrap;font-family:ui-monospace,Menlo,monospace;font-size:11px;line-height:1.5;color:var(--muted);margin:0;max-height:260px;overflow:auto;';
+    var cards=ev.map(function(r){
+      var vc=_vc[r.verdict]||['warn',r.verdict];
+      var raw=(r.details&&Object.keys(r.details).length)?'<details class="cov-row"><summary class="cov-sum"><span class="cov-name">raw evidence</span></summary><div class="cov-body"><pre style="'+_pre+'">'+_escHtml(JSON.stringify(r.details,null,2))+'</pre></div></details>':'';
+      return '<div class="rca-pattern" style="border-left-color:var(--'+vc[0]+')"><div class="rca-pattern-header"><span class="tag '+vc[0]+'">'+vc[1]+'</span><span class="rca-pattern-title">'+_escHtml((r.check||'').replace(/_/g,' '))+'</span></div><div class="rca-cause">'+_escHtml(r.summary||'')+'</div>'+raw+'</div>';
+    }).join('');
+    html+='<div class="section-title" style="margin-top:24px">Evidence <span class="cat-badge">live proof from the KB</span></div><div class="table-card"><div class="rec-list">'+cards+'</div></div>';
+  }
   box.innerHTML=html;
 }
 // ---- Charts ----
@@ -1832,6 +1834,7 @@ def generate_batch_dashboard(
     embed_detail_cap: int = 200,
     wall_seconds: float | None = None,
     concurrency: int | None = None,
+    evidence: dict | None = None,
 ) -> str:
     """Generate a self-contained, interactive HTML dashboard. Returns abs path.
 
@@ -1915,7 +1918,11 @@ def generate_batch_dashboard(
         if trimmed else ""
     )
 
-    report_json = json.dumps({"agg": agg, "cases": cases}, default=str).replace("</", "<\\/")
+    # Optional live-proof payload (from `discover --with-evidence`), keyed by document name, so
+    # the per-document modal can show the concrete evidence for THIS doc. Purely additive: the
+    # report builder stays a pure function of data - evidence is computed upstream (query surface).
+    report_json = json.dumps({"agg": agg, "cases": cases, "evidence": evidence or {}},
+                             default=str).replace("</", "<\\/")
     trends_html = _trends_section(trends or [])
     trends_pill = '<button class="nav-pill" data-section="section-trends" onclick="navScrollTo(\'section-trends\')">Trends</button>' if trends else ""
     action_plan_html = _action_plan_section(agg)

compass_kb_validation-2.9.0/ingestion_validation/report/audit.py

@@ -0,0 +1,186 @@
+"""Self-contained HTML reports for ``compass evidence`` and ``compass grounding-audit``.
+
+Same chrome as the validation dashboard and the coverage/migration analysis reports (via
+``report.shell.render_page``): header, nav pills, dark/light, theme variables, the shared
+card/tile/badge classes. Read-only PRESENTATION of already-computed, deterministic results -
+no LLM and no pass/fail decision happens here. Values are HTML-escaped through ``esc``.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from ingestion_validation.report.shell import esc, render_page
+
+_PRE = ("white-space:pre-wrap;font-family:ui-monospace,Menlo,monospace;font-size:11.5px;"
+        "line-height:1.5;color:var(--muted);margin:0;max-height:320px;overflow:auto;")
+
+
+def _abspath(path: str) -> str:
+    p = Path(path)
+    p.parent.mkdir(parents=True, exist_ok=True)
+    return str(p.resolve())
+
+
+def _tiles(items: list[tuple[str, object, str]]) -> str:
+    cells = "".join(
+        f'<div class="tile"><div class="label">{esc(label)}</div>'
+        f'<div class="value {cls}">{esc(val)}</div></div>'
+        for label, val, cls in items)
+    return f'<div class="kpi-grid">{cells}</div>'
+
+
+def _error_page(title: str, heading: str, project: str, run_id: str, message: str, path: str) -> str:
+    section = (f'<section class="section" id="section-summary"><div class="section-title">Summary</div>'
+               f'<div class="card"><div class="card-inner"><b>{esc(message)}</b></div></div></section>')
+    html = render_page(title=title, heading=heading, subtitle=project,
+                       meta={"Project": project or "-", "Run": run_id or "-"},
+                       nav=[("section-summary", "Summary")], sections=section)
+    Path(path).write_text(html, encoding="utf-8")
+    return path
+
+
+# --------------------------------------------------------------------------- #
+# compass evidence
+# --------------------------------------------------------------------------- #
+_VERDICT = {"CONFIRMED": ("bad", "Confirmed"), "WEAK": ("warn", "Weak"),
+            "NOT_REPRODUCED": ("ok", "Not reproduced"), "ERROR": ("warn", "Error")}
+
+
+def generate_evidence_report(payload: dict, output_path: str = "reports/evidence-report.html",
+                             project: str = "", run_id: str = "") -> str:
+    """Render `compass evidence` results: per-check proof cards with the raw evidence."""
+    path = _abspath(output_path)
+    if payload.get("error"):
+        return _error_page("COMPASS Evidence", "Evidence", project, run_id,
+                           f"Evidence: {payload['error']}", path)
+    results = payload.get("results", [])
+    counts: dict[str, int] = {}
+    for r in results:
+        counts[r.verdict] = counts.get(r.verdict, 0) + 1
+    tiles = _tiles([
+        ("Documents probed", payload.get("docs_probed", 0), ""),
+        ("Confirmed", counts.get("CONFIRMED", 0), "bad"),
+        ("Weak", counts.get("WEAK", 0), "warn"),
+        ("Not reproduced", counts.get("NOT_REPRODUCED", 0), "ok"),
+        ("Errors", counts.get("ERROR", 0), "warn"),
+    ])
+    summary = (f'<section class="section" id="section-summary"><div class="section-title">Summary</div>'
+               f'{tiles}<div class="muted" style="margin-top:12px">Deterministic proof built from the '
+               "KB's own chunks - no LLM, no live embedding. A CONFIRMED verdict reproduces exactly "
+               'what validation flagged.</div></section>')
+
+    by_check: dict[str, list] = {}
+    for r in results:
+        by_check.setdefault(r.check, []).append(r)
+    nav = [("section-summary", "Summary")]
+    sections = summary
+    for check, items in by_check.items():
+        confirmed = sum(1 for r in items if r.verdict == "CONFIRMED")
+        sid = "section-" + "".join(ch for ch in check if ch.isalnum())
+        label = check.replace("_", " ").title()
+        nav.append((sid, label))
+        cards = ""
+        for r in items:
+            cls, txt = _VERDICT.get(r.verdict, ("warn", r.verdict))
+            details = ""
+            if r.details:
+                details = ('<details class="cov-row"><summary class="cov-sum">'
+                           '<span class="cov-name">raw evidence</span></summary>'
+                           f'<div class="cov-body"><pre style="{_PRE}">'
+                           f'{esc(json.dumps(r.details, indent=2, default=str))}</pre></div></details>')
+            cards += (f'<div class="rca-pattern" style="border-left-color:var(--{cls})">'
+                      '<div class="rca-pattern-header">'
+                      f'<span class="tag {cls}">{esc(txt)}</span>'
+                      f'<span class="rca-pattern-title">{esc(r.document)}</span></div>'
+                      f'<div class="rca-cause">{esc(r.summary)}</div>{details}</div>')
+        sections += (f'<section class="section" id="{sid}"><div class="section-title">{esc(label)} '
+                     f'<span class="cat-badge">{confirmed}/{len(items)} confirmed</span></div>'
+                     f'<div class="table-card"><div class="rec-list">{cards}</div></div></section>')
+
+    html = render_page(
+        title=f"COMPASS Evidence - {project or 'KB'}",
+        heading=f"Evidence - {project or 'KB'}", subtitle=project,
+        meta={"Project": project or "-", "Run": run_id or "-",
+              "Documents probed": payload.get("docs_probed", 0)},
+        nav=nav, sections=sections)
+    Path(path).write_text(html, encoding="utf-8")
+    return path
+
+
+# --------------------------------------------------------------------------- #
+# compass grounding-audit
+# --------------------------------------------------------------------------- #
+_ATTR = {
+    "none": ("ok", "Grounded"),
+    "generation": ("bad", "Generation hallucination"),
+    "fabricated_source": ("bad", "Fabricated source"),
+    "retrieval": ("warn", "Retrieval gap"),
+    "citation_error": ("warn", "Citation error"),
+    "unverifiable": ("", "Unverifiable"),
+    "unknown": ("", "Unattributed"),
+}
+_SEV = {"CRITICAL": "bad", "HIGH": "bad", "MEDIUM": "warn", "LOW": "warn", "INFO": "ok"}
+
+
+def generate_grounding_report(results: list[Any], output_path: str = "reports/grounding-report.html",
+                              project: str = "", run_id: str = "") -> str:
+    """Render `compass grounding-audit` results: per-case verdict + per-claim citation table."""
+    path = _abspath(output_path)
+    if not results:
+        return _error_page("COMPASS Grounding Audit", "Grounding Audit", project, run_id,
+                           "No eval records to report.", path)
+    sound = sum(r.citations.get("summary", {}).get("sound", 0) for r in results)
+    checkable = sum(r.citations.get("summary", {}).get("checkable", 0) for r in results)
+    acc = round(100.0 * sound / checkable, 1) if checkable else None
+    fabr = sum(1 for r in results if r.has_fabrication)
+    tiles = _tiles([
+        ("Cases", len(results), ""),
+        ("Citations grounded", f"{sound}/{checkable}", ""),
+        ("Accuracy", f"{acc}%" if acc is not None else "-", "ok" if (acc or 0) >= 80 else "warn"),
+        ("Cases with fabrication", fabr, "bad" if fabr else "ok"),
+    ])
+    summary = (f'<section class="section" id="section-summary"><div class="section-title">Summary</div>'
+               f'{tiles}<div class="muted" style="margin-top:12px">Deterministic adjudication of the '
+               "eval's claims against the KB - no LLM in any verdict; it does not judge answer "
+               'quality.</div></section>')
+    nav = [("section-summary", "Summary")]
+    sections = summary
+    for i, r in enumerate(results):
+        sid = f"section-case{i}"
+        sev = r.severity()
+        nav.append((sid, (r.test_id or f"case {i + 1}")[:18]))
+        verdicts = r.citation_verdicts
+        if verdicts:
+            rows = "".join(
+                f'<tr><td>{esc((v.claim[:90] + "...") if len(v.claim) > 90 else v.claim)}</td>'
+                f'<td>{esc(v.doc)}</td><td>{esc(v.page or "-")}</td>'
+                f'<td><span class="tag {_ATTR.get(v.attribution, ("", v.attribution))[0]}">'
+                f'{esc(_ATTR.get(v.attribution, ("", v.attribution))[1])}</span></td></tr>'
+                for v in verdicts)
+            table = ('<div class="table-wrap"><table><thead><tr><th>Cited claim</th><th>Source</th>'
+                     f'<th>Page</th><th>Attribution</th></tr></thead><tbody>{rows}</tbody></table></div>')
+        else:
+            table = '<div class="muted">No citations in this answer.</div>'
+        signals = "".join(
+            f'<li><span class="tag {_SEV.get(s.get("severity", "INFO"), "warn")}">{esc(s.get("severity", ""))}'
+            f'</span> {esc(s.get("label", ""))} <span class="check-detail">{esc(s.get("detail", ""))}</span></li>'
+            for s in (r.signals or []))
+        signals_html = f'<ul>{signals}</ul>' if signals else ""
+        sections += (
+            f'<section class="section" id="{sid}"><div class="section-title">'
+            f'{esc(r.test_id or f"Case {i + 1}")} <span class="tag {_SEV.get(sev, "warn")}">{esc(sev)}</span></div>'
+            '<div class="card"><div class="card-inner">'
+            f'<div class="muted" style="margin-bottom:8px">Q: {esc(r.query)}</div>'
+            f'<div class="rca-cause"><b>Verdict:</b> {esc(r.layer_diagnosis())}</div>'
+            f'{signals_html}{table}</div></div></section>')
+
+    html = render_page(
+        title=f"COMPASS Grounding Audit - {project or 'KB'}",
+        heading=f"Grounding Audit - {project or 'KB'}", subtitle=project,
+        meta={"Project": project or "-", "Run": run_id or "-", "Cases": len(results)},
+        nav=nav, sections=sections)
+    Path(path).write_text(html, encoding="utf-8")
+    return path

{compass_kb_validation-2.8.0 → compass_kb_validation-2.9.0}/tests/test_citation.py

@@ -425,6 +425,17 @@ def test_nonstring_answer_field_is_not_stringified():
     assert "{" not in r.query
 
 
+def test_grounding_html_report_renders(tmp_path):
+    from ingestion_validation.report.audit import generate_grounding_report
+    rec = {"input": "Earnings?", "output": "Earnings rose 40% (MIS, May 2026, p. 1).",
+           "context.retrieved": "c", "scores": {}}
+    results = [run_audit(rec, _kb(), _cfg(gt_response_path="response"))]
+    out = generate_grounding_report(results, str(tmp_path / "gr.html"), project="wp")
+    html = open(out, encoding="utf-8").read()
+    assert "Grounding Audit" in html
+    assert "Generation hallucination" in html and "HIGH" in html   # per-claim attribution + severity
+
+
 def test_report_renders_citation_section():
     rec = {"input": "Earnings?", "response": "Earnings rose 40% (MIS, May 2026, p. 1).",
            "context.retrieved": "c", "scores": {}}

{compass_kb_validation-2.8.0 → compass_kb_validation-2.9.0}/tests/test_evidence.py

@@ -165,3 +165,14 @@ def test_probe_reproduces_validator_via_shared_text_probes():
     from ingestion_validation import text_probes
     from ingestion_validation.validators import retrieval_quality
     assert retrieval_quality._shared_paraphrases is text_probes.paraphrases
+
+
+def test_evidence_html_report_renders_and_escapes(tmp_path):
+    from ingestion_validation.report.audit import generate_evidence_report
+    payload = {"docs_probed": 1, "results": [
+        ev.EvidenceResult("duplicate_chunks", "<img onerror=x>.pdf", "CONFIRMED",
+                          "1 exact-duplicate pair", {"pairs": []})]}
+    out = generate_evidence_report(payload, str(tmp_path / "ev.html"), project="wp")
+    html = open(out, encoding="utf-8").read()
+    assert "COMPASS Evidence" in html and "Confirmed" in html
+    assert "<img onerror=x>" not in html and "&lt;img" in html    # untrusted doc name escaped

{compass_kb_validation-2.8.0 → compass_kb_validation-2.9.0}/tests/test_reporting.py

@@ -709,3 +709,41 @@ def test_chunk_previews_kept_per_document_not_blanket_at_scale():
     by = {c["name"]: c for c in payload["cases"]}
     assert by["small"]["chunks"]["items"]          # 2-chunk doc keeps its previews
     assert by["big0"]["chunks"]["items"] == []     # 20-chunk doc is trimmed
+
+
+def _dash_item(name, status):
+    r = PipelineResult(document_id=name, file_name=name)
+    r.add_step(StepResult("Redis Chunks", status, "ok" if status == StepStatus.PASSED else "x",
+                          checks=[{"label": "Chunk boundaries clean", "passed": status == StepStatus.PASSED,
+                                   "severity": "warn"}]))
+    r.finalize()
+    return {"name": name, "result": r}
+
+
+def _embedded_report(html_path):
+    import json as _json
+    import pathlib
+    import re as _re
+    doc = pathlib.Path(html_path).read_text(encoding="utf-8")
+    m = _re.search(r"const REPORT = (\{.*?\});", doc, _re.S)
+    assert m is not None
+    pathlib.Path(html_path).unlink()
+    return _json.loads(m.group(1)), doc
+
+
+def test_evidence_embeds_in_report_keyed_by_document():
+    # `discover --with-evidence` embeds live proof keyed by doc; the modal renders it.
+    items = [_dash_item("Guide.pdf", StepStatus.FAILED)]
+    evidence = {"Guide.pdf": [{"check": "duplicate_chunks", "document": "Guide.pdf",
+                               "verdict": "CONFIRMED", "summary": "1 dup pair", "details": {"n": 1}}]}
+    html = report_mod.generate_batch_dashboard(items, "reports/_t_ev.html", project="p", evidence=evidence)
+    data, doc = _embedded_report(html)
+    assert data["evidence"]["Guide.pdf"][0]["verdict"] == "CONFIRMED"
+    assert "live proof from the KB" in doc                 # the modal evidence section renders
+
+
+def test_report_without_evidence_stays_backward_compatible():
+    items = [_dash_item("Guide.pdf", StepStatus.PASSED)]
+    html = report_mod.generate_batch_dashboard(items, "reports/_t_noev.html", project="p")
+    data, _ = _embedded_report(html)
+    assert data["evidence"] == {}