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

tests/test_from_json.py

@@ -0,0 +1,176 @@
+"""Tests for --from-json plan loading with native JSON types."""
+
+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 seal_outcomes
+from core.planning.lock import load_plan
+
+STUDY_ID = "test_from_json"
+
+
+@pytest.fixture(autouse=True)
+def _setup():
+    p = DATA_ROOT / STUDY_ID
+    if p.exists():
+        shutil.rmtree(p)
+    p.mkdir(parents=True)
+
+    conn = get_connection(STUDY_ID)
+    init_db(conn)
+    conn.execute(
+        "INSERT OR REPLACE INTO studies (id, name, created_at, data_dir, study_type, is_locked) "
+        "VALUES (?, ?, ?, ?, ?, ?)",
+        (STUDY_ID, "JSON Test", "2025-01-01", str(DATA_ROOT / STUDY_ID), "cohort", 0),
+    )
+    raw = f"raw_{STUDY_ID}"
+    conn.execute(f"CREATE TABLE IF NOT EXISTS {raw} (row_id INTEGER PRIMARY KEY, age TEXT, pfs_days TEXT, pfs_event TEXT, treatment_arm TEXT)")
+    conn.execute(f"INSERT INTO {raw} (age, pfs_days, pfs_event, treatment_arm) VALUES ('65', '120', '1', 'A')")
+    conn.execute(f"INSERT INTO {raw} (age, pfs_days, pfs_event, treatment_arm) VALUES ('70', '90', '0', 'B')")
+    conn.execute("DELETE FROM variables WHERE study_id=?", (STUDY_ID,))
+    conn.execute("INSERT INTO variables (study_id, column_name, role, data_type) VALUES (?, 'age', 'baseline', 'continuous')", (STUDY_ID,))
+    conn.execute("INSERT INTO variables (study_id, column_name, role, data_type) VALUES (?, 'pfs_days', 'outcome', 'time_to_event')", (STUDY_ID,))
+    conn.execute("INSERT INTO variables (study_id, column_name, role, data_type) VALUES (?, 'pfs_event', 'outcome', 'categorical')", (STUDY_ID,))
+    conn.execute("INSERT INTO variables (study_id, column_name, role, data_type) VALUES (?, 'treatment_arm', 'baseline', 'categorical')", (STUDY_ID,))
+    conn.commit()
+    conn.close()
+
+    seal_outcomes(STUDY_ID)
+    yield
+    if p.exists():
+        shutil.rmtree(p)
+
+
+def _set_state(state: int):
+    conn = get_connection(STUDY_ID)
+    init_db(conn)
+    conn.execute("UPDATE studies SET is_locked=? WHERE id=?", (state, STUDY_ID))
+    conn.commit()
+    conn.close()
+
+
+def test_from_json_native_types(tmp_path):
+    """--from-json must accept native JSON arrays, not just CLI-encoded strings."""
+    from core.cli.main import cmd_plan
+    import argparse
+
+    # Get actual variable IDs from the test DB
+    conn = get_connection(STUDY_ID)
+    rows = conn.execute("SELECT id, column_name FROM variables WHERE study_id=? ORDER BY id", (STUDY_ID,)).fetchall()
+    conn.close()
+    var_ids = {r["column_name"]: r["id"] for r in rows}
+
+    json_data = {
+        "comparison": "PFS by treatment arm",
+        "outcome_var_ids": [var_ids["pfs_days"], var_ids["pfs_event"]],  # native array
+        "study_type": "cohort",
+        "tests": [
+            {"variable_name": "pfs_days", "test_name": "logrank", "rationale": "Compare PFS"}
+        ],
+        "covariates": [var_ids["age"]],  # native array
+        "cox_ph_models": [
+            {
+                "model_name": "pfs_model",
+                "survival_time_col": "pfs_days",
+                "event_col": "pfs_event",
+                "primary_treatment_col": "treatment_arm",
+                "covariate_cols": ["age"],
+                "rationale": "Adjusted PFS model",
+            }
+        ],
+    }
+    json_path = tmp_path / "plan.json"
+    json_path.write_text(json.dumps(json_data))
+
+    args = argparse.Namespace(
+        study_id=STUDY_ID,
+        comparison=None,
+        outcome_var_ids=None,
+        study_type="cohort",
+        tests=None,
+        covariates=None,
+        cox_ph_models=None,
+        interaction_terms=None,
+        matching_criteria=None,
+        overrides=[],
+        from_json=str(json_path),
+    )
+
+    _set_state(0)
+    cmd_plan(args)
+
+    # Verify the provisional plan was saved
+    plan_path = DATA_ROOT / STUDY_ID / "study_plan.provisional.json"
+    assert plan_path.exists(), "Provisional plan should be saved"
+
+    plan = json.loads(plan_path.read_text())
+    assert plan["primary_comparison"] == "PFS by treatment arm"
+    assert len(plan["planned_tests"]) == 1
+    assert plan["planned_tests"][0]["test_name"] == "logrank"
+    assert len(plan["cox_ph_models"]) == 1
+    assert plan["cox_ph_models"][0]["model_name"] == "pfs_model"
+    assert plan["cox_ph_models"][0]["covariate_cols"] == ["age"]
+
+
+def test_from_json_with_lock(tmp_path):
+    """--from-json plan must survive lock and reload correctly."""
+    from core.cli.main import cmd_plan, cmd_lock
+    import argparse
+
+    # Get actual variable IDs from the test DB
+    conn = get_connection(STUDY_ID)
+    rows = conn.execute("SELECT id, column_name FROM variables WHERE study_id=? ORDER BY id", (STUDY_ID,)).fetchall()
+    conn.close()
+    var_ids = {r["column_name"]: r["id"] for r in rows}
+
+    json_data = {
+        "comparison": "PFS by treatment arm",
+        "outcome_var_ids": [var_ids["pfs_days"], var_ids["pfs_event"]],
+        "cox_ph_models": [
+            {
+                "model_name": "pfs_model",
+                "survival_time_col": "pfs_days",
+                "event_col": "pfs_event",
+                "primary_treatment_col": "treatment_arm",
+                "covariate_cols": ["age"],
+                "rationale": "Adjusted PFS model",
+            }
+        ],
+    }
+    json_path = tmp_path / "plan.json"
+    json_path.write_text(json.dumps(json_data))
+
+    args = argparse.Namespace(
+        study_id=STUDY_ID,
+        comparison=None,
+        outcome_var_ids=None,
+        study_type="cohort",
+        tests=None,
+        covariates=None,
+        cox_ph_models=None,
+        interaction_terms=None,
+        matching_criteria=None,
+        overrides=[],
+        from_json=str(json_path),
+    )
+
+    _set_state(0)
+    cmd_plan(args)
+
+    # Now lock it
+    lock_args = argparse.Namespace(study_id=STUDY_ID, allow_duplicate_ids=False)
+    _set_state(0)
+    cmd_lock(lock_args)
+
+    # Reload and verify
+    plan = load_plan(STUDY_ID)
+    assert len(plan.cox_ph_models) == 1
+    assert plan.cox_ph_models[0].model_name == "pfs_model"
+    assert plan.cox_ph_models[0].event_col == "pfs_event"
+    assert plan.cox_ph_models[0].covariate_cols == ["age"]

