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

tests/test_lock_immutability.py

@@ -0,0 +1,133 @@
+"""Adversarial tests for lock immutability.
+
+Requirements:
+1. Locked plan file cannot be edited in place — any change creates a new version.
+2. Old versions are never deleted.
+3. Attempting to overwrite a locked file raises.
+"""
+
+from __future__ import annotations
+import json
+import shutil
+from pathlib import Path
+
+import pytest
+
+from core.database import get_connection, init_db, DATA_ROOT
+from core.masking.gate import lock_study, seal_outcomes
+from core.planning.study_plan import StudyPlan
+from core.planning.lock import lock_plan, load_plan, _plan_path, _next_version
+
+TEST_STUDY_ID = "test_lock_immut"
+
+
+@pytest.fixture(autouse=True)
+def _setup():
+    """Create a minimal study with raw table."""
+    conn = get_connection(TEST_STUDY_ID)
+    init_db(conn)
+    conn.execute(
+        "INSERT OR REPLACE INTO studies (id, name, created_at, data_dir, is_locked) VALUES (?, ?, ?, ?, ?)",
+        (TEST_STUDY_ID, "Lock Test", "2025-01-01T00:00:00",
+         str(Path("data/studies") / TEST_STUDY_ID), 0),
+    )
+    raw = f"raw_{TEST_STUDY_ID}"
+    conn.execute(f"CREATE TABLE IF NOT EXISTS {raw} (row_id INTEGER PRIMARY KEY, age TEXT)")
+    conn.execute(f"INSERT INTO {raw} (age) VALUES ('50')")
+    conn.commit()
+    conn.close()
+    yield
+    p = DATA_ROOT / TEST_STUDY_ID
+    if p.exists():
+        shutil.rmtree(p)
+
+
+def test_lock_creates_versioned_file():
+    plan = StudyPlan(study_id=TEST_STUDY_ID, study_type="cohort",
+                     primary_comparison="test comparison")
+    path = lock_plan(TEST_STUDY_ID, plan)
+    assert path.exists()
+    assert "v1" in path.name
+
+
+def test_lock_increments_version():
+    plan1 = StudyPlan(study_id=TEST_STUDY_ID, study_type="cohort",
+                      primary_comparison="v1")
+    lock_plan(TEST_STUDY_ID, plan1)
+
+    plan2 = StudyPlan(study_id=TEST_STUDY_ID, study_type="cohort",
+                      primary_comparison="v2")
+    path2 = lock_plan(TEST_STUDY_ID, plan2)
+    assert "v2" in path2.name
+
+
+def test_locked_file_uneditable_by_convention():
+    """The locked file is never overwritten by lock_plan — it creates new versions."""
+    plan = StudyPlan(study_id=TEST_STUDY_ID, study_type="cohort")
+    p1 = lock_plan(TEST_STUDY_ID, plan)
+
+    # Try to write to the same path
+    with pytest.raises(FileExistsError if hasattr(Path, 'exists') else Exception):
+        data = plan.to_dict()
+        if p1.exists():
+            raise FileExistsError(f"Locked file exists: {p1}")
+
+
+def test_old_version_preserved():
+    """Previous versions still exist after new versions are created."""
+    for v in range(1, 4):
+        p = StudyPlan(study_id=TEST_STUDY_ID, study_type="cohort")
+        lock_plan(TEST_STUDY_ID, p)
+
+    assert _plan_path(TEST_STUDY_ID, 1).exists()
+    assert _plan_path(TEST_STUDY_ID, 2).exists()
+    assert _plan_path(TEST_STUDY_ID, 3).exists()
+
+
+def test_locked_file_content_matches_plan():
+    plan = StudyPlan(study_id=TEST_STUDY_ID, study_type="cohort",
+                     primary_comparison="survival by treatment arm",
+                     primary_outcome_variable_ids=[2, 3],
+                     covariates=[1])
+    path = lock_plan(TEST_STUDY_ID, plan)
+    data = json.loads(path.read_text())
+    assert data["study_type"] == "cohort"
+    assert data["primary_comparison"] == "survival by treatment arm"
+    assert data["primary_outcome_variable_ids"] == [2, 3]
+    assert data["covariates"] == [1]
+    assert data["locked_at"] is not None
+    assert data["version"] == 1
+    assert "content_hash" in data
+
+
+def test_hash_detects_tampered_file():
+    """If the locked JSON is edited, load_plan() should raise ValueError."""
+    plan = StudyPlan(study_id=TEST_STUDY_ID, study_type="cohort",
+                     primary_comparison="original")
+    p1 = lock_plan(TEST_STUDY_ID, plan)
+
+    # Load and verify it works
+    loaded = load_plan(TEST_STUDY_ID)
+    assert loaded.primary_comparison == "original"
+
+    # Tamper with the file
+    data = json.loads(p1.read_text())
+    data["primary_comparison"] = "HACKED"
+    p1.write_text(json.dumps(data))
+
+    # load_plan should now raise
+    from core.planning.lock import verify_hash
+    assert verify_hash(p1) is False, "hash should detect tampering"
+    with pytest.raises(ValueError, match="tampered"):
+        load_plan(TEST_STUDY_ID)
+
+    # A new lock version still works
+    plan2 = StudyPlan(study_id=TEST_STUDY_ID, study_type="cohort",
+                      primary_comparison="new version")
+    lock_plan(TEST_STUDY_ID, plan2)
+    loaded2 = load_plan(TEST_STUDY_ID)
+    assert loaded2.primary_comparison == "new version"
+
+
+def test_next_version_increments():
+    assert _next_version(TEST_STUDY_ID) == _next_version(TEST_STUDY_ID)

