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

research_tool_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: research-tool-cli
+Version: 0.1.0
+Summary: Retrospective clinical research tool with outcome-masking and provenance
+Requires-Python: >=3.11
+License-File: LICENSE
+Requires-Dist: pandas>=2.0
+Requires-Dist: scipy>=1.11
+Requires-Dist: statsmodels>=0.14
+Requires-Dist: lifelines>=0.27
+Requires-Dist: tableone>=0.8
+Requires-Dist: matplotlib>=3.8
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: fastapi>=0.141.1
+Requires-Dist: uvicorn>=0.52.0
+Dynamic: license-file

research_tool_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,93 @@
+app/backend/_bootstrap.py,sha256=SAx23rcUXwhvKi3lpSpU3mpxbPCBDooNIZy0SBTnSSc,423
+app/backend/main.py,sha256=E5d3ikqABAf3BPR8xe6YlDwtZDiwMm7FSarFYiBN7xE,2456
+app/backend/state.py,sha256=hvM3FkqIfimp1fTzMx-yjnlT3TlbmC8mi0CjRujEjlA,2010
+app/backend/exports/verification_script.py,sha256=hCmuYtWjAJZpqmzm_I9Gog7-otFnI-2ZAVDioFTQEFc,627
+app/backend/routers/__init__.py,sha256=o_veNOEGGrtVNmc2PqvBn3AO2L5w2mBcTJoLlkTlz5E,53
+app/backend/routers/execution.py,sha256=cKRIIeHXanuYXx5BnkkcW7PYrieKjPijJVXw21NYn7s,19442
+app/backend/routers/ingestion.py,sha256=PQrdgP5kVqtSoow2ELmMSxKt7BCqmmkGD4jc6pAPZ_Q,7860
+app/backend/routers/planning.py,sha256=8ZRaNEsdCcBbWUsM4GMB9YLQWYLN2c9vu0FlkogIjUQ,9423
+app/backend/routers/reporting.py,sha256=AY27F0-_PqCGqoXw7xfGibNRFhBrRplppsvtR07T0rk,25191
+core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+core/database.py,sha256=0xrBAMw-FvOE0rLCWaxQBg_kPGcAqP2eDY34uGy3S7c,1767
+core/models.py,sha256=tno6tVGkft6LlMOSsq3BMZXcojJXyyjqWXz4TSh2Nng,4810
+core/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+core/cli/main.py,sha256=JeVPK6ogW92MPqpTV5sf9M3SOIWzW2tjkRWBg5kkzkM,75989
+core/ingestion/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+core/ingestion/csv_loader.py,sha256=_CZZ3cZdXP5lHPPzDClP-4rCGwy7zCfAGM5b25PNB8Q,6772
+core/ingestion/variable_classifier.py,sha256=4km47kjAcKQhmLFcAKjZqYTYivfVEbtU8i3J5vlq6gw,6552
+core/masking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+core/masking/gate.py,sha256=cWm2x-Bq5FiFoc7vxqCUX-LpZb1zXfqj9sW2xDXwhTY,4031
+core/planning/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+core/planning/diagnostics.py,sha256=65d-VQr_dYZlfKzPQ6eLl7qCk0Qx_BBCINufMKn8PhM,3084
+core/planning/lock.py,sha256=PZhIU6dMSpHhuq-FmI4PWrmYfJ41zffBC7-9z5vWXDQ,8476
+core/planning/study_plan.py,sha256=EaJGO9hOR08sK9tMn7fqdcVZ3bbu8SSNIad4z-fBFZU,2685
+core/planning/test_selector.py,sha256=lTZJhKohvsNmgQjpW9ejCt455AsiAkVFoNkM-pPvcVQ,18588
+core/provenance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+core/provenance/hashing.py,sha256=y5fOC7zQCmaBJj1w414_BZcLb7QnfKt0nUkMbo_iDhU,1241
+core/provenance/tracker.py,sha256=Zqqe_ymJarJFrgeDwLeU0bQDttOTnXGkz6kfEi7tsGM,2911
+core/reporting/__init__.py,sha256=g08sAieAAvGwvBH961e2WSQFPXua5xOfvJpnnigHPZU,2210
+core/reporting/appendix.py,sha256=uKLPIj6CHFYRXCx5KnIw5Hd1LYspHpP_9L91dfQ208c,2230
+core/reporting/bundle.py,sha256=qxey3WSy3VMA_IjXbna8LdfnCxg_2tU8qAS08YwA8lg,15935
+core/reporting/excel_export.py,sha256=qGbjqb_t3TfV18-t_sB0eGvU5Tk__1o-XVVeUTQX0ys,27860
+core/reporting/forensics.py,sha256=5B146teYI5aRRjE7oxRJKdu7ov_YIyBsRzq6UTEJkIU,22537
+core/reporting/forest_plot.py,sha256=J46wjwY635K6Zwy1j2s3Zl0_rAUQ4bm-3Q-O4S24Ieo,23868
+core/reporting/lineage.py,sha256=jcausgk7H-Ax4nRCXAR5cMh5IEh3GwBQbhvWXoGsyDE,20007
+core/reporting/manuscript_draft.py,sha256=du-wd2B3ibL-97UvFaD_tPaashepbhLpnC2zAG-Ew5I,35883
+core/reporting/plots.py,sha256=DdGR0hAGfOuNvRTyy2YjCzWjvpS3ofvfzIhZgcIRTvc,20589
+core/reporting/strobe_checklist.py,sha256=VTflC3kuz6LjycOV_st3XtRgbWwBbhcU0MtxqSHbwv4,20142
+core/reporting/flowchart/__init__.py,sha256=rHR7skK22xh-7_ZvDnjd5V_Y4aJB_vvMsJ0TbK1VRO4,396
+core/reporting/flowchart/flowchart.py,sha256=oYwvOOFg3sh2a3NRT4YbYCBnL2ZTmatdjQtejiN5594,21161
+core/stats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+core/stats/descriptive.py,sha256=aKHZOurnmqp9H1tXNyAaYBZKTbP75F9xQVqxy7mbylQ,3155
+core/stats/inferential.py,sha256=27YNhzDgtwMDq7xWkTT0n_PWo-J54xYMic66DsiGyfM,21333
+core/stats/multiple_comparisons.py,sha256=Xf3aWcxC5EUMUeQ5_QLgVzeRYWR3rt2jJ95H3TGKBEQ,1963
+core/stats/post_hoc.py,sha256=e-lvVATgz4r63clz2syHlswmEz7vb2cjqIwmGySFvjQ,1983
+exports/verification_script.py,sha256=hCmuYtWjAJZpqmzm_I9Gog7-otFnI-2ZAVDioFTQEFc,627
+research_tool_cli-0.1.0.dist-info/licenses/LICENSE,sha256=pak0F9cy-IuaMLXFmjYJe9_lIYUf6Et3tRH76enap1A,1070
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/conftest.py,sha256=PrWKP1NK0OVWhhiTxC74tOBRAdBIe3Gh82VAT5nib6Q,1618
+tests/test_amendments.py,sha256=LPFAWwAYnV5ihRgQi6Bzxshe2hBm-CnJ9FJnskxuuV0,11566
+tests/test_analyze_batch_robustness.py,sha256=bX_lMk7LK03FvAXN9soCtTF6AwQAY--0UYEeE49ym24,5965
+tests/test_app_statistical_reporting.py,sha256=ykDimDlo5VaYPSqwWQUssABoUNRB5abRJPWa3edzhXE,16834
+tests/test_benchmark_21.py,sha256=az9odKbxjgQx_TK7_5gdefV54VIrajH-jmzw_lAKOpY,21827
+tests/test_bundle.py,sha256=fCTRjoinAo5Ca2RMdp5nJztYyCfs7Q_S9qiJjNFbV80,9723
+tests/test_cox_ph_plan.py,sha256=EA8wcm6qcjP_inpKSv9Tqhc1j4fzpP2F3Ci9i5YvU98,17828
+tests/test_csv_loader.py,sha256=2_zmuUbT8UnF42ASD9VfVwNhb6c4QcVzSlVubt9Nrrc,11439
+tests/test_end_to_end.py,sha256=-_ndmea7epE2uusaEdv6kmRlyUk2hOWvnWyFY-3K1cQ,12706
+tests/test_excel_export.py,sha256=kR5d-Q1KM2oYhq2e14afptVFcdO5rNPSv2WHcA8Rhz8,6390
+tests/test_flowchart.py,sha256=rihtvXgWq5CyrvQH3PbutU2f_fCe4jXB9Z5x6sbBYsA,10004
+tests/test_forensics.py,sha256=mM4qn_WOjUfmc8zQUHMwjxKl35S6RJhivA18lTuZZrA,11571
+tests/test_forest_plot.py,sha256=L0RVhfCxvg74ufm820T6DmV9_SlJoE4DnRT20rgkyMk,16433
+tests/test_from_json.py,sha256=r99iANNRISku6_HnMimU_1X9fRyf5DjTHv6GNTWXdAE,6209
+tests/test_latest_plan_version.py,sha256=tHNdOkKjBYLvp329jJ9bMZAJ3ltfHiymUq5lzIivMR4,5655
+tests/test_lineage.py,sha256=-E1eS-SgZ8USchIoExv0rw_uXXSNA997n6Tl_f9cSFA,12615
+tests/test_lock_immutability.py,sha256=OEj4vG3bzLnSogZxIiyD0mqRRkQeqvsjJ__rNhhhEcE,4681
+tests/test_m1_fk_violation.py,sha256=Dd6DLBw6wUH-HGKRL8fmL21s29xXoVCbVfcueElgIOM,2828
+tests/test_m2_data_hash_consistency.py,sha256=r8eYDTtMUhJXeKf3DtXAwLPrrYp3sVHY18W96kSATgw,1614
+tests/test_m3_correction_timing.py,sha256=yyFfoimRoPN9_CaftkUwatLa_qNwiLEM3prVzYKtoO0,2602
+tests/test_m4_dedup_field.py,sha256=70dMAT_DGe0rAAmVv7e7avDaNoZJS4r_4KqSe3UEVNg,2400
+tests/test_m5_excel_hash_scope.py,sha256=iAfeOwHGNK-tPQUYOkJgUF7d8hi4wIEI4d8O6bThSxM,1733
+tests/test_m6_fisher_exact_naming.py,sha256=4Xx8KU3nBR6AmAuxrSi7s1UiGh0iN8MVya8JkOLm5Ng,1823
+tests/test_m7_duplicate_study_plan.py,sha256=Ecn5GtfxtSIUelwM2Xj-SMIPhbb06s5wiV122lcYSMk,2054
+tests/test_m8_filter_superseded.py,sha256=Gdr4xcQNeq3F4Osye6yzlg_XdwkHI_I2HFHMzIz75u0,2258
+tests/test_m9_table1_groupby.py,sha256=hAd_rAiIYO0jRvO6bLRG0X8jMfRu2Rqssdya3fmq0lo,2079
+tests/test_manuscript_draft.py,sha256=b_UhPzqf3KwFpjsKFUZTEdL6T4dq_S564pJ45wONd2I,11124
+tests/test_masking_gate.py,sha256=Kcu5JJCmBfjIHnk-rjfH_dSgN1Bok03hZ3JGL7VO5EA,7307
+tests/test_masking_migration.py,sha256=MtSv6fysXUYda4m0DAjmpJwHjNSMgnR8PT44hDHAEJo,4306
+tests/test_multiple_comparisons.py,sha256=pjGbHaxZFehlv4XjVUmaJqXXA6hiYDgRPvsBN-wa1zY,1746
+tests/test_plan_validation.py,sha256=jY65gOlU1WYuq1OH1Nm4FXS0aB2VmD5H2S_tW8MjNS0,10612
+tests/test_plots.py,sha256=wj6ufFjMmYcNfc4_XneLbmT432LFcmV5ILchKAQ8Q9s,16511
+tests/test_post_hoc_tagging.py,sha256=ogXzo3x-ebPGfppJd-MsE1IqeuxAspT5gpy9jmUmqIM,1652
+tests/test_posthoc_analyze.py,sha256=H2SHNskPgJZqfxA7xDDYuata6IcpUCd0wg7lS3hFq6k,7491
+tests/test_provenance_tracker.py,sha256=gvR2PecHWIYywWo8z5K0te3sQLBEqCM31H5wx3nAsoM,3326
+tests/test_roadmap_features.py,sha256=ccdfw6VamQ4qmV1UHapJyr9M9eEG4pz2aet_dGX0aXc,5173
+tests/test_stats_descriptive.py,sha256=ofYKXYCJQx1J-YC7pzCmWMvziH-wQzjVOLOrOthW0n4,2036
+tests/test_stats_inferential.py,sha256=2JO48LCU0NzZYNgwF5v1VJ9tHQqwuC9OsFyWOiGNCF4,14932
+tests/test_strobe_checklist.py,sha256=HavKdMTSuw4CUiZWZuRC90sjGHdTK2sUUIvs5okWrro,6468
+tests/test_test_selector.py,sha256=R8TndFSdYZYOnlgKqWXOZHZWpKRaqx-0zpSZM-7ZRoQ,15000
+tests/test_variable_classifier.py,sha256=rtMSgkEBptQiiWi6_WZ-ILoC05CtBMsBH98g30ltNEM,4605
+research_tool_cli-0.1.0.dist-info/METADATA,sha256=kKA0onLNvpYT4fnbO0_uE3Sys96asB8t3UxaiDy8d_0,481
+research_tool_cli-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+research_tool_cli-0.1.0.dist-info/entry_points.txt,sha256=SX_KdcqEHF-psCnClJXhYtxvR_hv0PTsU4ICVSHKOAY,53
+research_tool_cli-0.1.0.dist-info/top_level.txt,sha256=N6yCvTfFcmNhrHyaC-db76SKeUuBNskl2EXUFGYq8Z4,23
+research_tool_cli-0.1.0.dist-info/RECORD,,

