alignmenter 0.0.4__tar.gz → 0.0.8__tar.gz

{alignmenter-0.0.4/src/alignmenter.egg-info → alignmenter-0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alignmenter
-Version: 0.0.4
+Version: 0.0.8
 Summary: Persona-aligned evaluation toolkit for auditing conversational AI authenticity, safety, and stability.
 Author: Alignmenter
 License:                                  Apache License
@@ -241,7 +241,7 @@ Requires-Dist: transformers>=4.30.0; extra == "safety"
 Dynamic: license-file
 
 <p align="center">
-  <img src="../assets/alignmenter-banner.png" alt="Alignmenter" width="800">
+  <img src="https://alignmenter-branding.s3.us-west-2.amazonaws.com/alignmenter-banner.png" alt="Alignmenter" width="800">
 </p>
 
 <p align="center">
@@ -315,6 +315,9 @@ alignmenter run --config configs/run.yaml --no-generate
 
 # View interactive HTML report
 alignmenter report --last
+
+# Sanitize a dataset in-place or to a new file
+alignmenter dataset sanitize datasets/demo_conversations.jsonl --out datasets/demo_sanitized.jsonl
 ```
 
 **Output:**

{alignmenter-0.0.4 → alignmenter-0.0.8}/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="../assets/alignmenter-banner.png" alt="Alignmenter" width="800">
+  <img src="https://alignmenter-branding.s3.us-west-2.amazonaws.com/alignmenter-banner.png" alt="Alignmenter" width="800">
 </p>
 
 <p align="center">
@@ -73,6 +73,9 @@ alignmenter run --config configs/run.yaml --no-generate
 
 # View interactive HTML report
 alignmenter report --last
+
+# Sanitize a dataset in-place or to a new file
+alignmenter dataset sanitize datasets/demo_conversations.jsonl --out datasets/demo_sanitized.jsonl
 ```
 
 **Output:**

{alignmenter-0.0.4 → alignmenter-0.0.8}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alignmenter"
-version = "0.0.4"
+version = "0.0.8"
 description = "Persona-aligned evaluation toolkit for auditing conversational AI authenticity, safety, and stability."
 authors = [{name = "Alignmenter"}]
-readme = {file = "README.md", 'content-type' = "text/markdown"}
+readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.10"
 license = {file = "LICENSE"}
 keywords = ["llm", "evaluation", "alignment", "persona", "safety"]

alignmenter-0.0.8/src/alignmenter/__init__.py

@@ -0,0 +1,30 @@
+"""Alignmenter package scaffold."""
+
+import os
+
+# Hugging Face tokenizers will warn loudly when forked after parallelism is enabled.
+# Default to disabling parallel threads unless the user explicitly overrides it.
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+
+from .config import get_settings
+
+__version__ = "0.0.4"
+__all__ = ["get_settings", "__version__", "app"]
+
+
+class _AppProxy:
+    """Lazily import the Typer app when first accessed."""
+
+    def _resolve(self):
+        from .cli import app as cli_app
+
+        return cli_app
+
+    def __call__(self, *args, **kwargs):
+        return self._resolve()(*args, **kwargs)
+
+    def __getattr__(self, item):
+        return getattr(self._resolve(), item)
+
+
+app = _AppProxy()

{alignmenter-0.0.4 → alignmenter-0.0.8}/src/alignmenter/cli.py

@@ -23,6 +23,7 @@ from alignmenter.providers.classifiers import load_safety_classifier
 from alignmenter.providers.judges import load_judge_provider
 from alignmenter.providers.openai import OpenAICustomGPTProvider
 from alignmenter.run_config import load_run_options
+from alignmenter.scripts.sanitize_dataset import sanitize_dataset_file
 from alignmenter.runner import RunConfig, Runner
 from alignmenter.scorers.authenticity import AuthenticityScorer
 from alignmenter.scorers.safety import SafetyScorer
@@ -570,6 +571,7 @@ def run(
             compare_generate=regenerate,
             progress_callback=primary_cb,
             compare_progress_callback=compare_cb,
+            thresholds=inputs.thresholds,
         )
 
         try:
@@ -578,7 +580,8 @@ def run(
             typer.secho(f"Run failed: {exc}", fg=typer.colors.RED)
             raise typer.Exit(code=1) from exc
 
-    _print_run_summary(run_dir)
+    threshold_eval = getattr(runner, "threshold_results", {})
+    _print_run_summary(run_dir, thresholds=threshold_eval)
     report_path = run_dir / "index.html"
     target = report_path if report_path.exists() else run_dir
     typer.echo(f"Report written to: {_humanize_path(target)}")
@@ -587,6 +590,9 @@ def run(
     else:
         typer.echo(f"Open in browser: alignmenter report --path {_humanize_path(run_dir)}")
 
+    if threshold_eval and any(info.get("status") == "fail" for info in threshold_eval.values()):
+        raise typer.Exit(code=2)
+
 
 @app.command()
 def demo(
@@ -887,15 +893,59 @@ def dataset_lint(
     )
 
 
+@dataset_app.command("sanitize")
+def dataset_sanitize(
+    path: Path = typer.Argument(..., help="Path to input dataset (JSONL)."),
+    out: Optional[Path] = typer.Option(None, "--out", help="Output path (default: <input>_sanitized.jsonl)."),
+    in_place: bool = typer.Option(False, "--in-place", help="Overwrite the input file."),
+    use_hashing: bool = typer.Option(True, help="Use stable hashes for replacements instead of generic placeholders."),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Show sanitization results without writing output."),
+) -> None:
+    input_path = path if path.is_absolute() else (Path.cwd() / path)
+
+    output_override: Optional[Path] = None
+    if out:
+        output_override = out if out.is_absolute() else (Path.cwd() / out)
+
+    try:
+        stats = sanitize_dataset_file(
+            path=input_path,
+            out=output_override,
+            in_place=in_place,
+            use_hashing=use_hashing,
+            dry_run=dry_run,
+        )
+    except FileNotFoundError:
+        raise typer.BadParameter(f"Dataset not found: {input_path}")
+
+    typer.secho("✓ Sanitization complete", fg=typer.colors.GREEN)
+    typer.echo(f"  Records processed: {stats['records']}")
+    typer.echo(f"  Total PII instances: {stats['total_pii']}")
+    for pii_type, count in stats["pii"].items():
+        if count:
+            typer.echo(f"    {pii_type}: {count}")
+
+    output_path = stats["output_path"]
+    if stats["dry_run"]:
+        typer.secho("\n[DRY RUN] Would write to:", fg=typer.colors.YELLOW)
+        typer.echo(f"  {output_path}")
+        if stats["sample"]:
+            typer.echo("\nSample sanitized records (first 3):")
+            for record in stats["sample"]:
+                typer.echo(json.dumps(record, indent=2))
+    else:
+        typer.echo(f"  Output: {output_path}")
+
+
 def _load_env(path: Path) -> dict[str, str]:
     if not path.exists():
         return {}
     entries: dict[str, str] = {}
     for line in path.read_text(encoding="utf-8").splitlines():
         stripped = line.strip()
-        if not stripped or stripped.startswith("#") or "=" not in line:
+        if not stripped or stripped.startswith("#") or "=" not in stripped:
             continue
-        key, value = line.split("=", 1)
+        key, value = stripped.split("=", 1)
         entries[key.strip()] = value.strip()
     return entries
 
@@ -1002,6 +1052,15 @@ def _format_float(value: Optional[float]) -> Optional[str]:
     return (f"{value:.6f}".rstrip("0").rstrip("."))
 
 
+def _safe_float(value: object) -> Optional[float]:
+    try:
+        if value is None or value == "":
+            return None
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
 def _prompt_optional_int(message: str, default: Optional[Any]) -> Optional[int]:
     default_str = "" if default in (None, "") else str(default)
     while True:
@@ -1149,6 +1208,7 @@ class RunInputs:
     judge_budget: Optional[int]
     judge_cost: dict[str, float | int]
     classifier_identifier: str
+    thresholds: dict[str, dict[str, float]]
 
 
 def _prepare_run_inputs(
@@ -1200,6 +1260,22 @@ def _prepare_run_inputs(
         or "auto"
     )
 
+    raw_thresholds = config_options.get("thresholds") or {}
+    thresholds: dict[str, dict[str, float]] = {}
+    if isinstance(raw_thresholds, dict):
+        for scorer, cfg in raw_thresholds.items():
+            if not isinstance(cfg, dict):
+                continue
+            warn = _safe_float(cfg.get("warn") or cfg.get("threshold_warn"))
+            fail = _safe_float(cfg.get("fail") or cfg.get("threshold_fail"))
+            scoped: dict[str, float] = {}
+            if warn is not None:
+                scoped["warn"] = warn
+            if fail is not None:
+                scoped["fail"] = fail
+            if scoped:
+                thresholds[scorer] = scoped
+
     persona_path = _sync_custom_gpt(model_identifier, persona_path)
 
     run_config = RunConfig(
@@ -1226,6 +1302,7 @@ def _prepare_run_inputs(
         judge_budget=resolved_judge_budget,
         judge_cost=judge_cost,
         classifier_identifier=classifier_identifier,
+        thresholds=thresholds,
     )
 
     return inputs, run_config
@@ -1715,17 +1792,21 @@ def _extract_json_block(text: str) -> Optional[str]:
     return block or None
 
 
-def _print_run_summary(run_dir: Path) -> None:
+def _print_run_summary(
+    run_dir: Path, *, thresholds: Optional[dict[str, dict[str, Any]]] = None
+) -> dict[str, dict[str, Any]]:
     run_meta = _safe_read_json(run_dir / "run.json")
     if run_meta:
         turns = run_meta.get("turn_count")
         sessions = run_meta.get("session_count")
         if isinstance(turns, int) and isinstance(sessions, int):
             typer.echo(f"Loading dataset: {turns} turns across {sessions} sessions")
+        if thresholds is None and isinstance(run_meta.get("thresholds"), dict):
+            thresholds = run_meta.get("thresholds")
 
     results = _safe_read_json(run_dir / "results.json")
     if not results:
-        return
+        return thresholds or {}
 
     scorecards_raw = results.get("scorecards")
     scorecards = (
@@ -1750,6 +1831,16 @@ def _print_run_summary(run_dir: Path) -> None:
         ("stability", "Consistency score"),
     ]
 
+    threshold_info = thresholds or {}
+    for card in scorecards:
+        status = card.get("status")
+        if status and card.get("id") not in threshold_info:
+            threshold_info[card.get("id")] = {
+                "status": status,
+                "warn": card.get("warn"),
+                "fail": card.get("fail"),
+            }
+
     for scorer_id, label in headlines:
         value: Optional[float] = None
         card = scorecard_index.get(scorer_id)
@@ -1768,7 +1859,16 @@ def _print_run_summary(run_dir: Path) -> None:
         if value is None:
             continue
 
-        line = f"✓ {label}: {_format_score_value(value)}"
+        info = threshold_info.get(scorer_id, {}) if isinstance(threshold_info, dict) else {}
+        status = info.get("status", "pass")
+        symbol = {"pass": "✓", "warn": "⚠", "fail": "✗"}.get(status, "✓")
+        color = {
+            "pass": typer.colors.GREEN,
+            "warn": typer.colors.YELLOW,
+            "fail": typer.colors.RED,
+        }.get(status, typer.colors.GREEN)
+
+        line = f"{label}: {_format_score_value(value)}"
         if scorer_id == "authenticity" and isinstance(primary_scores, dict):
             metrics = primary_scores.get("authenticity")
             if isinstance(metrics, dict):
@@ -1776,8 +1876,20 @@ def _print_run_summary(run_dir: Path) -> None:
                 high = metrics.get("ci95_high")
                 if isinstance(low, (int, float)) and isinstance(high, (int, float)):
                     line += f" (range: {_format_score_value(low)}-{_format_score_value(high)})"
-
-        typer.echo(line)
+        warn_threshold = info.get("warn")
+        fail_threshold = info.get("fail")
+        if warn_threshold is not None or fail_threshold is not None:
+            details = []
+            if warn_threshold is not None:
+                details.append(f"warn<{warn_threshold}")
+            if fail_threshold is not None:
+                details.append(f"fail<{fail_threshold}")
+            if details:
+                line += f" [{', '.join(details)}]"
+
+        typer.secho(f"{symbol} {line}", fg=color)
+
+    return threshold_info if isinstance(threshold_info, dict) else {}
 
 
 def _humanize_path(path: Path) -> str:

{alignmenter-0.0.4 → alignmenter-0.0.8}/src/alignmenter/reporting/html.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any
+from typing import Any, Optional
 
 
 HTML_TEMPLATE = """<!DOCTYPE html>
@@ -47,6 +47,7 @@ HTML_TEMPLATE = """<!DOCTYPE html>
       .grade-table tbody td:last-child {{ border-right: 1px solid #334155; border-radius: 0 8px 8px 0; }}
       .metric-name {{ font-weight: 600; color: #e2e8f0; font-size: 1.1rem; }}
       .grade-cell {{ text-align: center; }}
+      .threshold-note {{ font-size: 0.75rem; margin-top: 6px; color: #94a3b8; display: block; }}
       .grade-badge {{ display: inline-flex; align-items: center; gap: 8px; padding: 8px 16px; border-radius: 8px; font-weight: 700; font-size: 1.1rem; }}
       .grade-badge.pass {{ background: rgba(74, 222, 128, 0.15); color: #4ade80; border: 2px solid rgba(74, 222, 128, 0.3); }}
       .grade-badge.warn {{ background: rgba(251, 191, 36, 0.15); color: #fbbf24; border: 2px solid rgba(251, 191, 36, 0.3); }}
@@ -118,11 +119,13 @@ HTML_TEMPLATE = """<!DOCTYPE html>
         <button class="export-btn" onclick="downloadCSV(window.scoresDataCSV, 'scores.csv')">Download CSV</button>
       </div>
       {score_tables}
-      {charts_section}
     </section>
+    {scenario_breakdown}
+    {persona_breakdown}
+    {charts_section}
     {reproducibility_section}
     <section>
-      <h2>Turn-Level Explorer</h2>
+      <h2>Turn Explorer</h2>
       {turn_preview}
     </section>
     <script>
@@ -195,7 +198,10 @@ class HTMLReporter:
                     table += safety_details
             score_blocks.append(table)
 
-        turn_preview = _render_turn_preview(sessions)
+        analytics = extras.get("analytics") if isinstance(extras, dict) else None
+
+        scenario_section, persona_section = _render_breakdown_sections(analytics)
+        turn_preview = _render_turn_preview(sessions, analytics)
         calibration_section = _render_calibration_section(primary)
         reproducibility_section = _render_reproducibility_section(summary)
         charts_section = _render_charts(primary)
@@ -212,6 +218,8 @@ class HTMLReporter:
             scorecard_block=scorecard_block,
             score_tables="".join(score_blocks) or "<p>No scores computed.</p>",
             turn_preview=turn_preview,
+            scenario_breakdown=scenario_section,
+            persona_breakdown=persona_section,
             calibration_section=calibration_section,
             reproducibility_section=reproducibility_section,
             charts_section=charts_section,
@@ -371,15 +379,28 @@ def _render_scorecards(scorecards: list[dict], summary: dict[str, Any]) -> str:
         diff_val = card.get("diff")
 
         # Determine grade class
-        grade_class = _get_grade_class(primary_val)
+        status = card.get("status")
+        grade_class = _get_grade_class(primary_val, status)
         letter = _get_grade_letter(primary_val)
 
         row = '<tr>'
         row += f'<td><span class="metric-name">{card.get("label", card.get("id", "Metric").title())}</span></td>'
+        warn_threshold = card.get("warn")
+        fail_threshold = card.get("fail")
+        threshold_note = ""
+        if warn_threshold is not None or fail_threshold is not None:
+            details = []
+            if warn_threshold is not None:
+                details.append(f"Warn &lt; {warn_threshold}")
+            if fail_threshold is not None:
+                details.append(f"Fail &lt; {fail_threshold}")
+            if details:
+                threshold_note = f"<div class='muted threshold-note'>{' | '.join(details)}</div>"
+
         row += f'<td class="grade-cell"><div class="grade-badge {grade_class}">'
         row += f'<span class="grade-letter">{letter}</span>'
         row += f'<span class="grade-score">{_format_scorecard_value(primary_val)}</span>'
-        row += '</div></td>'
+        row += f'</div>{threshold_note}</td>'
 
         if has_compare:
             if compare_val is not None:
@@ -422,8 +443,10 @@ def _render_scorecards(scorecards: list[dict], summary: dict[str, Any]) -> str:
     """
 
 
-def _get_grade_class(score: Any) -> str:
+def _get_grade_class(score: Any, status: Optional[str] = None) -> str:
     """Get CSS class for grade styling."""
+    if status in {"pass", "warn", "fail"}:
+        return status
     if not isinstance(score, (int, float)):
         return ""
     if score >= 0.8:
@@ -456,45 +479,142 @@ def _format_scorecard_value(value: Any) -> str:
     return str(value)
 
 
-def _render_turn_preview(sessions: list) -> str:
+def _render_breakdown_sections(analytics: Any) -> tuple[str, str]:
+    scenarios_html = _render_breakdown_table("Scenario Breakdown", analytics.get("scenarios") if isinstance(analytics, dict) else {})
+    personas_html = _render_breakdown_table("Persona Breakdown", analytics.get("personas") if isinstance(analytics, dict) else {})
+    return scenarios_html, personas_html
+
+
+def _render_breakdown_table(title: str, items: Any) -> str:
+    if not isinstance(items, dict) or not items:
+        return ""
+
     rows = []
-    for session in sessions[:3]:
-        turns = getattr(session, "turns", None)
-        if turns is None and hasattr(session, "get"):
-            turns = session.get("turns", [])
-        if turns is None:
-            turns = []
-        for turn in turns[:4]:
-            text = turn.get("text", "")
-            if len(text) > 160:
-                text = text[:157] + "…"
-            if hasattr(session, "session_id"):
-                session_id = getattr(session, "session_id")
-            elif hasattr(session, "get"):
-                session_id = session.get("session_id", "")
-            else:
-                session_id = ""
-            rows.append(
-                """
-                <tr>
-                  <td><code>{session_id}</code></td>
-                  <td>{role}</td>
-                  <td>{text}</td>
-                </tr>
-                """.format(
-                    session_id=session_id,
-                    role=turn.get("role", ""),
-                    text=text or "<span class='muted'>(empty)</span>",
-                )
+    for name, payload in items.items():
+        if not isinstance(payload, dict):
+            continue
+        scores = payload.get("scores", {}) if isinstance(payload.get("scores"), dict) else {}
+        auth = _breakdown_score(scores, "authenticity", "mean")
+        safety = _breakdown_score(scores, "safety", "score")
+        stability = _breakdown_score(scores, "stability", "stability")
+        risk_candidates = [v for v in (auth, safety, stability) if v is not None]
+        risk = min(risk_candidates) if risk_candidates else None
+        css_class = _get_score_class(risk) if risk is not None else ""
+        rows.append(
+            {
+                "name": name,
+                "sessions": payload.get("sessions", 0),
+                "turns": payload.get("turns", 0),
+                "auth": auth,
+                "safety": safety,
+                "stability": stability,
+                "risk": risk if risk is not None else 1.0,
+                "class": css_class,
+            }
+        )
+
+    rows.sort(key=lambda item: item["risk"])
+
+    body = []
+    for row in rows:
+        body.append(
+            "<tr>"
+            f"<td>{row['name']}</td>"
+            f"<td>{row['sessions']}</td>"
+            f"<td>{row['turns']}</td>"
+            f"<td class='{row['class'] or ''}'>{_format_score_value(row['auth'])}</td>"
+            f"<td class='{row['class'] or ''}'>{_format_score_value(row['safety'])}</td>"
+            f"<td class='{row['class'] or ''}'>{_format_score_value(row['stability'])}</td>"
+            "</tr>"
+        )
+
+    return (
+        f"<section><h2>{title}</h2>"
+        "<table>"
+        "<thead><tr><th>Name</th><th>Sessions</th><th>Turns</th><th>Authenticity</th><th>Safety</th><th>Consistency</th></tr></thead>"
+        f"<tbody>{''.join(body)}</tbody></table></section>"
+    )
+
+
+def _breakdown_score(scores: dict[str, Any], scorer_id: str, metric: str) -> Optional[float]:
+    metrics = scores.get(scorer_id)
+    if isinstance(metrics, dict):
+        value = metrics.get(metric)
+        if isinstance(value, (int, float)):
+            return round(float(value), 3)
+    return None
+
+
+def _render_turn_preview(sessions: list, analytics: Any) -> str:
+    turns: list[dict[str, Any]] = []
+    scenario_scores: dict[str, Optional[float]] = {}
+    if isinstance(analytics, dict):
+        for scenario, payload in (analytics.get("scenarios") or {}).items():
+            if not isinstance(payload, dict):
+                continue
+            scores = payload.get("scores", {}) if isinstance(payload.get("scores"), dict) else {}
+            auth = _breakdown_score(scores, "authenticity", "mean")
+            safety = _breakdown_score(scores, "safety", "score")
+            stability = _breakdown_score(scores, "stability", "stability")
+            candidates = [v for v in (auth, safety, stability) if v is not None]
+            scenario_scores[scenario] = min(candidates) if candidates else None
+
+    for session in sessions:
+        persona = next(iter(session.persona_ids), None) if hasattr(session, "persona_ids") else None
+        for turn in getattr(session, "turns", []) or []:
+            if turn.get("role") != "assistant":
+                continue
+            text = turn.get("text", "") or ""
+            tags = [tag for tag in turn.get("tags", []) if isinstance(tag, str)]
+            scenarios = [tag for tag in tags if tag.startswith("scenario:")]
+            risk_values = [scenario_scores.get(s) for s in scenarios if scenario_scores.get(s) is not None]
+            risk = min(risk_values) if risk_values else None
+            turns.append(
+                {
+                    "session": getattr(session, "session_id", ""),
+                    "persona": turn.get("persona_id") or persona or "—",
+                    "scenarios": ", ".join(scenarios) if scenarios else "—",
+                    "text": text,
+                    "risk": risk if risk is not None else 1.0,
+                }
             )
-    if not rows:
-        return "<p class='muted'>No turn data available.</p>"
+
+    if not turns:
+        return "<p class='muted'>No assistant turns available.</p>"
+
+    turns.sort(key=lambda item: item["risk"])
+    top_turns = turns[:20]
+
+    rows = []
+    for row in top_turns:
+        text = row["text"]
+        if len(text) > 280:
+            text = text[:277] + "…"
+        css_class = _get_score_class(row["risk"])
+        display_text = text if text else "<span class='muted'>(empty)</span>"
+        rows.append(
+            "<tr>"
+            f"<td><code>{row['session']}</code></td>"
+            f"<td>{row['scenarios']}</td>"
+            f"<td>{row['persona']}</td>"
+            f"<td class='{css_class}'>{display_text}</td>"
+            "</tr>"
+        )
+
     return (
-        "<table class='turn-table'><thead><tr><th>Session</th><th>Role</th><th>Text</th></tr></thead>"
+        "<table class='turn-table'><thead><tr><th>Session</th><th>Scenario</th><th>Persona</th><th>Snippet</th></tr></thead>"
         f"<tbody>{''.join(rows)}</tbody></table>"
     )
 
 
+def _format_score_value(value: Optional[float]) -> str:
+    if value is None:
+        return "—"
+    if isinstance(value, (int, float)):
+        return f"{float(value):.3f}"
+    return str(value)
+
+
 def _render_calibration_section(scores: dict[str, Any]) -> str:
     """Render calibration statistics (bootstrap CI, judge agreement, etc.)."""
     items = []

{alignmenter-0.0.4 → alignmenter-0.0.8}/src/alignmenter/run_config.py

@@ -103,4 +103,29 @@ def load_run_options(path: Path) -> dict[str, Any]:
         if report.get("include_raw") is not None:
             options["include_raw"] = bool(report.get("include_raw"))
 
+    thresholds: dict[str, dict[str, float]] = {}
+
+    def _store_threshold(scorer: str, key: str, value: Any) -> None:
+        try:
+            if value is None or value == "":
+                return
+            thresholds.setdefault(scorer, {})[key] = float(value)
+        except (TypeError, ValueError):
+            pass
+
+    if isinstance(data.get("thresholds"), dict):
+        for scorer, config in data["thresholds"].items():
+            if isinstance(config, dict):
+                _store_threshold(scorer, "warn", config.get("warn"))
+                _store_threshold(scorer, "fail", config.get("fail"))
+
+    for scorer in ("authenticity", "safety", "stability"):
+        section = data.get("scorers", {}).get(scorer, {})
+        if isinstance(section, dict):
+            _store_threshold(scorer, "warn", section.get("threshold_warn"))
+            _store_threshold(scorer, "fail", section.get("threshold_fail"))
+
+    if thresholds:
+        options["thresholds"] = thresholds
+
     return options