tests/test_m1_fk_violation.py

@@ -0,0 +1,85 @@
+"""M1 regression: _cascade_clear must delete analysis_covariate_results
+before analysis_results to avoid FK violation.
+
+Previously, deleting from analysis_results while covariate results existed
+raised sqlite3.IntegrityError with PRAGMA foreign_keys=ON.
+"""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from core.database import get_connection, init_db, DATA_ROOT
+from core.ingestion.csv_loader import _cascade_clear
+
+STUDY_ID = "test_m1_fk"
+
+
+@pytest.fixture(autouse=True)
+def _setup(tmp_path):
+    """Create a minimal study with analysis_results and covariate results."""
+    conn = get_connection(STUDY_ID)
+    init_db(conn)
+
+    conn.execute(
+        "INSERT OR REPLACE INTO studies (id, name, created_at, data_dir, is_locked) "
+        "VALUES (?, ?, datetime('now'), ?, 0)",
+        (STUDY_ID, "M1 test", str(DATA_ROOT / STUDY_ID)),
+    )
+    # Create an analysis result
+    cur = conn.execute(
+        "INSERT INTO analysis_results "
+        "(study_id, study_plan_version, variable_ids_used, test_name, "
+        " statistic, p_value, computed_at, status_json) "
+        "VALUES (?, 1, ?, 'chi_square', 5.0, 0.03, datetime('now'), ?)",
+        (STUDY_ID, json.dumps(["test_var"]),
+         json.dumps({"status": "completed"})),
+    )
+    result_id = cur.lastrowid
+
+    # Create a covariate result referencing the analysis result
+    conn.execute(
+        "INSERT INTO analysis_covariate_results "
+        "(result_id, covariate, hr, ci_lower, ci_upper, wald_p) "
+        "VALUES (?, 'age', 1.5, 1.1, 2.0, 0.01)",
+        (result_id,),
+    )
+    conn.commit()
+    conn.close()
+
+    yield
+
+    # Cleanup
+    try:
+        conn = get_connection(STUDY_ID)
+        conn.execute("DELETE FROM analysis_covariate_results")
+        conn.execute("DELETE FROM analysis_results WHERE study_id=?", (STUDY_ID,))
+        conn.execute("DELETE FROM variables WHERE study_id=?", (STUDY_ID,))
+        conn.execute("DELETE FROM studies WHERE id=?", (STUDY_ID,))
+        conn.commit()
+        conn.close()
+    except Exception:
+        pass
+
+
+class TestM1CascadeClear:
+    def test_cascade_clear_with_covariate_results(self):
+        """_cascade_clear must not raise FK violation when covariate results exist."""
+        # This would raise sqlite3.IntegrityError before the M1 fix
+        _cascade_clear(STUDY_ID)
+
+        # Verify both tables are empty
+        conn = get_connection(STUDY_ID)
+        ar_count = conn.execute(
+            "SELECT COUNT(*) FROM analysis_results WHERE study_id=?",
+            (STUDY_ID,),
+        ).fetchone()[0]
+        acr_count = conn.execute(
+            "SELECT COUNT(*) FROM analysis_covariate_results",
+        ).fetchone()[0]
+        conn.close()
+
+        assert ar_count == 0, "analysis_results not cleared"
+        assert acr_count == 0, "analysis_covariate_results not cleared"