research_tool_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

research_tool_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+research-tool = core.cli.main:main

research_tool_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Manjunath N K
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

research_tool_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+app
+core
+exports
+tests

tests/conftest.py

@@ -0,0 +1,45 @@
+"""Synthetic patient data generator for tests.
+
+Never commits real patient data.  This is the sole source of test data
+for the entire project.
+"""
+
+from __future__ import annotations
+import csv
+import io
+import random
+
+
+def synthetic_patients(n: int = 30, seed: int = 42) -> str:
+    """Return a CSV string of n synthetic patients.
+
+    Schema mimics a retrospective myeloma study:
+      age, sex, iss_stage, prior_lines, high_risk_cytogenetics,
+      treatment_arm, response_category, pfs_days, pfs_event, os_days, os_event
+    """
+    rng = random.Random(seed)
+    rows = [
+        ["age", "sex", "iss_stage", "prior_lines", "high_risk_cytogenetics",
+         "treatment_arm", "response_category", "pfs_days", "pfs_event", "os_days", "os_event"]
+    ]
+    for _ in range(n):
+        age = rng.randint(45, 85)
+        sex = rng.choice(["M", "F"])
+        iss = rng.choice(["I", "II", "III"])
+        prior = rng.randint(0, 6)
+        high_risk = rng.choice(["yes", "no"])
+        arm = rng.choice(["A", "B"])
+        resp = rng.choices(
+            ["CR", "PR", "MR", "SD", "PD"],
+            weights=[15, 30, 20, 20, 15],
+        )[0]
+        pfs_days = max(0, int(rng.expovariate(1 / 300)))
+        pfs_event = 1 if resp in ("PD",) or pfs_days < 200 else rng.choices([0, 1], weights=[40, 60])[0]
+        os_days = max(0, int(rng.expovariate(1 / 500)))
+        os_event = rng.choices([0, 1], weights=[30, 70])[0]
+        rows.append([age, sex, iss, prior, high_risk, arm, resp, pfs_days, pfs_event, os_days, os_event])
+
+    buf = io.StringIO()
+    w = csv.writer(buf)
+    w.writerows(rows)
+    return buf.getvalue()