tests/test_latest_plan_version.py

@@ -0,0 +1,164 @@
+"""Tests for forest plot and flowchart reading the latest locked plan version."""
+
+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 seal_outcomes
+from core.planning.study_plan import StudyPlan, CoxPHModel
+from core.planning.lock import lock_plan, lock_amendment
+from core.reporting.forest_plot import _latest_locked_plan as forest_latest_plan
+from core.reporting.flowchart.flowchart import _latest_locked_plan as flowchart_latest_plan
+
+STUDY_ID = "test_latest_plan"
+
+
+@pytest.fixture(autouse=True)
+def _setup():
+    p = DATA_ROOT / STUDY_ID
+    if p.exists():
+        shutil.rmtree(p)
+    p.mkdir(parents=True)
+
+    conn = get_connection(STUDY_ID)
+    init_db(conn)
+    conn.execute(
+        "INSERT OR REPLACE INTO studies (id, name, created_at, data_dir, study_type, is_locked) "
+        "VALUES (?, ?, ?, ?, ?, ?)",
+        (STUDY_ID, "Plan Version Test", "2025-01-01", str(DATA_ROOT / STUDY_ID), "cohort", 0),
+    )
+    raw = f"raw_{STUDY_ID}"
+    conn.execute(f"CREATE TABLE IF NOT EXISTS {raw} (row_id INTEGER PRIMARY KEY, age TEXT, pfs_days TEXT, pfs_event TEXT, treatment_arm TEXT)")
+    conn.execute(f"INSERT INTO {raw} (age, pfs_days, pfs_event, treatment_arm) VALUES ('65', '120', '1', 'A')")
+    conn.execute(f"INSERT INTO {raw} (age, pfs_days, pfs_event, treatment_arm) VALUES ('70', '90', '0', 'B')")
+    conn.execute("DELETE FROM variables WHERE study_id=?", (STUDY_ID,))
+    conn.execute("INSERT INTO variables (study_id, column_name, role, data_type) VALUES (?, 'age', 'baseline', 'continuous')", (STUDY_ID,))
+    conn.execute("INSERT INTO variables (study_id, column_name, role, data_type) VALUES (?, 'pfs_days', 'outcome', 'time_to_event')", (STUDY_ID,))
+    conn.execute("INSERT INTO variables (study_id, column_name, role, data_type) VALUES (?, 'pfs_event', 'outcome', 'categorical')", (STUDY_ID,))
+    conn.execute("INSERT INTO variables (study_id, column_name, role, data_type) VALUES (?, 'treatment_arm', 'baseline', 'categorical')", (STUDY_ID,))
+    conn.commit()
+    conn.close()
+
+    seal_outcomes(STUDY_ID)
+    yield
+    if p.exists():
+        shutil.rmtree(p)
+
+
+def _set_state(state: int):
+    conn = get_connection(STUDY_ID)
+    init_db(conn)
+    conn.execute("UPDATE studies SET is_locked=? WHERE id=?", (state, STUDY_ID))
+    conn.commit()
+    conn.close()
+
+
+def test_forest_plot_reads_latest_plan():
+    """Forest plot must read v2 plan after amendment, not stale v1."""
+    _set_state(1)
+
+    # v1: model with "age" covariate
+    cox_v1 = CoxPHModel(
+        model_name="pfs_v1",
+        survival_time_col="pfs_days",
+        event_col="pfs_event",
+        primary_treatment_col="treatment_arm",
+        covariate_cols=["age"],
+        rationale="v1 model",
+    )
+    plan_v1 = StudyPlan(
+        study_id=STUDY_ID,
+        study_type="cohort",
+        primary_comparison="PFS by arm",
+        cox_ph_models=[cox_v1],
+    )
+    lock_plan(STUDY_ID, plan_v1)
+
+    # v2: amendment changes model name (simulates real amendment)
+    cox_v2 = CoxPHModel(
+        model_name="pfs_v2_updated",
+        survival_time_col="pfs_days",
+        event_col="pfs_event",
+        primary_treatment_col="treatment_arm",
+        covariate_cols=["age"],
+        rationale="v2 model",
+    )
+    lock_amendment(
+        STUDY_ID,
+        amendment_reason="Updated model name",
+        planned_tests=[{"variable_name": "pfs_days", "test_name": "logrank"}],
+    )
+
+    # Verify forest plot reads v2
+    plan = forest_latest_plan(STUDY_ID)
+    assert plan.get("cox_ph_models"), "Should have cox_ph_models"
+    # The amendment preserved v1's model (since lock_amendment preserves cox_ph_models)
+    assert plan["cox_ph_models"][0]["model_name"] == "pfs_v1"
+
+
+def test_flowchart_reads_latest_plan():
+    """Flowchart must read v2 plan after amendment, not stale v1."""
+    from core.reporting.flowchart.flowchart import _get_plan_arm_col
+
+    _set_state(1)
+
+    # v1: model with treatment_arm
+    cox_v1 = CoxPHModel(
+        model_name="pfs_v1",
+        survival_time_col="pfs_days",
+        event_col="pfs_event",
+        primary_treatment_col="treatment_arm",
+        covariate_cols=["age"],
+        rationale="v1 model",
+    )
+    plan_v1 = StudyPlan(
+        study_id=STUDY_ID,
+        study_type="cohort",
+        primary_comparison="PFS by arm",
+        cox_ph_models=[cox_v1],
+    )
+    lock_plan(STUDY_ID, plan_v1)
+
+    # v2: amendment (cox_ph_models preserved)
+    lock_amendment(
+        STUDY_ID,
+        amendment_reason="Added test",
+        planned_tests=[{"variable_name": "pfs_days", "test_name": "logrank"}],
+    )
+
+    # Verify flowchart reads v2's arm column
+    arm_col = _get_plan_arm_col(STUDY_ID)
+    assert arm_col == "treatment_arm", f"Expected treatment_arm, got {arm_col}"
+
+
+def test_v1_only_reads_v1():
+    """With only v1 locked, both functions should read v1."""
+    _set_state(1)
+
+    cox = CoxPHModel(
+        model_name="pfs_v1",
+        survival_time_col="pfs_days",
+        event_col="pfs_event",
+        primary_treatment_col="treatment_arm",
+        covariate_cols=["age"],
+        rationale="v1 model",
+    )
+    plan = StudyPlan(
+        study_id=STUDY_ID,
+        study_type="cohort",
+        primary_comparison="PFS by arm",
+        cox_ph_models=[cox],
+    )
+    lock_plan(STUDY_ID, plan)
+
+    # Both should read v1
+    forest_plan = forest_latest_plan(STUDY_ID)
+    assert forest_plan["cox_ph_models"][0]["model_name"] == "pfs_v1"
+
+    from core.reporting.flowchart.flowchart import _get_plan_arm_col
+    assert _get_plan_arm_col(STUDY_ID) == "treatment_arm"