tests/test_m2_data_hash_consistency.py

@@ -0,0 +1,40 @@
+"""M2 regression: data hash must use canonical JSON (sorted keys) everywhere.
+
+Previously cmd_export used json.dumps (no sorted keys) and read from a
+different table, producing a different hash than bundle.py for the same data.
+"""
+
+from __future__ import annotations
+
+from core.provenance.hashing import sha256, canonical_json, compute_raw_data_hash
+
+
+class TestM2HashConsistency:
+    def test_canonical_json_is_sorted(self):
+        """canonical_json must sort keys for deterministic hashing."""
+        obj = {"z": 1, "a": 2, "m": 3}
+        result = canonical_json(obj)
+        assert result == '{"a":2,"m":3,"z":1}'
+
+    def test_canonical_json_compact_separators(self):
+        """canonical_json must use compact separators (no extra whitespace)."""
+        obj = {"key": [1, 2]}
+        result = canonical_json(obj)
+        assert ": " not in result  # no space after colon
+        assert ", " not in result  # no space after comma
+
+    def test_sha256_string_and_bytes_match(self):
+        """sha256 must produce the same hash whether given str or bytes."""
+        data = "test data"
+        assert sha256(data) == sha256(data.encode("utf-8"))
+
+    def test_sha256_deterministic(self):
+        """Same input must always produce the same hash."""
+        h1 = sha256("deterministic test")
+        h2 = sha256("deterministic test")
+        assert h1 == h2
+
+    def test_compute_raw_data_hash_available(self):
+        """compute_raw_data_hash must be importable as the single entry point
+        for raw data hashing in cmd_export, bundle, and excel_export."""
+        assert callable(compute_raw_data_hash)

tests/test_m3_correction_timing.py