tests/test_amendments.py

@@ -0,0 +1,296 @@
+"""Tests for the amendment workflow — pre-unmask and post-hoc amendments."""
+
+from __future__ import annotations
+
+import json
+import shutil
+import tempfile
+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
+from core.planning.lock import lock_plan, lock_amendment, load_plan, _next_version
+from core.reporting.manuscript_draft import generate_draft
+
+
+STUDY_ID = "test_amendments"
+
+
+@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, "Amend 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, response TEXT, treatment_arm TEXT)")
+    conn.execute(f"INSERT INTO {raw} (age, response, treatment_arm) VALUES ('65', 'CR', 'A')")
+    conn.execute(f"INSERT INTO {raw} (age, response, treatment_arm) VALUES ('70', 'PR', '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 (?, 'response', '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 _lock_v1():
+    """Lock a simple v1 plan (must be called while still masked)."""
+    plan = StudyPlan(study_id=STUDY_ID, study_type="cohort", primary_comparison="test",
+                     planned_tests=[{"variable_name": "age", "test_name": "t_test"}])
+    lock_plan(STUDY_ID, plan)
+
+
+def _insert_analysis(is_pre_registered: int, p_value: float | None = 0.03,
+                     test_name: str = "chi_square"):
+    conn = get_connection(STUDY_ID)
+    init_db(conn)
+    conn.execute(
+        """INSERT INTO analysis_results
+           (study_id, study_plan_version, variable_ids_used, test_name,
+            statistic, p_value, status_json, is_pre_registered, computed_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+        (STUDY_ID, 1, "[]", test_name, 5.2, p_value,
+         json.dumps({"status": "completed"}),
+         is_pre_registered, "2025-01-01T00:00:00"),
+    )
+    conn.commit()
+    conn.close()
+
+
+# ── Test 1: Pre-unmask amend creates new version ──────────────────────────
+
+def test_pre_unmask_amend_creates_new_version():
+    _set_state(1)  # locked/masked
+    plan = StudyPlan(study_id=STUDY_ID, study_type="cohort", primary_comparison="test",
+                     planned_tests=[{"variable_name": "response", "test_name": "chi_square"}])
+    lock_plan(STUDY_ID, plan)  # v1
+
+    path = lock_amendment(
+        STUDY_ID,
+        amendment_reason="Added t-test",
+        planned_tests=[{"variable_name": "response", "test_name": "t_test"}],
+    )
+    assert "v2" in path.name, f"Expected v2, got {path.name}"
+    # v1 should still exist
+    v1_path = DATA_ROOT / STUDY_ID / "study_plan.v1.locked.json"
+    assert v1_path.exists(), "v1 should still exist"
+
+
+# ── Test 2: Pre-unmask amend refused post-unmask ─────────────────────────
+
+def test_pre_unmask_amend_refused_after_unmask():
+    _lock_v1()
+    _set_state(2)  # unmasked
+    with pytest.raises(RuntimeError, match="already been unmasked"):
+        lock_amendment(
+            STUDY_ID,
+            amendment_reason="Should fail",
+            planned_tests=[{"variable_name": "response", "test_name": "t_test"}],
+        )
+
+
+# ── Test 3: Post-hoc amend refused pre-unmask ────────────────────────────
+
+def test_post_hoc_amend_refused_before_unmask():
+    _set_state(1)  # locked/masked, not unmasked
+    plan = StudyPlan(study_id=STUDY_ID, study_type="cohort", primary_comparison="test",
+                     planned_tests=[{"variable_name": "response", "test_name": "chi_square"}])
+    lock_plan(STUDY_ID, plan)  # v1
+
+    with pytest.raises(RuntimeError, match="before unmasking"):
+        lock_amendment(
+            STUDY_ID,
+            amendment_reason="Should fail",
+            post_hoc_tests=[{"variable_name": "response", "test_name": "t_test"}],
+        )
+
+
+# ── Test 4: Post-hoc result is_pre_registered=0 ──────────────────────────
+
+def test_amend_requires_reason():
+    with pytest.raises(ValueError, match="amendment_reason is required"):
+        lock_amendment(STUDY_ID, amendment_reason="",
+                       planned_tests=[{"variable_name": "response", "test_name": "chi_square"}])
+
+
+# ── Test 5: Draft with post-hoc results MUST contain the header ──────────
+
+def test_draft_with_post_hoc_contains_header():
+    _lock_v1()
+    _set_state(2)
+    _insert_analysis(is_pre_registered=0)  # post-hoc result
+    draft = generate_draft(STUDY_ID)
+    assert "Post-Hoc / Exploratory Analyses" in draft, \
+        "Draft with post-hoc results must contain the post-hoc section header"
+
+
+# ── Test 6: Count disclosure sentence appears ────────────────────────────
+
+def test_count_disclosure_sentence_present():
+    _lock_v1()
+    _set_state(2)
+    _insert_analysis(is_pre_registered=0, p_value=0.03)
+    _insert_analysis(is_pre_registered=0, p_value=0.50, test_name="t_test")
+    draft = generate_draft(STUDY_ID)
+    assert "2 additional post-hoc/exploratory analyses" in draft, \
+        "Should disclose 2 post-hoc analyses"
+    assert "1 of the 2 post-hoc analyses reached p < 0.05" in draft, \
+        "Should disclose 1 significant out of 2"
+    assert "corrected for multiple comparisons within their own family" in draft, \
+        "Should mention separate-family correction"
+
+
+# ── Test 7: No post-hoc results → no post-hoc section ────────────────────
+
+def test_no_post_hoc_no_section():
+    _lock_v1()
+    _set_state(2)
+    _insert_analysis(is_pre_registered=1)  # only pre-registered
+    draft = generate_draft(STUDY_ID)
+    assert "Post-Hoc / Exploratory Analyses" not in draft, \
+        "Should not have post-hoc section when no post-hoc results exist"
+
+
+# ── Test 8: Export JSON contains analysis_summary ────────────────────────
+
+def test_export_contains_analysis_summary():
+    _lock_v1()
+    _set_state(2)
+    _insert_analysis(is_pre_registered=1, p_value=0.02)  # pre-registered
+    _insert_analysis(is_pre_registered=0, p_value=0.03)  # post-hoc
+    draft = generate_draft(STUDY_ID)
+    # The count-disclosure sentence in the Discussion covers this
+    assert "1 additional post-hoc/exploratory analyses" in draft, \
+        "Count disclosure should show 1 post-hoc analysis"
+
+
+def test_lock_plan_still_refuses_after_unmask():
+    """lock_plan() must remain uncallable after unmasking — core HARKing guard."""
+    _lock_v1()
+    _set_state(2)  # unmasked
+    plan = StudyPlan(study_id=STUDY_ID, study_type="cohort", primary_comparison="new test",
+                     planned_tests=[{"variable_name": "response", "test_name": "chi_square"}])
+    with pytest.raises(RuntimeError, match="Cannot lock a plan after unmasking"):
+        lock_plan(STUDY_ID, plan)
+
+
+# ── Test: Amendment preserves cox_ph_models ──────────────────────────────
+
+def test_amendment_preserves_cox_ph_models():
+    """lock_amendment() must carry forward cox_ph_models from the prior plan version."""
+    from core.planning.study_plan import CoxPHModel
+
+    _set_state(1)  # locked/masked
+    cox_model = CoxPHModel(
+        model_name="pfs_model",
+        survival_time_col="pfs_days",
+        event_col="pfs_event",
+        primary_treatment_col="treatment_arm",
+        covariate_cols=["age"],
+        rationale="Test model",
+    )
+    plan = StudyPlan(
+        study_id=STUDY_ID,
+        study_type="cohort",
+        primary_comparison="PFS by arm",
+        planned_tests=[{"variable_name": "response", "test_name": "chi_square"}],
+        cox_ph_models=[cox_model],
+    )
+    lock_plan(STUDY_ID, plan)  # v1
+
+    # Amend: add a new test
+    lock_amendment(
+        STUDY_ID,
+        amendment_reason="Added t-test",
+        planned_tests=[{"variable_name": "response", "test_name": "t_test"}],
+    )
+
+    # Load v2 and verify cox_ph_models survived
+    v2 = load_plan(STUDY_ID, version=2)
+    assert len(v2.cox_ph_models) == 1, \
+        f"Expected 1 cox_ph_model in v2, got {len(v2.cox_ph_models)}"
+    assert v2.cox_ph_models[0].model_name == "pfs_model"
+    assert v2.cox_ph_models[0].event_col == "pfs_event"
+    assert v2.cox_ph_models[0].covariate_cols == ["age"]
+
+
+def test_analyze_dedup_no_rerun():
+    """Analyze must skip tests that already have a completed result."""
+    _lock_v1()
+    _set_state(2)
+    import argparse
+    from core.cli.main import cmd_analyze
+
+    # First analyze — should run
+    ns = argparse.Namespace(study_id=STUDY_ID, force=False, post_hoc=False, rerun=False)
+    cmd_analyze(ns)
+
+    conn = get_connection(STUDY_ID)
+    count1 = conn.execute(
+        "SELECT COUNT(*) as cnt FROM analysis_results WHERE study_id=?", (STUDY_ID,)
+    ).fetchone()["cnt"]
+    conn.close()
+    assert count1 == 1, f"Expected 1 result after first analyze, got {count1}"
+
+    # Second analyze — should skip
+    cmd_analyze(ns)
+
+    conn = get_connection(STUDY_ID)
+    count2 = conn.execute(
+        "SELECT COUNT(*) as cnt FROM analysis_results WHERE study_id=?", (STUDY_ID,)
+    ).fetchone()["cnt"]
+    conn.close()
+    assert count2 == 1, f"Expected still 1 result after skip, got {count2}"
+
+
+def test_analyze_rerun_creates_new_supersedes_old():
+    """--rerun must produce a new result and mark old as superseded."""
+    _lock_v1()
+    _set_state(2)
+    import argparse
+    from core.cli.main import cmd_analyze
+
+    ns = argparse.Namespace(study_id=STUDY_ID, force=False, post_hoc=False, rerun=False)
+    cmd_analyze(ns)
+
+    # Rerun with --rerun
+    ns.rerun = True
+    cmd_analyze(ns)
+
+    conn = get_connection(STUDY_ID)
+    rows = conn.execute(
+        "SELECT id, superseded_previous_result_id FROM analysis_results WHERE study_id=? ORDER BY id",
+        (STUDY_ID,),
+    ).fetchall()
+    conn.close()
+    assert len(rows) == 2, f"Expected 2 rows after rerun, got {len(rows)}"
+    # First row should have NULL superseded (it's the original)
+    assert rows[0]["superseded_previous_result_id"] is None
+    # Second row should point to first
+    assert rows[1]["superseded_previous_result_id"] == rows[0]["id"], \
+        f"Second row should supersede first. Got {rows[1]['superseded_previous_result_id']} vs {rows[0]['id']}"

tests/test_analyze_batch_robustness.py

@@ -0,0 +1,162 @@
+"""Regression tests for analyze batch robustness.
+
+Bug: --test "8:kaplan_meier_logrank:..." stored ID "8" as variable_name,
+but event_col derivation expected column name "pfs_days" → produced "8_event".
+
+Bug: One test failure aborted entire batch — Cox PH never ran.
+"""
+
+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, unmask_study
+from core.planning.study_plan import StudyPlan
+from core.planning.lock import lock_plan, load_plan
+from core.cli.main import cmd_analyze
+import argparse
+
+
+STUDY_ID = "test_batch_robust"
+
+
+@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, "Batch Robust 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)")
+    for i in range(30):
+        arm = "A" if i % 2 == 0 else "B"
+        event = "1" if i % 3 == 0 else "0"
+        conn.execute(f"INSERT INTO {raw} (age, pfs_days, pfs_event, treatment_arm) VALUES (?, ?, ?, ?)",
+                     (str(30 + i), str(100 + i * 5), event, arm))
+    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_var_id_resolved_to_column_name():
+    """Variable ID '8' in --test must resolve to column_name before event_col derivation."""
+    # Get the actual variable ID for pfs_days
+    conn = get_connection(STUDY_ID)
+    row = conn.execute("SELECT id FROM variables WHERE study_id=? AND column_name=?", (STUDY_ID, "pfs_days")).fetchone()
+    conn.close()
+    pfs_var_id = str(row["id"])
+
+    _set_state(1)
+    plan = StudyPlan(
+        study_id=STUDY_ID,
+        study_type="cohort",
+        primary_comparison="PFS by arm",
+        planned_tests=[
+            {"variable_name": pfs_var_id, "test_name": "kaplan_meier_logrank", "rationale": "KM test"},
+        ],
+    )
+    lock_plan(STUDY_ID, plan)
+    _set_state(2)
+    unmask_study(STUDY_ID)
+
+    args = argparse.Namespace(study_id=STUDY_ID, force=False, post_hoc=False, rerun=False)
+    cmd_analyze(args)
+
+    conn = get_connection(STUDY_ID)
+    rows = conn.execute(
+        "SELECT test_name, status_json FROM analysis_results WHERE study_id=?",
+        (STUDY_ID,),
+    ).fetchall()
+    conn.close()
+
+    km_results = [r for r in rows if r["test_name"] == "kaplan_meier_logrank"]
+    assert len(km_results) == 1
+    status = json.loads(km_results[0]["status_json"])
+    # Should succeed, not fail with "8_event not found"
+    assert status["status"] == "completed", f"Expected completed, got {status}"
+
+
+def test_batch_continues_after_test_failure():
+    """One test failure must not abort remaining tests in the batch."""
+    _set_state(1)
+    plan = StudyPlan(
+        study_id=STUDY_ID,
+        study_type="cohort",
+        primary_comparison="PFS by arm",
+        planned_tests=[
+            # This will fail: no event column "nonexistent_event"
+            {"variable_name": "pfs_days", "test_name": "kaplan_meier_logrank", "rationale": "KM test"},
+            # This should still run
+            {"variable_name": "age", "test_name": "t_test", "rationale": "Age comparison"},
+        ],
+    )
+    lock_plan(STUDY_ID, plan)
+    _set_state(2)
+    unmask_study(STUDY_ID)
+
+    # Monkey-patch run_test to simulate failure for KM
+    import core.cli.main as main_mod
+    original_run_test = main_mod.run_test
+
+    def mock_run_test(test_name, data, **kwargs):
+        if test_name == "kaplan_meier_logrank":
+            raise ValueError("Simulated failure: no linked event column")
+        return original_run_test(test_name, data, **kwargs)
+
+    main_mod.run_test = mock_run_test
+    try:
+        args = argparse.Namespace(study_id=STUDY_ID, force=False, post_hoc=False, rerun=False)
+        cmd_analyze(args)
+    finally:
+        main_mod.run_test = original_run_test
+
+    conn = get_connection(STUDY_ID)
+    rows = conn.execute(
+        "SELECT test_name, status_json FROM analysis_results WHERE study_id=?",
+        (STUDY_ID,),
+    ).fetchall()
+    conn.close()
+
+    # Both tests should have results
+    assert len(rows) == 2, f"Expected 2 results, got {len(rows)}"
+
+    km_result = [r for r in rows if r["test_name"] == "kaplan_meier_logrank"][0]
+    ttest_result = [r for r in rows if r["test_name"] == "t_test"][0]
+
+    km_status = json.loads(km_result["status_json"])
+    ttest_status = json.loads(ttest_result["status_json"])
+
+    # KM should be error, t_test should be completed
+    assert km_status["status"] == "error"
+    assert "Simulated failure" in km_status.get("reason", "")
+    assert ttest_status["status"] == "completed"