research-tool-cli 0.1.0__py3-none-any.whl

tests/test_forensics.py

@@ -0,0 +1,305 @@
+"""Tests for forensics anomaly detection."""
+
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+
+import pytest
+
+from core.database import DATA_ROOT, get_connection, init_db
+from core.reporting.forensics import (
+    _find_time_pairs,
+    _is_benford_eligible,
+    _first_digit_dist,
+    _get_numeric_values,
+    _check_impossible_timelines,
+    run_forensics,
+)
+
+
+# ── Helpers ──────────────────────────────────────────────────────────────────
+
+def _make_study(study_id: str, rows: list[dict], col_info: dict | None = None):
+    """Create a study with a raw table and variable metadata."""
+    study_dir = DATA_ROOT / study_id
+    if study_dir.exists():
+        shutil.rmtree(study_dir)
+
+    conn = get_connection(study_id)
+    init_db(conn)
+
+    conn.execute(
+        """INSERT INTO studies (id, name, created_at, data_dir, is_locked, unmasked_at)
+           VALUES (?, ?, ?, ?, ?, ?)""",
+        (study_id, "test", "2026-01-01T00:00:00+00:00", str(study_dir), 2,
+         "2026-07-01T00:00:00+00:00"),
+    )
+
+    # Create raw table
+    if rows:
+        cols = list(rows[0].keys())
+        col_defs = ", ".join(f'"{c}" TEXT' for c in cols)
+        conn.execute(f"""
+            CREATE TABLE IF NOT EXISTS raw_{study_id} (
+                "row_id" INTEGER PRIMARY KEY,
+                {col_defs}
+            )
+        """)
+        col_list = ", ".join(f'"{c}"' for c in cols)
+        for r in rows:
+            placeholders = ", ".join("?" for _ in cols)
+            conn.execute(
+                f"INSERT INTO raw_{study_id} ({col_list}) "
+                f"VALUES ({placeholders})",
+                [str(r[c]) for c in cols],
+            )
+
+    # Variable metadata
+    if col_info:
+        for col_name, info in col_info.items():
+            conn.execute(
+                """INSERT INTO variables (study_id, column_name, role, data_type, is_masked)
+                   VALUES (?, ?, ?, ?, ?)""",
+                (study_id, col_name, info.get("role", "baseline"),
+                 info.get("data_type", "continuous"), info.get("is_masked", 0)),
+            )
+
+    conn.commit()
+    conn.close()
+    return study_dir
+
+
+# ── Tests ────────────────────────────────────────────────────────────────────
+
+class TestImpossibleTimelines:
+    """Tier 1: PFS > OS detection."""
+
+    def test_catches_pfs_exceeds_os(self):
+        """A deliberately broken row where PFS > OS must be flagged."""
+        study_id = "test_forensics_timeline_break"
+        col_info = {
+            "pfs_days": {"role": "outcome", "data_type": "time_to_event"},
+            "os_days": {"role": "outcome", "data_type": "time_to_event"},
+        }
+        rows = [
+            {"pfs_days": "100", "os_days": "500"},
+            {"pfs_days": "600", "os_days": "200"},
+            {"pfs_days": "300", "os_days": "400"},
+        ]
+        _make_study(study_id, rows, col_info)
+
+        conn = get_connection(study_id)
+        lines: list[str] = []
+        _check_impossible_timelines(
+            conn, f"raw_{study_id}", f"raw_masked_{study_id}",
+            col_info, 3, True, lines,
+        )
+        conn.close()
+
+        combined = "\n".join(lines)
+        assert "⚠" in combined, "Should flag PFS > OS"
+        assert "pfs_days=600" in combined or "600" in combined
+        assert "os_days=200" in combined or "200" in combined
+
+        shutil.rmtree(DATA_ROOT / study_id, ignore_errors=True)
+
+    def test_no_false_positive_when_valid(self):
+        """All PFS ≤ OS must not raise flags."""
+        study_id = "test_forensics_timeline_ok"
+        col_info = {
+            "pfs_days": {"role": "outcome", "data_type": "time_to_event"},
+            "os_days": {"role": "outcome", "data_type": "time_to_event"},
+        }
+        rows = [
+            {"pfs_days": "100", "os_days": "500"},
+            {"pfs_days": "200", "os_days": "300"},
+            {"pfs_days": "50", "os_days": "600"},
+        ]
+        _make_study(study_id, rows, col_info)
+
+        conn = get_connection(study_id)
+        lines: list[str] = []
+        _check_impossible_timelines(
+            conn, f"raw_{study_id}", f"raw_masked_{study_id}",
+            col_info, 3, True, lines,
+        )
+        conn.close()
+
+        combined = "\n".join(lines)
+        assert "✓" in combined
+        assert "⚠" not in combined
+
+        shutil.rmtree(DATA_ROOT / study_id, ignore_errors=True)
+
+    def test_no_time_pair_returns_early(self):
+        """No time_to_event columns must produce a clean skip."""
+        col_info = {
+            "age": {"role": "baseline", "data_type": "continuous"},
+            "sex": {"role": "baseline", "data_type": "categorical"},
+        }
+        pairs = _find_time_pairs(col_info)
+        assert pairs == []
+
+
+class TestBenfordEligibility:
+    """Tier 2: Benford's Law eligibility gate."""
+
+    def test_eligible_multiple_orders(self):
+        """Values spanning >2 orders with sufficient N are eligible."""
+        vals = [10 ** (i / 10) * 100 for i in range(60)]  # 100 to ~1M
+        eligible, reason = _is_benford_eligible(vals, len(vals))
+        assert eligible, f"Should be eligible: {reason}"
+
+    def test_refuses_bounded_column(self):
+        """Bounded narrow-range column (<2 orders) must be rejected."""
+        vals = [float(i) for i in range(40, 81)]  # 40–80, <2 orders
+        eligible, reason = _is_benford_eligible(vals, len(vals))
+        assert not eligible, f"Should be rejected: {reason}"
+        assert "100" in reason or "order" in reason
+
+    def test_refuses_small_n(self):
+        """N < 30 must be rejected."""
+        vals = [10.0, 50.0, 200.0, 800.0, 3000.0]
+        eligible, reason = _is_benford_eligible(vals, len(vals))
+        assert not eligible
+        assert "Sample too small" in reason
+
+    def test_refuses_negative_values(self):
+        """Non-positive values must be rejected."""
+        vals = [1.0, 10.0, 100.0, -5.0, 1000.0] * 10  # N=50, wide range
+        eligible, reason = _is_benford_eligible(vals, len(vals))
+        assert not eligible
+        assert "non-positive" in reason
+
+    def test_refuses_too_few_unique(self):
+        """Too few unique values must be rejected."""
+        vals = [10.0] * 5 + [100.0] * 5 + [200.0] * 5 + [500.0] * 5 + [1000.0] * 5
+        eligible, reason = _is_benford_eligible(vals, len(vals))
+        # N=25 is already too small, so this will fail the N check
+        assert not eligible
+
+    def test_marginal_n_below_50_caveated(self):
+        """30 ≤ N < 50 should be eligible but caveated."""
+        vals = [10 ** (i / 10) * 10 for i in range(40)]  # 10–10^4, 40 vals
+        eligible, reason = _is_benford_eligible(vals, len(vals))
+        assert eligible, f"Should be eligible: {reason}"
+        assert "Marginal" in reason
+
+
+class TestFullReportOnSynthetic:
+    """Full report against synthetic_21.csv constraints."""
+
+    def test_synthetic_21_caveats_benford(self):
+        """synthetic_21.csv has N=21 — Benford section must caveat sample size."""
+        # Build the synthetic_21 schema
+        col_info = {
+            "patient_id": {"role": "baseline", "data_type": "categorical"},
+            "age": {"role": "baseline", "data_type": "continuous"},
+            "sex": {"role": "baseline", "data_type": "categorical"},
+            "iss_stage": {"role": "baseline", "data_type": "categorical"},
+            "prior_lines": {"role": "baseline", "data_type": "continuous"},
+            "high_risk_fish": {"role": "baseline", "data_type": "categorical"},
+            "treatment_arm": {"role": "baseline", "data_type": "categorical"},
+            "response_category": {"role": "outcome", "data_type": "categorical"},
+            "pfs_days": {"role": "outcome", "data_type": "time_to_event"},
+            "pfs_event": {"role": "outcome", "data_type": "categorical"},
+            "os_days": {"role": "outcome", "data_type": "time_to_event"},
+            "os_event": {"role": "outcome", "data_type": "categorical"},
+        }
+        rows = [
+            {"patient_id": f"SUBJ_{i:03d}", "age": str(40 + (i * 2) % 44),
+             "sex": "M" if i % 2 == 0 else "F",
+             "iss_stage": ["I", "II", "III"][i % 3],
+             "prior_lines": str(i % 5),
+             "high_risk_fish": "yes" if i % 3 == 0 else "no",
+             "treatment_arm": "A" if i % 2 == 0 else "B",
+             "response_category": ["CR", "PR", "SD", "PD"][i % 4],
+             "pfs_days": str(30 + i * 30),
+             "pfs_event": "1" if i % 3 != 0 else "0",
+             "os_days": str(30 + i * 60),
+             "os_event": "1" if i % 2 == 0 else "0"}
+            for i in range(21)
+        ]
+        study_id = "test_forensics_synth21"
+        _make_study(study_id, rows, col_info)
+
+        report = run_forensics(study_id)
+        assert report.exists()
+        text = report.read_text()
+
+        # Benford column should say "too small"
+        assert "Sample too small" in text
+        # Should still produce a complete report
+        assert "Forensics Report" in text
+        assert "Tier 1" in text
+        assert "Tier 2" in text
+        assert "## Summary" in text or "Summary of Checks" in text
+
+        shutil.rmtree(DATA_ROOT / study_id, ignore_errors=True)
+
+
+class TestOutOfRange:
+    """Tier 1: out-of-range value detection."""
+
+    def test_age_out_of_range(self):
+        """Age > 120 must be flagged."""
+        study_id = "test_forensics_oor"
+        col_info = {
+            "age": {"role": "baseline", "data_type": "continuous"},
+        }
+        rows = [{"age": str(v)} for v in [45, 130, 80, -5, 55]]
+        _make_study(study_id, rows, col_info)
+
+        report = run_forensics(study_id)
+        text = report.read_text()
+        assert "⚠" in text
+        assert "age" in text
+        assert "130" in text or "130" in text
+        assert "-5" in text
+
+        shutil.rmtree(DATA_ROOT / study_id, ignore_errors=True)
+
+
+class TestDuplicates:
+    """Tier 1: duplicate detection."""
+
+    def test_exact_duplicate_flagged(self):
+        study_id = "test_forensics_dup_exact"
+        col_info = {
+            "patient_id": {"role": "baseline", "data_type": "categorical"},
+            "age": {"role": "baseline", "data_type": "continuous"},
+            "sex": {"role": "baseline", "data_type": "categorical"},
+        }
+        rows = [
+            {"patient_id": "A", "age": "50", "sex": "M"},
+            {"patient_id": "A", "age": "50", "sex": "M"},
+        ]
+        _make_study(study_id, rows, col_info)
+
+        report = run_forensics(study_id)
+        text = report.read_text()
+        assert "⚠" in text
+        assert "exact duplicate" in text
+
+        shutil.rmtree(DATA_ROOT / study_id, ignore_errors=True)
+
+    def test_near_duplicate_conflict_flagged(self):
+        study_id = "test_forensics_dup_near"
+        col_info = {
+            "age": {"role": "baseline", "data_type": "continuous"},
+            "sex": {"role": "baseline", "data_type": "categorical"},
+        }
+        rows = [
+            {"patient_id": "A", "age": "50", "sex": "M"},
+            {"patient_id": "A", "age": "51", "sex": "M"},
+        ]
+        _make_study(study_id, rows, col_info)
+
+        report = run_forensics(study_id)
+        text = report.read_text()
+        assert "conflicting" in text
+        assert "age" in text
+
+        shutil.rmtree(DATA_ROOT / study_id, ignore_errors=True)