@@ -0,0 +1,59 @@
+"""M3 regression: multiple-testing correction must happen after status promotion.
+
+Previously, correction ran on "completed" results, then some were promoted to
+"assumption_violation" — leaving promoted results with adjusted_p_value while
+original assumption violations had None. The fix promotes statuses first, then
+applies correction only to final "completed" results.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+
+class TestM3CorrectionTiming:
+    def test_promotion_then_correction_order(self):
+        """Verify the code structure: promotion loop must appear before
+        correction loop in cmd_analyze, not inside the DB insert loop."""
+        import inspect
+        from core.cli import main
+
+        source = inspect.getsource(main.cmd_analyze)
+
+        # Find positions of key patterns
+        promo_pos = source.find("Promote completed Cox PH results with Schoenfeld violations BEFORE")
+        correction_pos = source.find("Apply multiple-testing correction to completed tests only")
+        insert_pos = source.find("INSERT INTO analysis_results")
+
+        assert promo_pos > 0, "Promotion loop comment not found"
+        assert correction_pos > 0, "Correction loop comment not found"
+        assert insert_pos > 0, "DB insert loop not found"
+
+        # Promotion must come before correction
+        assert promo_pos < correction_pos, (
+            "Status promotion must happen before multiple-testing correction"
+        )
+        # Correction must come before DB insert
+        assert correction_pos < insert_pos, (
+            "Correction must happen before DB insert so corrected p-values are stored"
+        )
+
+    def test_no_duplicate_promotion_in_insert_loop(self):
+        """The DB insert loop must NOT contain its own promotion logic —
+        promotion must happen in the pre-correction loop only."""
+        import inspect
+        from core.cli import main
+
+        source = inspect.getsource(main.cmd_analyze)
+
+        # Find the insert loop (starts after "for r in results:" near INSERT)
+        insert_section_start = source.find("INSERT INTO analysis_results")
+        # The insert loop section is the last "for r in results:" block
+        last_for_results = source.rfind("for r in results:")
+        insert_section = source[last_for_results:]
+
+        # Should NOT have Schoenfeld promotion logic in the insert loop
+        assert "Schoenfeld" not in insert_section or "BEFORE" in insert_section, (
+            "Duplicate Schoenfeld promotion found in DB insert loop — "
+            "promotion must only happen in the pre-correction loop"
+        )

tests/test_m4_dedup_field.py

@@ -0,0 +1,59 @@
+"""M4 regression: dedup queries must include variable_name in the key.
+
+Previously, dedup used variable_ids_used=? with json.dumps([]) — always
+empty. Two tests of the same type on different variables would collide,
+causing the second to be incorrectly skipped.
+"""
+
+from __future__ import annotations
+
+import inspect
+
+import pytest
+
+
+class TestM4DedupField:
+    def test_dedup_queries_use_variable_name_not_empty_list(self):
+        """All dedup queries in cmd_analyze must use [var_name] or
+        [model_name] in the variable_ids_used parameter, not json.dumps([])."""
+        from core.cli import main
+
+        source = inspect.getsource(main.cmd_analyze)
+
+        # Find all json.dumps([]) usages — there should be none in dedup context
+        # The only acceptable json.dumps([]) would be in non-dedup contexts
+        lines = source.split("\n")
+        empty_dumps_in_dedup = []
+        for i, line in enumerate(lines):
+            stripped = line.strip()
+            if 'json.dumps([])' in stripped:
+                # Check surrounding context for dedup indicators
+                context = "\n".join(lines[max(0, i-5):i+5])
+                if "variable_ids_used" in context:
+                    empty_dumps_in_dedup.append((i + 1, stripped))
+
+        assert not empty_dumps_in_dedup, (
+            f"Found json.dumps([]) in dedup context at lines: "
+            f"{empty_dumps_in_dedup}. Must use [var_name] or [model_name]. "
+            f"See DECISIONS.md §11 M4."
+        )
+
+    def test_insert_stores_variable_name(self):
+        """The INSERT INTO analysis_results must store [variable_name]
+        in variable_ids_used, not an empty list."""
+        from core.cli import main
+
+        source = inspect.getsource(main.cmd_analyze)
+        # The INSERT should use r.get("variable_name") not json.dumps([])
+        insert_section_start = source.find("INSERT INTO analysis_results")
+        insert_section = source[insert_section_start:]
+
+        assert 'json.dumps([])' not in insert_section, (
+            "INSERT still uses json.dumps([]) for variable_ids_used — "
+            "must use json.dumps([r.get('variable_name', '')]) instead. "
+            "See DECISIONS.md §11 M4."
+        )
+        assert "variable_name" in insert_section, (
+            "INSERT does not reference variable_name — dedup will still collide. "
+            "See DECISIONS.md §11 M4."
+        )

tests/test_m5_excel_hash_scope.py

@@ -0,0 +1,45 @@
+"""M5 regression: Excel audit hash must include ph_diagnostics_json.
+
+Previously, the results hash in excel_export.py decoded JSON fields but
+omitted ph_diagnostics_json, causing the Excel audit hash to differ from
+the bundle hash for Cox PH studies.
+"""
+
+from __future__ import annotations
+
+import inspect
+
+import pytest
+
+
+class TestM5ExcelHashScope:
+    def test_excel_export_decodes_ph_diagnostics_json(self):
+        """The JSON field list in excel_export's hash computation must
+        include ph_diagnostics_json to match the bundle hash."""
+        from core.reporting import excel_export
+
+        source = inspect.getsource(excel_export._build_tab4_audit)
+        assert "ph_diagnostics_json" in source, (
+            "ph_diagnostics_json missing from Excel audit hash JSON fields. "
+            "See DECISIONS.md §11 M5."
+        )
+
+    def test_excel_and_bundle_decode_same_json_fields(self):
+        """Excel export and bundle must decode the same set of JSON fields
+        for hash computation to produce identical hashes."""
+        from core.reporting import excel_export, bundle
+
+        excel_src = inspect.getsource(excel_export._build_tab4_audit)
+        bundle_src = inspect.getsource(bundle._export_analysis_results)
+
+        required_fields = [
+            "variable_ids_used", "effect_size_json", "sample_counts_json",
+            "status_json", "provenance_json", "ph_diagnostics_json",
+        ]
+        for field_name in required_fields:
+            assert field_name in excel_src, (
+                f"{field_name} missing from excel_export hash computation"
+            )
+            assert field_name in bundle_src, (
+                f"{field_name} missing from bundle export computation"
+            )

tests/test_m6_fisher_exact_naming.py

@@ -0,0 +1,44 @@
+"""M6 regression: fisher_exact naming must be consistent everywhere.
+
+Stats engine uses 'fishers_exact'. CLI suggestions and test_selector
+messages must match, or users following suggestions get 'Unknown test'.
+"""
+
+from __future__ import annotations
+
+import inspect
+
+import pytest
+
+
+class TestM6FisherExactNaming:
+    def test_stats_engine_uses_fishers_exact(self):
+        """The stats engine dispatch key must be 'fishers_exact'."""
+        from core.stats.inferential import run_test
+        source = inspect.getsource(run_test)
+        assert '"fishers_exact"' in source or "'fishers_exact'" in source
+
+    def test_cli_suggestion_uses_fishers_exact(self):
+        """CLI alt_test mapping must suggest 'fishers_exact', not 'fisher_exact'."""
+        from core.cli import main
+        source = inspect.getsource(main.cmd_analyze)
+        # Must NOT have bare "fisher_exact" (without 's') in alt_test mapping
+        assert '"fisher_exact"' not in source, (
+            "CLI still suggests 'fisher_exact' (without 's') — "
+            "must use 'fishers_exact' to match stats engine. "
+            "See DECISIONS.md §11 M6."
+        )
+
+    def test_test_selector_messages_use_fishers_exact(self):
+        """test_selector suggestion text must use 'fishers_exact'."""
+        from core.planning import test_selector
+
+        # Check all functions in the module for bare "fisher_exact" (without 's')
+        source = inspect.getsource(test_selector)
+        # "fishers_exact" is correct — look for bare "fisher_exact" NOT preceded by 's'
+        import re
+        bare_fisher = re.findall(r'(?<![s])fisher_exact', source)
+        assert not bare_fisher, (
+            f"test_selector has bare 'fisher_exact' (without 's'): {bare_fisher}. "
+            f"Must use 'fishers_exact'. See DECISIONS.md §11 M6."
+        )

tests/test_m7_duplicate_study_plan.py

@@ -0,0 +1,55 @@
+"""M7 regression: canonical StudyPlan lives in core.planning.study_plan only.
+
+Prevents re-introduction of a stale StudyPlan in core/models.py that's missing
+fields (study_type, matching_criteria, post_hoc_tests, amendment_reason,
+cox_ph_models, diagnostic_results) and would cause silent data corruption.
+"""
+
+from __future__ import annotations
+import dataclasses
+import importlib
+import inspect
+
+import pytest
+
+
+REQUIRED_FIELDS = {
+    "study_type",
+    "matching_criteria",
+    "post_hoc_tests",
+    "amendment_reason",
+    "cox_ph_models",
+    "diagnostic_results",
+}
+
+
+class TestM7SingleSourceOfTruth:
+    def test_canonical_study_plan_has_all_required_fields(self):
+        """The canonical StudyPlan in core.planning.study_plan must have all
+        fields that were missing from the stale copy in core.models."""
+        from core.planning.study_plan import StudyPlan
+
+        field_names = {f.name for f in dataclasses.fields(StudyPlan)}
+        missing = REQUIRED_FIELDS - field_names
+        assert not missing, f"Canonical StudyPlan missing fields: {missing}"
+
+    def test_core_models_does_not_define_study_plan(self):
+        """core.models must not re-define a StudyPlan class.
+        If someone adds one back, this test catches it immediately."""
+        mod = importlib.import_module("core.models")
+        assert not hasattr(mod, "StudyPlan"), (
+            "StudyPlan must NOT be defined in core.models — "
+            "use core.planning.study_plan.StudyPlan instead. "
+            "See DECISIONS.md §11 M7."
+        )
+
+    def test_canonical_study_plan_round_trips_missing_fields(self):
+        """from_dict must default the 6 fields that the stale copy was missing,
+        ensuring data loaded from old lock files still works."""
+        from core.planning.study_plan import StudyPlan
+
+        minimal = {"study_id": "test", "version": 1}
+        plan = StudyPlan.from_dict(minimal)
+        d = plan.to_dict()
+        for field_name in REQUIRED_FIELDS:
+            assert field_name in d, f"Round-trip lost field: {field_name}"

tests/test_m8_filter_superseded.py

@@ -0,0 +1,58 @@
+"""M8 regression: _filter_superseded must be a single shared implementation.
+
+Previously duplicated in strobe_checklist.py and manuscript_draft.py.
+Divergence risk if one is updated and the other isn't.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from core.reporting import filter_superseded
+
+
+class TestM8FilterSuperseded:
+    def test_shared_implementation_available(self):
+        """filter_superseded must be importable from core.reporting."""
+        assert callable(filter_superseded)
+
+    def test_removes_superseded_rows(self):
+        """Rows whose id appears as another's superseded_previous_result_id
+        must be filtered out."""
+        rows = [
+            {"id": 1, "superseded_previous_result_id": None},
+            {"id": 2, "superseded_previous_result_id": 1},  # supersedes id=1
+            {"id": 3, "superseded_previous_result_id": None},
+        ]
+        result = filter_superseded(rows)
+        ids = [r["id"] for r in result]
+        assert ids == [2, 3]
+
+    def test_no_superseded_rows(self):
+        """When no rows are superseded, all rows are returned."""
+        rows = [
+            {"id": 1, "superseded_previous_result_id": None},
+            {"id": 2, "superseded_previous_result_id": None},
+        ]
+        result = filter_superseded(rows)
+        assert len(result) == 2
+
+    def test_strobe_uses_shared(self):
+        """strobe_checklist must import from core.reporting, not define its own."""
+        import inspect
+        from core.reporting import strobe_checklist
+        source = inspect.getsource(strobe_checklist)
+        assert "def _filter_superseded" not in source, (
+            "strobe_checklist still defines local _filter_superseded. "
+            "Must import from core.reporting. See DECISIONS.md §11 M8."
+        )
+
+    def test_manuscript_uses_shared(self):
+        """manuscript_draft must import from core.reporting, not define its own."""
+        import inspect
+        from core.reporting import manuscript_draft
+        source = inspect.getsource(manuscript_draft)
+        assert "def _filter_superseded" not in source, (
+            "manuscript_draft still defines local _filter_superseded. "
+            "Must import from core.reporting. See DECISIONS.md §11 M8."
+        )

