@@ -0,0 +1,212 @@
+"""Tests for the regression analysis path: task routing + TrustReport integration.
+
+Covers analyze() task detection/routing, regression metric surfacing in the
+report, show() rendering, to_dict() serialization, save() round-trips, and that
+classification-only features are cleanly guarded on a regression report.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from trustlens import analyze
+from trustlens.report import TrustReport
+
+
+@pytest.fixture
+def regression_data():
+    rng = np.random.default_rng(42)
+    n = 200
+    X = rng.normal(size=(n, 3))
+    y_true = X @ np.array([1.5, -2.0, 0.7]) + rng.normal(scale=1.0, size=n)
+    y_pred = y_true + rng.normal(scale=1.0, size=n)
+    return X, y_true, y_pred
+
+
+def test_explicit_regression_routes_and_skips_trust_score(regression_data):
+    X, y_true, y_pred = regression_data
+    rep = analyze(model=None, X=X, y_true=y_true, y_pred=y_pred, task="regression", verbose=False)
+    assert isinstance(rep, TrustReport)
+    assert rep.task_type == "regression"
+    assert rep.trust_score is None  # classification score intentionally absent
+    ed = rep.results["regression"]["error_distribution"]
+    for key in (
+        "mean_absolute_error",
+        "rmse",
+        "median_absolute_error",
+        "p90_absolute_error",
+        "max_error",
+    ):
+        assert key in ed
+    assert rep.metadata["task_type"] == "regression"
+    assert "n_classes" not in rep.metadata
+    assert rep.metadata["n_unique_targets"] == len(np.unique(y_true))
+
+
+def test_auto_detection(regression_data):
+    X, y_true, y_pred = regression_data
+    # Continuous target -> regression.
+    rep = analyze(model=None, X=X, y_true=y_true, y_pred=y_pred, task="auto", verbose=False)
+    assert rep.task_type == "regression"
+    # Integer label target -> classification (not routed to regression).
+    y_cls = (y_true > np.median(y_true)).astype(int)
+    yprob = np.column_stack([1 - y_cls, y_cls]).astype(float)
+    rep_cls = analyze(
+        model=None, X=X, y_true=y_cls, y_pred=y_cls, y_prob=yprob, task="auto", verbose=False
+    )
+    assert rep_cls.task_type == "classification"
+
+
+def test_show_renders_regression(regression_data, capsys):
+    X, y_true, y_pred = regression_data
+    rep = analyze(model=None, X=X, y_true=y_true, y_pred=y_pred, task="regression", verbose=False)
+    rep.show()
+    out = capsys.readouterr().out
+    assert "Regression Reliability Report" in out
+    assert "MAE" in out and "RMSE" in out
+    assert "Task      : regression" in out
+
+
+def test_to_dict_serializes_regression(regression_data):
+    X, y_true, y_pred = regression_data
+    rep = analyze(model=None, X=X, y_true=y_true, y_pred=y_pred, task="regression", verbose=False)
+    d = rep.to_dict()
+    assert d["task_type"] == "regression"
+    assert "regression.error_distribution.rmse" in d
+    assert isinstance(d["regression.error_distribution.rmse"], float)
+    # No classification trust score leaks into a regression dict.
+    assert "trust_score" not in d
+    assert "trust_grade" not in d
+
+
+def test_uncertainty_metrics_populated_when_supplied(regression_data):
+    X, y_true, y_pred = regression_data
+    lo, hi = y_pred - 2.0, y_pred + 2.0
+    variance = np.abs(y_true - y_pred)  # perfectly tracks error
+    rep = analyze(
+        model=None,
+        X=X,
+        y_true=y_true,
+        y_pred=y_pred,
+        task="regression",
+        prediction_intervals=(lo, hi),
+        predicted_variance=variance,
+        confidence_level=0.95,
+        verbose=False,
+    )
+    reg = rep.results["regression"]
+    picp = reg["interval_coverage"]
+    assert "picp" in picp and 0.0 <= picp["picp"] <= 1.0
+    assert picp["target_coverage"] == 0.95
+    corr = reg["error_variance_correlation"]
+    assert corr["verdict"] == "informative"  # variance == error => strong corr
+
+
+def test_uncertainty_metrics_skip_gracefully(regression_data):
+    X, y_true, y_pred = regression_data
+    rep = analyze(model=None, X=X, y_true=y_true, y_pred=y_pred, task="regression", verbose=False)
+    reg = rep.results["regression"]
+    assert reg["interval_coverage"]["status"] == "skipped"
+    assert reg["error_variance_correlation"]["status"] == "skipped"
+
+
+def test_model_predict_path():
+    from sklearn.linear_model import LinearRegression
+
+    rng = np.random.default_rng(0)
+    n = 120
+    X = rng.normal(size=(n, 4))
+    y = X @ np.array([1.0, 0.5, -1.0, 2.0]) + rng.normal(scale=0.5, size=n)
+    model = LinearRegression().fit(X, y)
+    # No y_pred given -> resolved via model.predict.
+    rep = analyze(model=model, X=X, y_true=y, task="regression", verbose=False)
+    assert rep.task_type == "regression"
+    assert rep.results["regression"]["error_distribution"]["n_samples"] == n
+
+
+def test_classification_features_guarded_on_regression(regression_data):
+    X, y_true, y_pred = regression_data
+    rep = analyze(model=None, X=X, y_true=y_true, y_pred=y_pred, task="regression", verbose=False)
+    for call in (
+        lambda: rep.summary_plot(show=False),
+        lambda: rep.plot(),
+        lambda: rep.show_failures(),
+        lambda: rep.deployment_explanation,
+    ):
+        with pytest.raises(NotImplementedError):
+            call()
+
+
+def test_save_roundtrip_regression(regression_data, tmp_path):
+    import json
+
+    X, y_true, y_pred = regression_data
+    rep = analyze(model=None, X=X, y_true=y_true, y_pred=y_pred, task="regression", verbose=False)
+    # JSON
+    jp = rep.save(str(tmp_path / "reg.json"))
+    data = json.loads(jp.read_text(encoding="utf-8"))
+    assert data["task_type"] == "regression"
+    assert "regression" in data["results"]
+    # TXT
+    tp = rep.save(str(tmp_path / "reg.txt"))
+    assert "Regression Reliability Report" in tp.read_text(encoding="utf-8")
+
+
+def test_invalid_task_raises(regression_data):
+    X, y_true, y_pred = regression_data
+    with pytest.raises(ValueError):
+        analyze(model=None, X=X, y_true=y_true, y_pred=y_pred, task="nonsense", verbose=False)
+
+
+def test_multiclass_float_labels_route_to_classification():
+    """A 25-class label set encoded as float must NOT be mistaken for
+    regression — integer-valued floats are class labels at any cardinality."""
+    rng = np.random.default_rng(7)
+    n = 300
+    X = rng.normal(size=(n, 3))
+    y_cls = rng.integers(0, 25, size=n).astype(float)  # 25 integer classes as float
+    assert len(np.unique(y_cls)) > 20
+    yprob = np.full((n, 25), 1 / 25)
+    rep = analyze(
+        model=None, X=X, y_true=y_cls, y_pred=y_cls, y_prob=yprob, task="auto", verbose=False
+    )
+    assert rep.task_type == "classification"
+
+
+def test_singleton_column_predictions_flattened():
+    """`(n, 1)` predictions (valid single-output) flatten rather than crash;
+    a true multi-output shape is rejected with a clear error."""
+    rng = np.random.default_rng(11)
+    n = 150
+    X = rng.normal(size=(n, 2))
+    y_true = (X @ np.array([1.0, -0.5])) + rng.normal(scale=0.3, size=n)
+    y_pred_2d = (y_true + rng.normal(scale=0.3, size=n)).reshape(-1, 1)  # (n, 1)
+    rep = analyze(
+        model=None,
+        X=X,
+        y_true=y_true.reshape(-1, 1),
+        y_pred=y_pred_2d,
+        task="regression",
+        verbose=False,
+    )
+    assert rep.results["regression"]["error_distribution"]["n_samples"] == n
+    # True multi-output is rejected, not silently mis-shaped.
+    with pytest.raises(ValueError):
+        analyze(
+            model=None,
+            X=X,
+            y_true=y_true,
+            y_pred=np.column_stack([y_pred_2d[:, 0], y_pred_2d[:, 0]]),
+            task="regression",
+            verbose=False,
+        )
+
+
+def test_to_dict_includes_regression_metadata(regression_data):
+    X, y_true, y_pred = regression_data
+    rep = analyze(model=None, X=X, y_true=y_true, y_pred=y_pred, task="regression", verbose=False)
+    d = rep.to_dict()
+    assert d["n_samples"] == len(y_true)
+    assert d["model"] == "Manual"
+    assert "timestamp" in d and "trustlens_version" in d
@@ -24,12 +24,41 @@
 import numpy as np
 
 from trustlens.backends.registry import get_resolver
-from trustlens.core.pipeline import _run_analysis_pipeline
+from trustlens.core.pipeline import _run_analysis_pipeline, _run_regression_pipeline
 from trustlens.report import TrustReport
 
 logger = logging.getLogger(__name__)
 
 
+def _detect_task(y_true: np.ndarray, task: str) -> str:
+    """Resolve the analysis task type.
+
+    ``task`` may be ``"classification"`` / ``"regression"`` (explicit, honored
+    as-is) or ``"auto"``. Auto-detection errs toward ``"classification"`` and
+    only returns ``"regression"`` when the target is clearly continuous — a
+    float array that is not integer-valued, or has many distinct values — so a
+    discrete label set is never mis-routed.
+    """
+    if task in ("classification", "regression"):
+        return task
+    if task != "auto":
+        raise ValueError(f"Invalid task {task!r}. Use 'auto', 'classification', or 'regression'.")
+
+    y = np.asarray(y_true)
+    if y.dtype.kind == "f":
+        n_unique = len(np.unique(y))
+        is_integer_valued = bool(np.all(np.isfinite(y))) and bool(np.allclose(y, np.round(y)))
+        # Integer-valued floats are class labels at ANY cardinality (a 25-class
+        # target encoded as float must not be mistaken for regression), and a
+        # small distinct-value set is also label-like. Only clearly-continuous
+        # floats route to regression.
+        if is_integer_valued or n_unique <= 20:
+            return "classification"
+        return "regression"
+    # Non-float dtypes (ints, strings, bools) default to classification.
+    return "classification"
+
+
 def quick_analyze(
     model=None, X=None, y=None, dataset="iris", framework: Optional[str] = None
 ) -> TrustReport:
@@ -107,6 +136,10 @@ def analyze(
     modules: Optional[list[str]] = None,
     plugins: Optional[list[str]] = None,
     class_labels: Optional[np.ndarray] = None,
+    task: str = "auto",
+    prediction_intervals: Optional[tuple[np.ndarray, np.ndarray]] = None,
+    predicted_variance: Optional[np.ndarray] = None,
+    confidence_level: float = 0.95,
     verbose: bool = True,
 ) -> TrustReport:
     """