tests/test_forest_plot.py

@@ -0,0 +1,374 @@
+from __future__ import annotations
+
+import math
+import shutil
+from pathlib import Path
+
+from core.database import DATA_ROOT, get_connection, init_db
+from core.reporting.forest_plot import (
+    CovariateRow,
+    ForestPlotData,
+    load_forest_data,
+    render_svg,
+    render_ascii,
+    _extract_epv,
+)
+
+
+# ── Fixtures ─────────────────────────────────────────────────────────────────
+
+def _make_study(study_id: str, covariates: list[dict],
+                concordance: float = 0.72, lr_p: float = 0.01,
+                n: int = 200, epv_text: str | None = None):
+    study_dir = DATA_ROOT / study_id
+    if study_dir.exists():
+        shutil.rmtree(study_dir)
+    study_dir.mkdir(parents=True, exist_ok=True)
+
+    conn = get_connection(study_id)
+    init_db(conn)
+    conn.execute(
+        """INSERT INTO studies (id, name, created_at, data_dir, is_locked, unmasked_at)
+           VALUES (?, ?, ?, ?, ?, ?)""",
+        (study_id, "test", "2026-01-01T00:00:00+00:00", str(study_dir), 2, "2026-07-01T00:00:00+00:00"),
+    )
+    conn.execute(
+        """INSERT INTO analysis_results
+           (study_id, test_name, computed_at, concordance_index, lr_test_p,
+            is_pre_registered, study_plan_version, status_json,
+            sample_counts_json, provenance_json)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+        (study_id, "cox_ph_model", "2026-07-01T00:00:00+00:00",
+         concordance, lr_p, 1, 1,
+         '{"status": "completed"}',
+         f'{{"n_total": {n}, "n_analyzed": {n}, "n_excluded": 0}}',
+         '{}'),
+    )
+    result_id = conn.execute("SELECT last_insert_rowid()").fetchone()[0]
+
+    for i, c in enumerate(covariates):
+        conn.execute(
+            """INSERT INTO analysis_covariate_results
+               (result_id, covariate, hr, ci_lower, ci_upper, wald_p, coef, se, z,
+                reference_level, tested_level)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+            (result_id, c["covariate"], c["hr"], c["ci_lower"], c["ci_upper"],
+             c["wald_p"], c.get("coef"), c.get("se"), c.get("z"),
+             c.get("reference_level"), c.get("tested_level")),
+        )
+    conn.commit()
+    conn.close()
+
+    # Write plan with EPV warning
+    plan = {}
+    if epv_text:
+        plan["warnings"] = {"cox_model": epv_text}
+    import json
+    (study_dir / "study_plan.v1.locked.json").write_text(json.dumps(plan))
+
+    return study_id, result_id
+
+
+# ── Tests ────────────────────────────────────────────────────────────────────
+
+class TestExtractEPV:
+    def test_extracts_epv_from_warning(self):
+        epv, warn = _extract_epv('{"test": "EPV=2.5"}')
+        assert epv == 2.5
+        assert warn is True
+
+    def test_high_epv_no_warning(self):
+        epv, warn = _extract_epv('{"test": "EPV=25.0"}')
+        assert epv == 25.0
+        assert warn is False
+
+    def test_no_epv_string(self):
+        epv, warn = _extract_epv('{"test": "no epv here"}')
+        assert epv is None
+        assert warn is False
+
+    def test_none_input(self):
+        epv, warn = _extract_epv(None)
+        assert epv is None
+        assert warn is False
+
+
+class TestCovariateRowProperties:
+    def test_ci_crosses_one_detection(self):
+        def make(hr, lo, hi, p):
+            return CovariateRow("x", hr, lo, hi, p, coef=None, se=None, z=None)
+        assert make(1.5, 0.8, 2.2, 0.1).ci_crosses_one is True    # crosses 1
+        assert make(2.5, 1.2, 4.0, 0.01).ci_crosses_one is False  # entirely above 1
+        assert make(0.5, 0.3, 0.9, 0.02).ci_crosses_one is False  # entirely below 1
+        assert make(0.5, 0.3, 1.0, 0.01).ci_crosses_one is True   # upper bound = 1
+        assert make(1.0, 0.8, 1.2, 0.05).ci_crosses_one is True   # HR exactly 1
+        assert make(0.8, 0.6, 1.2, 0.1).ci_crosses_one is True    # crosses 1
+        assert make(0.4, 0.3, 0.5, 0.001).ci_crosses_one is False # entirely below 1
+
+    def test_unstable_flag(self):
+        c = CovariateRow("x", 0, 0, 0, 1.0, coef=None, se=None, z=None, unstable=True)
+        assert c.unstable is True
+
+
+class TestAgainstRealStudy:
+    """Test against 4-covariate myeloma cohort study with EPV=2.5."""
+
+    def setup_method(self):
+        self.sid = "test_forest_real_study"
+        covariates = [
+            {"covariate": "treatment_arm", "hr": 1.7029, "ci_lower": 0.2402,
+             "ci_upper": 12.0733, "wald_p": 0.5943, "reference_level": "A", "tested_level": "B"},
+            {"covariate": "age", "hr": 0.9934, "ci_lower": 0.9199,
+             "ci_upper": 1.0727, "wald_p": 0.8656},
+            {"covariate": "high_risk_fish", "hr": 0.3455, "ci_lower": 0.0606,
+             "ci_upper": 1.9711, "wald_p": 0.2316},
+            {"covariate": "prior_lines", "hr": 0.8521, "ci_lower": 0.5412,
+             "ci_upper": 1.3415, "wald_p": 0.4870},
+        ]
+        _make_study(
+            self.sid, covariates, n=21,
+            epv_text="cox_ph_model pfs_model: 10 events across 4 predictor(s) (EPV=2.5). Cox models are unreliable below 10 events per predictor."
+        )
+
+    def teardown_method(self):
+        shutil.rmtree(DATA_ROOT / self.sid, ignore_errors=True)
+
+    def test_loads_four_covariates(self):
+        """Must load exactly 4 covariates with correct display labels."""
+        data = load_forest_data(self.sid)
+        assert len(data.covariates) == 4
+        labels = [c.display_label for c in data.covariates]
+        assert any("Treatment Group" in l for l in labels)
+        assert any("Age, years" in l for l in labels)
+        assert any("High-Risk Cytogenetics" in l for l in labels)
+        assert any("Prior Lines of Therapy" in l for l in labels)
+
+    def test_values_match_db(self):
+        """HR/CI/p values must match DB exactly — pull and compare."""
+        data = load_forest_data(self.sid)
+        conn = get_connection(self.sid)
+        rows = conn.execute(
+            "SELECT covariate, hr, ci_lower, ci_upper, wald_p, reference_level, tested_level "
+            "FROM analysis_covariate_results "
+            "WHERE result_id=(SELECT id FROM analysis_results "
+            "  WHERE study_id=? AND test_name='cox_ph_model' "
+            "  AND id NOT IN (SELECT COALESCE(superseded_previous_result_id, -1) "
+            "    FROM analysis_results WHERE study_id=? AND test_name='cox_ph_model' "
+            "    AND superseded_previous_result_id IS NOT NULL) "
+            "  ORDER BY id DESC LIMIT 1)",
+            (self.sid,) * 2,
+        ).fetchall()
+        conn.close()
+        db_map = {r["covariate"]: r for r in rows}
+        for c in data.covariates:
+            db = db_map[c.covariate]
+            assert c.hr == db["hr"]
+            assert c.ci_lower == db["ci_lower"]
+            assert c.ci_upper == db["ci_upper"]
+            assert c.wald_p == db["wald_p"]
+            assert c.reference_level == db["reference_level"]
+            assert c.tested_level == db["tested_level"]
+
+    def test_epv_caveat_present(self):
+        """Study has EPV=2.5 — report must carry the caveat."""
+        data = load_forest_data(self.sid)
+        assert data.epv_warning is True
+        assert data.epv is not None
+        assert data.epv < 10
+
+    def test_all_cis_cross_one(self):
+        """All 4 covariates in this study have CI crossing 1."""
+        data = load_forest_data(self.sid)
+        for c in data.covariates:
+            assert c.ci_crosses_one, f"{c.covariate} CI does not cross 1"
+
+    def test_svg_renders_with_epv_caveat(self):
+        """SVG output must contain the EPV caveat text."""
+        data = load_forest_data(self.sid)
+        out = "/tmp/test_forest_real.svg"
+        render_svg(data, out)
+        svg = Path(out).read_text()
+        assert "EPV=2.5" in svg
+        assert "Caution" in svg
+        assert "unstable" in svg
+        Path(out).unlink(missing_ok=True)
+
+    def test_ascii_renders_with_epv_caveat(self):
+        """ASCII output must contain the EPV caveat text."""
+        data = load_forest_data(self.sid)
+        text = render_ascii(data)
+        assert "EPV=2.5" in text
+        assert "Caution" in text
+
+
+class TestHighEPVNoCaveat:
+    """Constructed study with high EPV — caveat must NOT appear."""
+
+    def setup_method(self):
+        self.sid = "test_forest_high_epv"
+        covariates = [
+            {"covariate": "treatment_arm", "hr": 2.0, "ci_lower": 1.2,
+             "ci_upper": 3.3, "wald_p": 0.008, "coef": 0.69, "se": 0.26, "z": 2.65,
+             "reference_level": "A", "tested_level": "B"},
+            {"covariate": "age", "hr": 1.05, "ci_lower": 1.01,
+             "ci_upper": 1.09, "wald_p": 0.015, "coef": 0.05, "se": 0.02, "z": 2.43},
+        ]
+        _make_study(self.sid, covariates, n=500,
+                    epv_text="EPV=50.0 — adequate")
+        self.data = load_forest_data(self.sid)
+
+    def teardown_method(self):
+        shutil.rmtree(DATA_ROOT / self.sid, ignore_errors=True)
+
+    def test_epv_warning_false(self):
+        assert self.data.epv_warning is False
+        assert self.data.epv == 50.0
+
+    def test_svg_no_caveat(self):
+        out = "/tmp/test_forest_high_epv.svg"
+        render_svg(self.data, out)
+        svg = Path(out).read_text()
+        assert "Caution" not in svg
+        Path(out).unlink(missing_ok=True)
+
+    def test_ascii_no_caveat(self):
+        text = render_ascii(self.data)
+        assert "Caution" not in text
+
+    def test_some_cis_dont_cross_one(self):
+        assert self.data.covariates[0].ci_crosses_one is False
+        assert self.data.covariates[1].ci_crosses_one is False
+
+    def test_concordance_loaded(self):
+        assert self.data.concordance_index == 0.72
+
+
+class TestUnstableCovariate:
+    """Row with inf/nan HR should render as 'did not converge'."""
+
+    def setup_method(self):
+        self.sid = "test_forest_unstable"
+        covariates = [
+            {"covariate": "stable_var", "hr": 1.5, "ci_lower": 0.8,
+             "ci_upper": 2.8, "wald_p": 0.2, "coef": 0.4, "se": 0.3, "z": 1.33,
+             "reference_level": "A", "tested_level": "B"},
+            {"covariate": "unstable_var", "hr": float("inf"), "ci_lower": 0.5,
+             "ci_upper": float("inf"), "wald_p": 0.5, "coef": None, "se": None, "z": None,
+             "reference_level": "A", "tested_level": "B"},
+        ]
+        _make_study(self.sid, covariates, epv_text="EPV=25.0")
+        self.data = load_forest_data(self.sid)
+
+    def teardown_method(self):
+        shutil.rmtree(DATA_ROOT / self.sid, ignore_errors=True)
+
+    def test_unstable_flagged(self):
+        assert self.data.covariates[1].unstable is True
+
+    def test_stable_not_flagged(self):
+        assert self.data.covariates[0].unstable is False
+
+    def test_svg_shows_unstable_text(self):
+        out = "/tmp/test_forest_unstable.svg"
+        render_svg(self.data, out)
+        svg = Path(out).read_text()
+        assert "did not converge" in svg.lower()
+        Path(out).unlink(missing_ok=True)
+
+
+
+class TestWideHRAlignment:
+    """When HR or CI bounds are ≥10.00, columns must stay aligned."""
+
+    def setup_method(self):
+        self.sid = "test_forest_wide_hr"
+        covariates = [
+            {
+                "covariate": "treatment_arm",
+                "hr": 12.45, "ci_lower": 1.02, "ci_upper": 145.30,
+                "wald_p": 0.041, "coef": 2.52, "se": 1.20, "z": 2.10,
+                "reference_level": "A", "tested_level": "B",
+            },
+            {
+                "covariate": "age",
+                "hr": 1.01, "ci_lower": 0.98, "ci_upper": 1.04,
+                "wald_p": 0.33, "coef": 0.01, "se": 0.01, "z": 0.98,
+            },
+        ]
+        _make_study(self.sid, covariates, n=500, epv_text="EPV=50.0")
+        self.data = load_forest_data(self.sid)
+
+    def teardown_method(self):
+        shutil.rmtree(DATA_ROOT / self.sid, ignore_errors=True)
+
+    def test_columns_aligned(self):
+        """CI brackets must start at the same character position on every row."""
+        text = render_ascii(self.data)
+        lines = text.splitlines()
+        # Skip header row which contains "aHR [95% CI]"
+        data_lines = [l for l in lines if "[" in l and "Covariate" not in l]
+        assert len(data_lines) == 2
+        ci_starts = [l.index("[") for l in data_lines]
+        assert ci_starts[0] == ci_starts[1], \
+            f"CI brackets misaligned: {ci_starts}"
+
+    def test_header_data_column_alignment(self):
+        """Header columns (aHR, p-value) must align exactly with data row columns."""
+        text = render_ascii(self.data)
+        lines = text.splitlines()
+        # Find header row (has "aHR" and "p-value")
+        header = next(l for l in lines if "aHR" in l and "p-value" in l)
+        # Find first data row (has "p=" and CI bracket)
+        data_row = next(l for l in lines if "p=" in l and "[" in l)
+        # Check alignment of key column positions
+        # HR column: header "aHR" right-edge aligns with data HR numeric right-edge (both in 7-char field)
+        # CI bracket: header "[95% CI]" left-edge aligns with data "[" left-edge
+        assert header.index("[95% CI]") == data_row.index("[")
+        # p-value header aligns with p= field
+        assert header.index("p-value") == data_row.index("p=")
+
+    def test_ref_line_at_computed_position(self):
+        """The │ reference line must sit at exactly the character index _pos(1.0) computes."""
+        text = render_ascii(self.data)
+        lines = text.splitlines()
+        # Find the axis tick line (has │ at tick positions including value 1.0).
+        # Locate the │ that sits at the 1.0 tick position by searching the scale header structure.
+        # The second │ after name_w chars marks the ref position.
+        tick_line = [l for l in lines if "│" in l and "─" in l and "Forest" not in l
+                     and "C-index" not in l and "EPV" not in l and "⚠" not in l
+                     and "**" not in l and not l.startswith("─")][0]
+        # The plot area starts after label column + separator │, at index name_w + 1.
+        # The ref │ is somewhere in the tick line — find it as the ─┬ at the tick for 1.0,
+        # then locate the │ immediately after it.
+        # Tick marker for 1.0: the tick text "1" follows a "┬" character placed at the ref x.
+        # In the scale header: "...┬" then below "...│" — the │ under each ┬ is at the same index.
+        # So find the │ that's below "┬" in the scale header — that's the ref pos.
+        # Easier: find the separator line ──┬── (which has ┬ at each tick position).
+        # Actually, the simplest: compute lo/hi like render_ascii does, derive ref,
+        # then assert │ in a data row is at name_w + 1 + ref.
+        all_vals = [1.0]
+        for c in self.data.covariates:
+            if not c.unstable and c.hr > 0 and c.ci_lower > 0 and c.ci_upper > 0:
+                all_vals.extend([c.hr, c.ci_lower, c.ci_upper])
+        lo = min(all_vals) / 1.3
+        hi = max(all_vals) * 1.3
+        if lo <= 0:
+            lo = 0.1
+        plot_w = 30
+        ref = int((math.log(1.0) - math.log(lo)) / (math.log(hi) - math.log(lo)) * plot_w)
+        for l in lines:
+            if "[" in l and "p=" in l:  # data row
+                label_part = l.split("│")[0]
+                # │ in data row is at index len(label_part)
+                assert l.index("│", len(label_part)) == len(label_part)
+                # Within the plot, ref is at index ref (0-based in 30-char buf).
+                # So │ appears at len(label_part) + 1 (│ sep) + ref within plot... no.
+                # Actually │ IS at len(label_part) — it's the label separator at position name_w+0.
+                # The ref line │ inside the plot area is at a later index.
+                # data_line format: {label}│{plot_buf}  {hr} {ci} {p}
+                # The second │ in the line (reference line inside plot) is what we want.
+                rest = l[len(label_part) + 1:]  # after first │
+                ref_char_idx = rest.index("│")
+                # ref_char_idx in rest should equal ref (plot_buf index)
+                assert ref_char_idx == ref, \
+                    f"ref │ at plot index {ref_char_idx}, expected {ref} (lo={lo:.2f}, hi={hi:.2f})"