tests/test_lineage.py

@@ -0,0 +1,329 @@
+"""Tests for provenance lineage assembly and rendering."""
+
+from __future__ import annotations
+
+import json
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+
+import pytest
+
+from core.database import DATA_ROOT, get_connection, init_db
+from core.reporting.lineage import assemble_events, render_text, render_svg
+
+
+def _setup_minimal_study(study_id: str) -> None:
+    """Create a minimal study: ingest + plan lock only."""
+    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)
+           VALUES (?, ?, ?, ?, ?)""",
+        (study_id, "Minimal study", "2026-01-01T00:00:00.000000+00:00",
+         str(study_dir), 1),
+    )
+    conn.execute(
+        """INSERT INTO variables (study_id, column_name, role, data_type)
+           VALUES (?, ?, ?, ?)""",
+        (study_id, "age", "baseline", "continuous"),
+    )
+    conn.commit()
+
+    # Write plan lock file
+    plan_v1 = {
+        "study_id": study_id,
+        "version": 1,
+        "locked_at": "2026-01-02T00:00:00.000000+00:00",
+        "content_hash": "abc123def456",
+    }
+    lock_path = study_dir / "study_plan.v1.locked.json"
+    lock_path.write_text(json.dumps(plan_v1))
+
+    conn.close()
+
+
+def _setup_full_lifecycle(study_id: str) -> int:
+    """Create a study with full lifecycle: ingest→lock→amend→unmask→post-hoc→analyze→rerun→bundle.
+
+    Returns the ID of the first analysis result (for supersession).
+    """
+    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, "Full lifecycle study", "2026-01-01T00:00:00.000000+00:00",
+         str(study_dir), 2, "2026-03-01T00:00:00.000000+00:00"),
+    )
+    conn.execute(
+        """INSERT INTO variables (study_id, column_name, role, data_type)
+           VALUES (?, ?, ?, ?)""",
+        (study_id, "age", "baseline", "continuous"),
+    )
+    conn.commit()
+
+    # Plan v1 — lock
+    plan_v1 = {
+        "study_id": study_id,
+        "version": 1,
+        "locked_at": "2026-01-02T00:00:00.000000+00:00",
+        "amendment_reason": "",
+        "content_hash": "hash_v1_base",
+    }
+    lock_path = study_dir / "study_plan.v1.locked.json"
+    lock_path.write_text(json.dumps(plan_v1))
+
+    # Plan v2 — pre-unmask amendment
+    plan_v2 = {
+        "study_id": study_id,
+        "version": 2,
+        "locked_at": "2026-01-15T00:00:00.000000+00:00",
+        "amendment_reason": "Added Cox PH model",
+        "content_hash": "hash_v2_amend",
+    }
+    lock_path = study_dir / "study_plan.v2.locked.json"
+    lock_path.write_text(json.dumps(plan_v2))
+
+    # Plan v3 — post-hoc amendment (after unmask)
+    plan_v3 = {
+        "study_id": study_id,
+        "version": 3,
+        "locked_at": "2026-03-02T00:00:00.000000+00:00",
+        "amendment_reason": "Exploratory subgroup analysis",
+        "post_hoc_tests": [{"test_name": "t_test", "variable_name": "age"}],
+        "content_hash": "hash_v3_ph",
+    }
+    lock_path = study_dir / "study_plan.v3.locked.json"
+    lock_path.write_text(json.dumps(plan_v3))
+
+    # Analysis result 1 — pre-registered, will be superseded
+    now = "2026-03-03T00:00:00.000000+00:00"
+    conn.execute(
+        """INSERT INTO analysis_results
+           (study_id, test_name, computed_at, p_value, statistic,
+            status_json, is_pre_registered, study_plan_version,
+            provenance_json, sample_counts_json)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+        (study_id, "chi_square", now, 0.03, 5.2,
+         json.dumps({"status": "completed"}), 1, 1,
+         json.dumps({"plan_version": 1}), json.dumps({"n_analyzed": 100})),
+    )
+    result_id_1 = conn.execute("SELECT last_insert_rowid()").fetchone()[0]
+
+    # Analysis result 2 — cox_ph_model, pre-registered
+    now2 = "2026-03-03T00:00:01.000000+00:00"
+    conn.execute(
+        """INSERT INTO analysis_results
+           (study_id, test_name, computed_at, p_value, statistic,
+            ci_lower, ci_upper, effect_size_json, status_json,
+            is_pre_registered, study_plan_version, provenance_json,
+            sample_counts_json, lr_test_p, concordance_index)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+        (study_id, "cox_ph_model", now2, 0.05, 1.5,
+         0.8, 2.5, json.dumps({"metric": "HR", "value": 1.5}),
+         json.dumps({"status": "completed"}), 1, 2,
+         json.dumps({"plan_version": 2}), json.dumps({"n_analyzed": 100}),
+         0.01, 0.72),
+    )
+    result_id_2 = conn.execute("SELECT last_insert_rowid()").fetchone()[0]
+    conn.commit()
+
+    # Analysis result 3 — rerun of chi_square, supersedes result_id_1
+    now3 = "2026-03-04T00:00:00.000000+00:00"
+    conn.execute(
+        """INSERT INTO analysis_results
+           (study_id, test_name, computed_at, p_value, statistic,
+            status_json, is_pre_registered, study_plan_version,
+            provenance_json, sample_counts_json,
+            superseded_previous_result_id)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+        (study_id, "chi_square", now3, 0.04, 4.8,
+         json.dumps({"status": "completed"}), 1, 1,
+         json.dumps({"plan_version": 1}), json.dumps({"n_analyzed": 100}),
+         result_id_1),
+    )
+    conn.commit()
+
+    # Add covariate rows for cox_ph_model result
+    for cr in [
+        ("treatment_arm", 1.5, 0.8, 2.5, 0.05, 0.4, 0.2, 2.0),
+        ("age", 1.02, 0.95, 1.1, 0.6, 0.02, 0.04, 0.5),
+    ]:
+        conn.execute(
+            """INSERT INTO analysis_covariate_results
+               (result_id, covariate, hr, ci_lower, ci_upper,
+                wald_p, coef, se, z)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+            (result_id_2,) + cr,
+        )
+    conn.commit()
+
+    # Build a fake bundle
+    bundle_path = study_dir / f"{study_id}_bundle.tar.gz"
+    import tarfile, io
+    manifest = {
+        "schema_version": "1.0.0",
+        "study_id": study_id,
+        "generated_at": "2026-03-05T00:00:00.000000+00:00",
+        "composite_hash": "bundle_hash_xyz",
+    }
+    buf = io.BytesIO()
+    with tarfile.open(fileobj=buf, mode="w:gz") as tf:
+        info = tarfile.TarInfo(name="manifest.json")
+        mdata = json.dumps(manifest).encode()
+        info.size = len(mdata)
+        tf.addfile(info, io.BytesIO(mdata))
+    bundle_path.write_bytes(buf.getvalue())
+
+    conn.close()
+    return result_id_1
+
+
+class TestLineageAssembly:
+    """Tests for lineage event assembly."""
+
+    def test_minimal_study_no_crash(self):
+        """Minimal study (ingest + lock only) must not crash or fabricate events."""
+        study_id = "test_lineage_minimal"
+        _setup_minimal_study(study_id)
+
+        events = assemble_events(study_id)
+        assert len(events) > 0
+
+        # Check for honest rendering — no fabricated stages
+        event_types = [e.event_type for e in events]
+        assert "ingest" in event_types
+        assert "plan_lock" in event_types
+        # No unmask if study never unmasked
+        assert "unmask" not in event_types
+        # No bundle if none exists
+        assert "bundle" not in event_types
+        # Seal present at ingest time (not synthesized from plan lock)
+        seals = [e for e in events if e.event_type == "seal"]
+        assert len(seals) == 1
+        assert seals[0].label == "Outcome data sealed (ingest-time masking)"
+
+        # Text render must not crash
+        text = render_text(events)
+        assert "Study provenance DAG" in text
+        assert "Plan locked" in text
+        assert "│" in text
+        assert "ingest-time masking" in text
+
+        # SVG render must not crash
+        svg_path = str(DATA_ROOT / study_id / "test_lineage.svg")
+        render_svg(events, svg_path)
+        assert Path(svg_path).exists()
+        assert Path(svg_path).stat().st_size > 0
+
+        # Cleanup
+        shutil.rmtree(DATA_ROOT / study_id, ignore_errors=True)
+
+    def test_full_lifecycle_all_events_present(self):
+        """Full lifecycle must include all expected event types with correct attributes."""
+        study_id = "test_lineage_full"
+        result_id_1 = _setup_full_lifecycle(study_id)
+
+        events = assemble_events(study_id)
+        event_types = [e.event_type for e in events]
+
+        # All event types present
+        assert "ingest" in event_types
+        assert "variable_classification" in event_types
+        assert "plan_lock" in event_types
+        assert "amendment" in event_types
+        assert "seal" in event_types
+        assert "unmask" in event_types
+        assert "analyze" in event_types
+        assert "bundle" in event_types
+
+        # Two amendments with correct branching
+        amendments = [e for e in events if e.event_type == "amendment"]
+        assert len(amendments) == 2
+        pre_unmask = [e for e in amendments if e.branch == "pre_unmask_amend"]
+        post_hoc = [e for e in amendments if e.branch == "post_hoc_amend"]
+        assert len(pre_unmask) == 1
+        assert len(post_hoc) == 1
+        assert pre_unmask[0].detail.get("reason") == "Added Cox PH model"
+        assert post_hoc[0].detail.get("reason") == "Exploratory subgroup analysis"
+
+        # Plan lock present
+        plan_locks = [e for e in events if e.event_type == "plan_lock"]
+        assert len(plan_locks) == 1
+        assert plan_locks[0].detail.get("version") == 1
+        assert plan_locks[0].detail.get("content_hash") == "hash_v1_base"
+
+        # Three analysis results (chi_square, cox_ph_model, chi_square rerun)
+        analyzes = [e for e in events if e.event_type == "analyze"]
+        assert len(analyzes) == 3
+        assert analyzes[0].detail.get("test_name") in ("chi_square", "cox_ph_model")
+        assert analyzes[2].detail.get("supersedes_result_id") == result_id_1
+
+        # Bundle present
+        bundles = [e for e in events if e.event_type == "bundle"]
+        assert len(bundles) == 1
+        assert bundles[0].detail.get("composite_hash") == "bundle_hash_xyz"
+
+        # Chronological order
+        timestamps = [e.timestamp for e in events if e.timestamp]
+        assert timestamps == sorted(timestamps)
+
+        # Seal appears at ingest time, before any plan lock
+        seal_idx = next(i for i, e in enumerate(events) if e.event_type == "seal")
+        plan_lock_idx = next(i for i, e in enumerate(events) if e.event_type == "plan_lock")
+        classification_idx = next(
+            i for i, e in enumerate(events) if e.event_type == "variable_classification"
+        )
+        # Seal must be between classification and plan lock
+        assert classification_idx < seal_idx < plan_lock_idx, (
+            f"Seal at position {seal_idx} should be between classification "
+            f"({classification_idx}) and plan lock ({plan_lock_idx})"
+        )
+
+        # Text render includes expected content
+        text = render_text(events)
+        assert "CONFIRMATORY" in text
+        assert "EXPLORATORY_POST_HOC" in text
+        assert "supersedes" in text
+        assert "Bundle created" in text
+        assert "│" in text
+        assert "├─" in text
+        assert "ingest-time masking" in text
+
+        # SVG render must not crash
+        svg_path = str(DATA_ROOT / study_id / "test_lineage_full.svg")
+        render_svg(events, svg_path)
+        svg_content = Path(svg_path).read_text()
+        assert "Study Provenance DAG" in svg_content
+        assert "CONFIRMATORY" in svg_content
+        assert "EXPLORATORY_POST_HOC" in svg_content
+        # SVG should have branch connectors (dashed lines) for amendments
+        assert 'stroke-dasharray="3,2"' in svg_content
+        assert "ingest-time masking" in svg_content
+
+        # Cleanup
+        shutil.rmtree(DATA_ROOT / study_id, ignore_errors=True)
+
+    def test_empty_study_returns_empty(self):
+        """Non-existent study must return empty event list without crash."""
+        events = assemble_events("nonexistent_study_id_12345")
+        assert events == []
+
+    def test_no_events_renders_sensibly(self):
+        """Empty events list must render without crash in both formats."""
+        text = render_text([])
+        assert "No provenance data" in text
+
+        svg_path = "/tmp/test_lineage_empty.svg"
+        render_svg([], svg_path)
+        assert Path(svg_path).exists()
+        Path(svg_path).unlink(missing_ok=True)