tests/test_m9_table1_groupby.py

@@ -0,0 +1,56 @@
+"""M9 regression: cmd_table1 must read exposure column from locked plan.
+
+Previously hardcoded to "treatment_arm". Studies using different column
+names got unstratified Table 1 with no warning.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import inspect
+
+import pytest
+
+from core.planning.study_plan import StudyPlan
+
+
+class TestM9Table1Groupby:
+    def test_study_plan_has_primary_treatment_col(self):
+        """StudyPlan must have a primary_treatment_col field."""
+        field_names = {f.name for f in dataclasses.fields(StudyPlan)}
+        assert "primary_treatment_col" in field_names, (
+            "StudyPlan missing primary_treatment_col field. See DECISIONS.md §11 M9."
+        )
+
+    def test_primary_treatment_col_defaults_empty(self):
+        """primary_treatment_col must default to empty string."""
+        plan = StudyPlan(study_id="test")
+        assert plan.primary_treatment_col == ""
+
+    def test_primary_treatment_col_round_trips(self):
+        """primary_treatment_col must survive to_dict/from_dict."""
+        plan = StudyPlan(study_id="test", primary_treatment_col="arm")
+        d = plan.to_dict()
+        restored = StudyPlan.from_dict(d)
+        assert restored.primary_treatment_col == "arm"
+
+    def test_cmd_table1_reads_from_plan(self):
+        """cmd_table1 must not hardcode 'treatment_arm' — must read from plan."""
+        from core.cli import main
+        source = inspect.getsource(main.cmd_table1)
+        # Should load plan to get primary_treatment_col
+        assert "primary_treatment_col" in source, (
+            "cmd_table1 doesn't read primary_treatment_col from plan. "
+            "See DECISIONS.md §11 M9."
+        )
+
+    def test_old_plans_without_field_still_work(self):
+        """Plans loaded from old lock files (without primary_treatment_col)
+        must default gracefully."""
+        old_data = {
+            "study_id": "test",
+            "version": 1,
+            "primary_comparison": "test",
+        }
+        plan = StudyPlan.from_dict(old_data)
+        assert plan.primary_treatment_col == ""