@@ -143,6 +176,20 @@ def analyze(
       Semantic class labels in the order corresponding to probability columns.
       Useful for raw backends such as ``xgboost.Booster`` that return ordinal
       probability columns without a ``classes_`` attribute.
+    task : str, default='auto'
+      Analysis task: ``'auto'`` (detect from ``y_true``), ``'classification'``,
+      or ``'regression'``. Regression routes through the regression reliability
+      metrics (error distribution, interval coverage, error-variance
+      correlation) instead of the classification modules.
+    prediction_intervals : tuple(np.ndarray, np.ndarray), optional
+      ``(lower, upper)`` per-sample prediction-interval bounds (regression only).
+      Enables Prediction Interval Coverage (PICP); omitted ⇒ that metric is
+      skipped.
+    predicted_variance : np.ndarray, optional
+      Per-sample predicted variance / uncertainty score (regression only).
+      Enables the error-variance correlation metric; omitted ⇒ skipped.
+    confidence_level : float, default=0.95
+      Nominal coverage the supplied ``prediction_intervals`` claim (regression).
     verbose : bool
       Print progress updates. Default True.
 
@@ -184,7 +231,35 @@ def analyze(
     >>> report.show()
     """
     if len(y_true) < 30:
-        logger.warning("Small dataset (n < 30) detected. Calibration metrics may be unreliable.")
+        logger.warning("Small dataset (n < 30) detected. Metrics may be unreliable.")
+
+    # ------------------------------------------------------------------
+    # 0. Route by task. Regression skips the classification backend (which
+    #    resolves class probabilities) and the classification modules.
+    # ------------------------------------------------------------------
+    task_type = _detect_task(y_true, task)
+    if task_type == "regression":
+        if y_pred is None:
+            if model is None or not hasattr(model, "predict"):
+                raise ValueError(
+                    "Regression analysis needs point predictions: pass y_pred=..., "
+                    "or a model that exposes .predict(X)."
+                )
+            y_pred_resolved = np.asarray(model.predict(X))
+        else:
+            y_pred_resolved = np.asarray(y_pred)
+        return _run_regression_pipeline(
+            model=model,
+            X=X,
+            y_true=np.asarray(y_true),
+            y_pred=y_pred_resolved,
+            prediction_intervals=prediction_intervals,
+            predicted_variance=predicted_variance,
+            confidence_level=confidence_level,
+            framework=framework or ("manual" if y_pred is not None else None),
+            backend_metadata={"task_type": "regression"},
+            verbose=verbose,
+        )
 
     # ------------------------------------------------------------------
     # 1. Resolve predictions via Backend Registry