Restore multimodal rebuild scripts

rebuild/mm_bench/README.md

@@ -0,0 +1,157 @@
+# Rebuilding ClinSeek-MM-Bench
+
+This directory contains the reconstruction scripts for the multimodal part of
+ClinSeek-Bench. The released file `inputs/mm_bench.jsonl` is the source of
+truth for the evaluated `qid`s, questions, labels, and image/report pointers.
+Protected MIMIC-derived patient databases, CXR JPG files, and report text are
+not redistributed. The scripts below use the manifest plus locally downloaded
+PhysioNet/source datasets to rebuild the `data/mm_bench` tree on an authorized
+machine.
+
+The scripts build two artifacts:
+
+1. Source-aligned subsets that preserve each upstream benchmark's own format
+   and pairing metadata for audit.
+2. The ClinSeek-MM-Bench runtime package used by the evaluation code.
+
+The source-aligned subsets are provenance artifacts only. They may include
+upstream labels and listfile metadata, so do not use them as model input.
+Use the final `ClinSeek-MM-Bench` package for evaluation.
+
+## Required source data
+
+Download the following datasets under your own PhysioNet credentials and data
+use agreements:
+
+- MIMIC-IV, latest available local release.
+- MIMIC-CXR, with the `files/` and `mimic-cxr-reports/` folders.
+- MIMIC-CXR-JPG, either v2.0.0 or v2.1.0 layout is acceptable if the JPG files
+  resolve by subject/study/DICOM path.
+- EHRXQA release from PhysioNet, used for the EHRXQA-derived rows.
+- MIMIC-IV-Note is optional for this build; the released EHRXQA rows use CXR
+  report text from MIMIC-CXR.
+
+For MedMod-derived rows, clone the official MedMod repository because the
+scripts verify the released rows against its task listfiles:
+
+```bash
+git clone https://github.com/nyuad-cai/MedMod.git /path/to/MedMod
+```
+
+## Configure paths
+
+Use paths on your machine. The examples below intentionally use placeholders.
+
+```bash
+export CLINSEEK_BENCH=/path/to/ClinSeek-Bench
+export BUILD_ROOT=/path/to/clinseek-mm-rebuild
+
+export EHRXQA_ROOT=/path/to/ehrxqa/1.0.0
+export MIMIC_CXR_ROOT=/path/to/mimic-cxr/2.0.0
+export MIMIC_CXR_JPG_ROOT=/path/to/mimic-cxr-jpg
+export MIMICIV_ROOT=/path/to/mimiciv
+export MIMIC_IV_NOTE_ROOT=/path/to/mimic-iv-note
+
+export MEDMOD_REPO_ROOT=/path/to/MedMod
+```
+
+## Build source-aligned subsets
+
+```bash
+python "$CLINSEEK_BENCH/rebuild/mm_bench/build_ehrxqa_release_original_subset.py" \
+  --input "$CLINSEEK_BENCH/inputs/mm_bench.jsonl" \
+  --output-root "$BUILD_ROOT/source/EHRXQA" \
+  --ehrxqa-root "$EHRXQA_ROOT" \
+  --cxr-root "$MIMIC_CXR_ROOT" \
+  --cxr-jpg-root "$MIMIC_CXR_JPG_ROOT" \
+  --mimiciv-root "$MIMICIV_ROOT" \
+  --mimic-iv-note-root "$MIMIC_IV_NOTE_ROOT" \
+  --overwrite
+
+python "$CLINSEEK_BENCH/rebuild/mm_bench/build_medmod_release_original_subset.py" \
+  --input "$CLINSEEK_BENCH/inputs/mm_bench.jsonl" \
+  --output-root "$BUILD_ROOT/source/MedMod" \
+  --medmod-repo-root "$MEDMOD_REPO_ROOT" \
+  --cxr-jpg-root "$MIMIC_CXR_JPG_ROOT" \
+  --cxr-meta-root "$MIMIC_CXR_ROOT" \
+  --mimiciv-root "$MIMICIV_ROOT" \
+  --overwrite
+```
+
+The MedMod script intentionally rebuilds only the rows present in
+`inputs/mm_bench.jsonl`; it does not rebuild the full MedMod benchmark.
+It also writes audit warnings when a frozen released row differs from the
+script's latest-AP CXR pairing check. These warnings are preserved in metadata;
+use `--strict-official-match` if you want such rows to fail reconstruction.
+
+## Convert to ClinSeek-MM-Bench format
+
+```bash
+python "$CLINSEEK_BENCH/rebuild/mm_bench/build_ehrxqa_clinseek_mm_subset.py" \
+  --original-root "$BUILD_ROOT/source/EHRXQA" \
+  --output-root "$BUILD_ROOT/runtime/EHRXQA" \
+  --overwrite
+
+python "$CLINSEEK_BENCH/rebuild/mm_bench/build_medmod_clinseek_mm_subset.py" \
+  --original-root "$BUILD_ROOT/source/MedMod" \
+  --output-root "$BUILD_ROOT/runtime/MedMod" \
+  --overwrite
+
+python "$CLINSEEK_BENCH/rebuild/mm_bench/combine_clinseek_mm_bench.py" \
+  --reference-input "$CLINSEEK_BENCH/inputs/mm_bench.jsonl" \
+  --ehrxqa-root "$BUILD_ROOT/runtime/EHRXQA" \
+  --medmod-root "$BUILD_ROOT/runtime/MedMod" \
+  --output-root "$BUILD_ROOT/final/ClinSeek-MM-Bench" \
+  --overwrite
+```
+
+The final package will be:
+
+```text
+$BUILD_ROOT/final/ClinSeek-MM-Bench/
+├── inputs/mm_bench.jsonl
+└── data/mm_bench/
+    ├── ehrxqa/
+    └── medmod/
+```
+
+The source-only `inputs/mm_bench.jsonl` does not store pre-rendered
+`input_text`, because that field contains MIMIC-derived EHR table rows. During
+conversion, the scripts render `input_text` locally from the rebuilt patient
+databases and CXR asset pointers.
+
+## Validate
+
+Validate either a local rebuilt package:
+
+```bash
+python "$CLINSEEK_BENCH/rebuild/mm_bench/validate_multimodal_release.py" \
+  --bench-root "$BUILD_ROOT/final/ClinSeek-MM-Bench"
+```
+
+Validate this source-only Hugging Face checkout without requiring protected
+assets:
+
+```bash
+python "$CLINSEEK_BENCH/rebuild/mm_bench/validate_multimodal_release.py" \
+  --bench-root "$CLINSEEK_BENCH" \
+  --manifest-only
+```
+
+If you have a local checkout that also materializes rebuilt assets, you can
+validate by file names in the git tree:
+
+```bash
+python "$CLINSEEK_BENCH/rebuild/mm_bench/validate_multimodal_release.py" \
+  --bench-root "$CLINSEEK_BENCH" \
+  --use-git-tree
+```
+
+Expected release counts:
+
+- 989 total rows.
+- 497 EHRXQA-derived rows and 492 MedMod-derived rows.
+- 165 EHRXQA patient DBs and 395 MedMod patient DBs.
+- 350 EHRXQA JPG files and 477 MedMod JPG files.
+- 356 EHRXQA CXR report text files.
+- 0 missing DB/image/report references.

rebuild/mm_bench/build_ehrxqa_clinseek_mm_subset.py

@@ -0,0 +1,744 @@
+#!/usr/bin/env python3
+"""Convert a source-aligned EHRXQA subset into ClinSeek-MM-Bench format."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import os
+import shutil
+import sqlite3
+import sys
+from collections import Counter
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+SRC_ROOT = REPO_ROOT / "src"
+if str(SRC_ROOT) not in sys.path:
+    sys.path.insert(0, str(SRC_ROOT))
+
+DEFAULT_ORIGINAL_ROOT = Path(
+    os.environ.get(
+        "EHRXQA_ORIGINAL_SUBSET_ROOT",
+        "data/build/ClinSeek-MM-Bench-EHRXQA-source",
+    )
+)
+DEFAULT_OUTPUT_ROOT = Path(
+    os.environ.get(
+        "CLINSEEK_EHRXQA_MM_ROOT",
+        "data/build/ClinSeek-MM-Bench-EHRXQA",
+    )
+)
+
+TIME_COLUMNS = {
+    "admissions": "admittime",
+    "chartevents": "charttime",
+    "cost": "chargetime",
+    "diagnoses_icd": "charttime",
+    "icustays": "intime",
+    "inputevents": "starttime",
+    "labevents": "charttime",
+    "microbiologyevents": "charttime",
+    "outputevents": "charttime",
+    "prescriptions": "starttime",
+    "procedures_icd": "charttime",
+    "tb_cxr": "studydatetime",
+    "transfers": "intime",
+}
+
+LEAKAGE_POLICY = {
+    "sanitize_datetime_columns": True,
+    "mask_future_datetime_columns": True,
+    "row_timestamp_columns": TIME_COLUMNS,
+    "datetime_columns": {
+        "admissions": ["admittime", "dischtime"],
+        "chartevents": ["charttime"],
+        "cost": ["chargetime"],
+        "diagnoses_icd": ["charttime"],
+        "icustays": ["intime", "outtime"],
+        "inputevents": ["starttime"],
+        "labevents": ["charttime"],
+        "microbiologyevents": ["charttime"],
+        "outputevents": ["charttime"],
+        "patients": ["dod"],
+        "prescriptions": ["starttime", "stoptime"],
+        "procedures_icd": ["charttime"],
+        "tb_cxr": ["studydatetime"],
+        "transfers": ["intime", "outtime"],
+    },
+}
+
+REFERENCE_TABLES = {"d_icd_diagnoses", "d_icd_procedures", "d_items", "d_labitems"}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--original-root", type=Path, default=DEFAULT_ORIGINAL_ROOT)
+    parser.add_argument("--output-root", type=Path, default=DEFAULT_OUTPUT_ROOT)
+    parser.add_argument("--asset-prefix", default="EHRXQAOriginalLinked_v1")
+    parser.add_argument("--max-table-rows", type=int, default=80)
+    parser.add_argument(
+        "--render-input-text",
+        action="store_true",
+        help="Render input_text from the rebuilt patient DB instead of preserving the released HF JSONL field.",
+    )
+    parser.add_argument(
+        "--copy-cxr-context",
+        choices=("linked", "all"),
+        default="linked",
+        help="Copy only JSONL-linked assets or all CXR assets packaged by the source-aligned subset.",
+    )
+    parser.add_argument("--overwrite", action="store_true")
+    return parser.parse_args()
+
+
+def ensure_dir(path: Path) -> None:
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def reset_dir(path: Path, overwrite: bool) -> None:
+    if path.exists():
+        if not overwrite:
+            raise FileExistsError(f"Output root already exists: {path}")
+        shutil.rmtree(path)
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def link_or_copy(src: Path, dst: Path) -> None:
+    src = src.resolve()
+    ensure_dir(dst.parent)
+    if dst.exists():
+        return
+    try:
+        os.link(src, dst)
+    except OSError:
+        shutil.copy2(src, dst)
+
+
+def copytree_links(src: Path, dst: Path) -> None:
+    if not src.exists():
+        return
+    if dst.exists():
+        return
+    shutil.copytree(src, dst, copy_function=lambda s, d: (link_or_copy(Path(s), Path(d)) or str(d)))
+
+
+def write_json(path: Path, payload: Any) -> None:
+    ensure_dir(path.parent)
+    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
+def read_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    with path.open("r", encoding="utf-8") as handle:
+        for line in handle:
+            if line.strip():
+                rows.append(json.loads(line))
+    return rows
+
+
+def safe_int(value: Any) -> int | None:
+    if value is None or value == "":
+        return None
+    try:
+        if pd.isna(value):
+            return None
+    except TypeError:
+        pass
+    try:
+        return int(float(str(value).strip()))
+    except ValueError:
+        return None
+
+
+def compact_value(value: Any) -> Any:
+    try:
+        if pd.isna(value):
+            return ""
+    except TypeError:
+        pass
+    if hasattr(value, "isoformat"):
+        return value.isoformat(sep=" ")
+    return value
+
+
+def table_to_text(table_name: str, frame: pd.DataFrame, max_rows: int) -> str:
+    total = len(frame)
+    if total == 0:
+        return f"### {table_name}\nRows visible before cutoff: 0\n"
+    display = frame
+    sort_col = TIME_COLUMNS.get(table_name)
+    if sort_col and sort_col in display.columns:
+        display = display.sort_values(sort_col, kind="stable")
+    if max_rows and len(display) > max_rows:
+        display = display.tail(max_rows)
+        shown = f"latest {len(display)} of {total}"
+    else:
+        shown = f"{total} of {total}"
+    clean = display.copy()
+    for column in clean.columns:
+        clean[column] = clean[column].map(compact_value)
+    return (
+        f"### {table_name}\n"
+        f"Rows visible before cutoff: {total}; rows included below: {shown}\n"
+        f"{clean.to_csv(index=False)}"
+    )
+
+
+def render_ehr_context_from_manager(manager: Any, sample: dict[str, Any], max_table_rows: int) -> str:
+    manager.load_ehr_for_sample(str(sample["subject_id"]), sample["prediction_time"])
+    blocks = []
+    for table_name in sorted(manager.ehr_data):
+        blocks.append(table_to_text(table_name, manager.ehr_data[table_name], max_table_rows))
+    return "\n".join(blocks).strip()
+
+
+def parse_datetime(value: Any) -> pd.Timestamp | None:
+    if value in (None, ""):
+        return None
+    try:
+        parsed = pd.Timestamp(value)
+    except (TypeError, ValueError):
+        return None
+    if pd.isna(parsed):
+        return None
+    return parsed
+
+
+def filter_by_cutoff(table_name: str, frame: pd.DataFrame, cutoff: pd.Timestamp | None) -> pd.DataFrame:
+    if cutoff is None:
+        return frame
+    time_column = TIME_COLUMNS.get(table_name)
+    if not time_column or time_column not in frame.columns:
+        return frame
+    parsed = pd.to_datetime(frame[time_column], errors="coerce")
+    return frame.loc[parsed.notna() & (parsed <= cutoff)].copy()
+
+
+def render_ehr_context(db_path: Path, prediction_time: str, max_table_rows: int) -> str:
+    cutoff = parse_datetime(prediction_time)
+    blocks: list[str] = []
+    with sqlite3.connect(db_path) as conn:
+        table_names = [
+            row[0]
+            for row in conn.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
+        ]
+        for table_name in table_names:
+            frame = pd.read_sql_query(f'SELECT * FROM "{table_name}"', conn)
+            visible = filter_by_cutoff(table_name, frame, cutoff)
+            blocks.append(table_to_text(table_name, visible, max_table_rows))
+    return "\n".join(blocks).strip()
+
+
+def build_input_text(sample: dict[str, Any], image_paths: list[str], ehr_text: str) -> str:
+    return "\n\n".join(
+        [
+            str(sample.get("question") or "").strip(),
+            "<ehr_context>",
+            ehr_text,
+            "</ehr_context>",
+            "<image_inputs>",
+            "\n".join(f"- {path}" for path in image_paths) if image_paths else "NONE",
+            "</image_inputs>",
+        ]
+    )
+
+
+def strip_asset_prefix(path: str) -> str:
+    text = str(path).replace("\\", "/")
+    if "/" in text and text.split("/", 1)[0].endswith("OriginalLinked_v1"):
+        return text.split("/", 1)[1]
+    return text
+
+
+def load_manifest(original_root: Path) -> list[dict[str, Any]]:
+    manifest = original_root / "linked_manifests" / "test.jsonl"
+    if not manifest.exists():
+        raise FileNotFoundError(f"Missing source manifest: {manifest}")
+    return read_jsonl(manifest)
+
+
+def source_tables_dir(original_root: Path) -> Path:
+    path = original_root / "source_release" / "1.0.0" / "ehrxqa" / "database" / "gold"
+    if not path.is_dir():
+        raise FileNotFoundError(f"Missing EHRXQA gold table root: {path}")
+    return path
+
+
+def table_is_reference(table_name: str) -> bool:
+    return table_name in REFERENCE_TABLES or table_name.startswith("d_")
+
+
+def write_frame(conn: sqlite3.Connection, table_name: str, frame: pd.DataFrame, *, append: bool = False) -> None:
+    clean = frame.where(pd.notna(frame), None)
+    clean.to_sql(table_name, conn, if_exists="append" if append else "replace", index=False)
+
+
+def quote_identifier(name: str) -> str:
+    return '"' + name.replace('"', '""') + '"'
+
+
+def list_sqlite_tables(conn: sqlite3.Connection) -> list[str]:
+    return [
+        row[0]
+        for row in conn.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
+    ]
+
+
+def list_attached_sqlite_tables(conn: sqlite3.Connection, schema: str) -> list[str]:
+    q_schema = quote_identifier(schema)
+    return [
+        row[0]
+        for row in conn.execute(f"SELECT name FROM {q_schema}.sqlite_master WHERE type='table' ORDER BY name")
+    ]
+
+
+def sqlite_table_columns(conn: sqlite3.Connection, table_name: str) -> list[str]:
+    return [row[1] for row in conn.execute(f"PRAGMA table_info({quote_identifier(table_name)})")]
+
+
+def source_sqlite_path(original_root: Path) -> Path:
+    return source_tables_dir(original_root) / "mimic_iv_cxr.sqlite"
+
+
+def build_reference_database(tables_dir: Path, output_db: Path) -> list[str]:
+    written: list[str] = []
+    if output_db.exists():
+        output_db.unlink()
+    with sqlite3.connect(output_db) as conn:
+        for csv_path in sorted(tables_dir.glob("*.csv")):
+            table_name = csv_path.stem
+            if not table_is_reference(table_name):
+                continue
+            write_frame(conn, table_name, pd.read_csv(csv_path, low_memory=False))
+            written.append(table_name)
+    return written
+
+
+def create_text_table(
+    conn: sqlite3.Connection,
+    table_name: str,
+    columns: list[str],
+    rows: list[list[Any]],
+) -> None:
+    q_table = quote_identifier(table_name)
+    column_sql = ", ".join(f"{quote_identifier(column)} TEXT" for column in columns)
+    conn.execute(f"CREATE TABLE {q_table} ({column_sql})")
+    if not rows:
+        return
+    placeholders = ", ".join(["?"] * len(columns))
+    conn.executemany(f"INSERT INTO {q_table} VALUES ({placeholders})", rows)
+
+
+def csv_value(value: Any) -> Any:
+    if value is None or value == "":
+        return None
+    return value
+
+
+def build_reference_database_from_csvs(tables_dir: Path, output_db: Path) -> list[str]:
+    written: list[str] = []
+    if output_db.exists():
+        output_db.unlink()
+    with sqlite3.connect(output_db) as conn:
+        for csv_path in sorted(tables_dir.glob("*.csv")):
+            table_name = csv_path.stem
+            if not table_is_reference(table_name):
+                continue
+            with csv_path.open("r", encoding="utf-8", newline="") as handle:
+                reader = csv.reader(handle)
+                columns = next(reader)
+                rows = [[csv_value(value) for value in row] for row in reader]
+            create_text_table(conn, table_name, columns, rows)
+            written.append(table_name)
+        conn.commit()
+    return written
+
+
+def build_patient_databases_from_source_csvs(
+    *,
+    original_root: Path,
+    database_root: Path,
+    subject_ids: set[int],
+) -> dict[str, Any]:
+    tables_dir = source_tables_dir(original_root)
+    subject_lookup = {str(subject_id): subject_id for subject_id in subject_ids}
+    subject_tables: dict[int, list[tuple[str, list[str], list[list[Any]]]]] = {
+        subject_id: [] for subject_id in subject_ids
+    }
+    built_tables: list[str] = []
+    for csv_path in sorted(tables_dir.glob("*.csv")):
+        table_name = csv_path.stem
+        if table_is_reference(table_name):
+            continue
+        with csv_path.open("r", encoding="utf-8", newline="") as handle:
+            reader = csv.DictReader(handle)
+            if not reader.fieldnames or "subject_id" not in reader.fieldnames:
+                continue
+            columns = list(reader.fieldnames)
+            if table_name == "patients":
+                columns = [column for column in columns if column != "dod"]
+            grouped: dict[int, list[list[Any]]] = {}
+            for row in reader:
+                subject_id = subject_lookup.get(str(row.get("subject_id") or ""))
+                if subject_id is None:
+                    continue
+                grouped.setdefault(subject_id, []).append([csv_value(row.get(column)) for column in columns])
+        if not grouped:
+            continue
+        built_tables.append(table_name)
+        for subject_id, rows in grouped.items():
+            subject_tables[subject_id].append((table_name, columns, rows))
+
+    built_subjects = {subject_id for subject_id, tables in subject_tables.items() if tables}
+    missing = sorted(subject_ids - built_subjects)
+    if missing:
+        raise FileNotFoundError(f"Missing built patient DBs for subjects: {missing[:20]}")
+    ensure_dir(database_root)
+    for subject_id, tables in sorted(subject_tables.items()):
+        db_path = database_root / f"patient_{subject_id}.db"
+        if db_path.exists():
+            db_path.unlink()
+        with sqlite3.connect(db_path) as conn:
+            conn.execute("PRAGMA journal_mode=OFF")
+            conn.execute("PRAGMA synchronous=OFF")
+            for table_name, columns, rows in tables:
+                create_text_table(conn, table_name, columns, rows)
+            conn.commit()
+    reference_tables = build_reference_database_from_csvs(tables_dir, database_root / "reference_table.db")
+    return {
+        "patient_db_source": "source_aligned_subset_csv",
+        "source_table_root": "source_release/1.0.0/ehrxqa/database/gold",
+        "built_subjects": len(built_subjects),
+        "built_tables": built_tables,
+        "reference_tables": reference_tables,
+    }
+
+
+def build_reference_database_from_sqlite(source_db: Path, output_db: Path) -> list[str]:
+    written: list[str] = []
+    if output_db.exists():
+        output_db.unlink()
+    with sqlite3.connect(output_db) as conn:
+        conn.execute("ATTACH DATABASE ? AS src", (str(source_db),))
+        for table_name in list_attached_sqlite_tables(conn, "src"):
+            if not table_is_reference(table_name):
+                continue
+            q_table = quote_identifier(table_name)
+            conn.execute(f"CREATE TABLE {q_table} AS SELECT * FROM src.{q_table}")
+            written.append(table_name)
+        conn.commit()
+    return written
+
+
+def build_patient_databases_from_source_sqlite(
+    *,
+    original_root: Path,
+    database_root: Path,
+    subject_ids: set[int],
+) -> dict[str, Any]:
+    source_db = source_sqlite_path(original_root)
+    if not source_db.exists():
+        raise FileNotFoundError(f"Missing EHRXQA source SQLite: {source_db}")
+    ensure_dir(database_root)
+    with sqlite3.connect(source_db) as src_conn:
+        table_names = list_sqlite_tables(src_conn)
+        patient_tables = [
+            table_name
+            for table_name in table_names
+            if not table_is_reference(table_name)
+            and "subject_id" in sqlite_table_columns(src_conn, table_name)
+        ]
+
+    built_subjects = set()
+    for subject_id in sorted(subject_ids):
+        db_path = database_root / f"patient_{subject_id}.db"
+        if db_path.exists():
+            db_path.unlink()
+        with sqlite3.connect(db_path) as dst_conn:
+            dst_conn.execute("PRAGMA journal_mode=OFF")
+            dst_conn.execute("PRAGMA synchronous=OFF")
+            dst_conn.execute("ATTACH DATABASE ? AS src", (str(source_db),))
+            rows_written = 0
+            for table_name in patient_tables:
+                q_table = quote_identifier(table_name)
+                row_count = dst_conn.execute(
+                    f"SELECT COUNT(*) FROM src.{q_table} WHERE subject_id = ?",
+                    (subject_id,),
+                ).fetchone()[0]
+                if row_count == 0:
+                    continue
+                columns = [
+                    row[1]
+                    for row in dst_conn.execute(f"PRAGMA src.table_info({quote_identifier(table_name)})")
+                ]
+                if table_name == "patients":
+                    columns = [column for column in columns if column != "dod"]
+                select_columns = ", ".join(quote_identifier(column) for column in columns)
+                dst_conn.execute(
+                    f"CREATE TABLE {q_table} AS SELECT {select_columns} FROM src.{q_table} WHERE subject_id = ?",
+                    (subject_id,),
+                )
+                rows_written += row_count
+            dst_conn.commit()
+        if rows_written:
+            built_subjects.add(subject_id)
+
+    missing = sorted(subject_ids - built_subjects)
+    if missing:
+        raise FileNotFoundError(f"Missing built patient DBs for subjects: {missing[:20]}")
+    reference_tables = build_reference_database_from_sqlite(source_db, database_root / "reference_table.db")
+    return {
+        "patient_db_source": "source_aligned_subset_sqlite",
+        "source_sqlite": "source_release/1.0.0/ehrxqa/database/gold/mimic_iv_cxr.sqlite",
+        "built_subjects": len(built_subjects),
+        "built_tables": patient_tables,
+        "reference_tables": reference_tables,
+    }
+
+
+def build_patient_databases_from_source(
+    *,
+    original_root: Path,
+    database_root: Path,
+    subject_ids: set[int],
+) -> dict[str, Any]:
+    tables_dir = source_tables_dir(original_root)
+    if any(tables_dir.glob("*.csv")):
+        return build_patient_databases_from_source_csvs(
+            original_root=original_root,
+            database_root=database_root,
+            subject_ids=subject_ids,
+        )
+
+    sqlite_path = source_sqlite_path(original_root)
+    if sqlite_path.exists():
+        return build_patient_databases_from_source_sqlite(
+            original_root=original_root,
+            database_root=database_root,
+            subject_ids=subject_ids,
+        )
+
+    built_tables: list[str] = []
+    subject_frames: dict[int, list[tuple[str, pd.DataFrame]]] = {subject_id: [] for subject_id in subject_ids}
+    for csv_path in sorted(tables_dir.glob("*.csv")):
+        table_name = csv_path.stem
+        if table_is_reference(table_name):
+            continue
+        header = pd.read_csv(csv_path, nrows=0)
+        if "subject_id" not in header.columns:
+            continue
+        built_tables.append(table_name)
+        frame = pd.read_csv(csv_path, low_memory=False)
+        subset = frame[frame["subject_id"].isin(subject_ids)]
+        if subset.empty:
+            continue
+        for subject_id, group in subset.groupby("subject_id", sort=True):
+            subject_frames[int(subject_id)].append((table_name, group.copy()))
+
+    built_subjects = {subject_id for subject_id, frames in subject_frames.items() if frames}
+    missing = sorted(subject_ids - built_subjects)
+    if missing:
+        raise FileNotFoundError(f"Missing built patient DBs for subjects: {missing[:20]}")
+    ensure_dir(database_root)
+    for subject_id, frames in sorted(subject_frames.items()):
+        db_path = database_root / f"patient_{subject_id}.db"
+        if db_path.exists():
+            db_path.unlink()
+        with sqlite3.connect(db_path) as conn:
+            for table_name, frame in frames:
+                write_frame(conn, table_name, frame)
+    reference_tables = build_reference_database(tables_dir, database_root / "reference_table.db")
+    return {
+        "patient_db_source": "source_aligned_subset",
+        "built_subjects": len(built_subjects),
+        "built_tables": built_tables,
+        "reference_tables": reference_tables,
+    }
+
+
+def write_runtime_metadata(bench_root: Path) -> None:
+    write_json(
+        bench_root / "metadata.json",
+        {
+            "package_name": "ClinSeek-MM-Bench-EHRXQA-runtime",
+            "leakage_policy": LEAKAGE_POLICY,
+            "path_contract": {
+                "db_path_hint": "relative_to_benchmark_root",
+                "image_paths": "relative_to_benchmark_root",
+                "report_paths": "relative_to_benchmark_root",
+                "tb_cxr.image_path": "relative_to_benchmark_root",
+                "tb_cxr.report_path": "relative_to_benchmark_root",
+            },
+        },
+    )
+
+
+def copy_linked_assets(original_root: Path, bench_root: Path, row: dict[str, Any]) -> tuple[list[str], list[str]]:
+    rel_images = [strip_asset_prefix(path) for path in row.get("packaged_image_relpaths") or []]
+    rel_reports = [strip_asset_prefix(path) for path in row.get("packaged_report_relpaths") or []]
+    for relpath in rel_images + rel_reports:
+        link_or_copy(original_root / relpath, bench_root / relpath)
+    return rel_images, rel_reports
+
+
+def copy_all_cxr_context(original_root: Path, bench_root: Path) -> None:
+    copytree_links(original_root / "mimic-cxr", bench_root / "mimic-cxr")
+
+
+def write_table_descriptions(bench_root: Path) -> None:
+    dst = bench_root / "table_description"
+    ensure_dir(dst)
+    (dst / "link_information.json").write_text("", encoding="utf-8")
+    (dst / "shorten_description.json").write_text("", encoding="utf-8")
+
+
+def main() -> None:
+    args = parse_args()
+    reset_dir(args.output_root, args.overwrite)
+    manifest_rows = load_manifest(args.original_root)
+
+    bench_root = args.output_root / "data" / "mm_bench" / "ehrxqa"
+    database_root = bench_root / "database"
+    inputs_root = args.output_root / "inputs"
+    ensure_dir(database_root)
+    ensure_dir(inputs_root)
+
+    by_subject: dict[int, dict[str, Any]] = {}
+    for row in manifest_rows:
+        subject_id = safe_int(row.get("subject_id"))
+        if subject_id is None:
+            raise ValueError(f"Missing subject_id: {row.get('qid')}")
+        by_subject.setdefault(subject_id, row)
+
+    db_build_summary = build_patient_databases_from_source(
+        original_root=args.original_root,
+        database_root=database_root,
+        subject_ids=set(by_subject),
+    )
+    write_table_descriptions(bench_root)
+    ehr_manager_root = bench_root
+    write_runtime_metadata(bench_root)
+
+    if args.copy_cxr_context == "all":
+        copy_all_cxr_context(args.original_root, bench_root)
+
+    ehr_manager = None
+    need_rendered_input_text = args.render_input_text or any(
+        not row.get("released_input_text") for row in manifest_rows
+    )
+    if need_rendered_input_text:
+        try:
+            from agentlite.commons.EHRManager import EHRManager  # type: ignore
+
+            ehr_manager = EHRManager(str(ehr_manager_root))
+        except Exception as exc:  # pragma: no cover - fallback for portable envs
+            print({"ehr_manager_unavailable": repr(exc)}, flush=True)
+    output_rows: list[dict[str, Any]] = []
+    stats = Counter()
+    linked_image_count = 0
+    linked_report_count = 0
+    for index, row in enumerate(manifest_rows):
+        rel_images, rel_reports = copy_linked_assets(args.original_root, bench_root, row)
+        linked_image_count += len(rel_images)
+        linked_report_count += len(rel_reports)
+        prefixed_images = [f"{args.asset_prefix}/{relpath}" for relpath in rel_images]
+        prefixed_reports = [f"{args.asset_prefix}/{relpath}" for relpath in rel_reports]
+        if args.render_input_text or not row.get("released_input_text"):
+            if ehr_manager is not None:
+                ehr_text = render_ehr_context_from_manager(ehr_manager, row, args.max_table_rows)
+            else:
+                subject_id = safe_int(row.get("subject_id"))
+                if subject_id is None:
+                    raise ValueError(f"Missing subject_id: {row.get('qid')}")
+                ehr_text = render_ehr_context(
+                    database_root / f"patient_{subject_id}.db",
+                    str(row.get("prediction_time")),
+                    args.max_table_rows,
+                )
+            input_text = build_input_text(row, prefixed_images, ehr_text)
+        else:
+            input_text = row.get("released_input_text")
+        output_rows.append(
+            {
+                "qid": row.get("qid"),
+                "source_index": row.get("source_index"),
+                "source_benchmark": "ehrxqa",
+                "task": row.get("task"),
+                "source_split": row.get("source_split"),
+                "subject_id": row.get("subject_id"),
+                "hadm_id": row.get("hadm_id"),
+                "stay_id": row.get("stay_id"),
+                "prediction_time": row.get("prediction_time"),
+                "question": row.get("question"),
+                "input_text": input_text,
+                "image_paths": prefixed_images,
+                "report_paths": prefixed_reports,
+                "ground_truth": row.get("ground_truth"),
+                "answer_type": row.get("answer_type"),
+                "modalities": row.get("modalities") or ["cxr_table", "cxr_image"],
+            }
+        )
+        stats[f"task:{row.get('task')}"] += 1
+        if (index + 1) % 100 == 0:
+            print({"rendered_rows": index + 1, "total": len(manifest_rows)}, flush=True)
+
+    output_path = inputs_root / "mm_bench_ehrxqa.jsonl"
+    with output_path.open("w", encoding="utf-8") as handle:
+        for row in output_rows:
+            handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n")
+
+    metadata = {
+        "package_name": "ClinSeek-MM-Bench-EHRXQA",
+        "original_root": "EHRXQA_ORIGINAL_SUBSET_ROOT",
+        "records": len(output_rows),
+        "subjects": len(by_subject),
+        "patient_dbs": len(list(database_root.glob("patient_*.db"))),
+        "db_build_summary": db_build_summary,
+        "unique_linked_images": len({p for row in output_rows for p in row["image_paths"]}),
+        "unique_linked_reports": len({p for row in output_rows for p in row["report_paths"]}),
+        "linked_image_refs": linked_image_count,
+        "linked_report_refs": linked_report_count,
+        "copy_cxr_context": args.copy_cxr_context,
+        "input_text_source": "rendered_from_db" if need_rendered_input_text else "released_hf_jsonl",
+        "input_file": "inputs/mm_bench_ehrxqa.jsonl",
+        "bench_root": "data/mm_bench/ehrxqa",
+        "asset_prefix": args.asset_prefix,
+        "stats": dict(sorted(stats.items())),
+        "path_contract": {
+            "image_paths": "strip asset_prefix, then resolve relative to bench_root",
+            "report_paths": "strip asset_prefix, then resolve relative to bench_root",
+            "patient_db": "data/mm_bench/ehrxqa/database/patient_<subject_id>.db",
+        },
+        "leakage_policy": {
+            "ground_truth": "kept only in output JSONL field, never in input_text",
+            "patient_db_source": db_build_summary.get("patient_db_source"),
+            "runtime_policy": "EHRManager uses benchmark metadata leakage_policy at load time",
+        },
+    }
+    write_json(args.output_root / "metadata.json", metadata)
+
+    readme = """# ClinSeek-MM-Bench-EHRXQA
+
+This directory contains the EHRXQA-derived portion of ClinSeek-MM-Bench.
+
+Use:
+
+- `inputs/mm_bench_ehrxqa.jsonl`
+- `data/mm_bench/ehrxqa`
+
+The JSONL contains both agentic fields (`question`, `image_paths`, `subject_id`)
+and curated-input fields (`input_text`, `image_paths`).  Patient SQLite DBs are
+under `data/mm_bench/ehrxqa/database`.
+"""
+    (args.output_root / "README.md").write_text(readme, encoding="utf-8")
+    print(json.dumps(metadata, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

rebuild/mm_bench/build_ehrxqa_release_original_subset.py

@@ -0,0 +1,570 @@
+#!/usr/bin/env python3
+"""Build the source-aligned EHRXQA subset used by ClinSeek MM-Bench.
+
+This script rebuilds only the EHRXQA rows present in the released
+inputs/mm_bench.jsonl.  It keeps the official EHRXQA schema, writes subset
+CSV/SQLite tables, and packages the CXR files needed by the selected patients
+using relative paths.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shutil
+import sqlite3
+from collections import Counter
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+
+
+DEFAULT_INPUT = Path(
+    os.environ.get(
+        "CLINSEEK_MM_BENCH_JSONL",
+        "data/ClinSeek-Bench/inputs/mm_bench.jsonl",
+    )
+)
+DEFAULT_OUTPUT_ROOT = Path(
+    os.environ.get(
+        "EHRXQA_ORIGINAL_SUBSET_ROOT",
+        "data/build/ClinSeek-MM-Bench-EHRXQA-source",
+    )
+)
+DEFAULT_EHRXQA_ROOT = Path(
+    os.environ.get("EHRXQA_ROOT", "external/ehrxqa/1.0.0")
+)
+DEFAULT_CXR_ROOT = Path(
+    os.environ.get("MIMIC_CXR_ROOT", "external/mimic-cxr/2.0.0")
+)
+DEFAULT_CXR_JPG_ROOT = Path(
+    os.environ.get("MIMIC_CXR_JPG_ROOT", "external/mimic-cxr-jpg")
+)
+DEFAULT_MIMICIV_ROOT = Path(os.environ.get("MIMICIV_ROOT", "external/mimiciv/3.1"))
+DEFAULT_MIMIC_IV_NOTE_ROOT = Path(
+    os.environ.get("MIMIC_IV_NOTE_ROOT", "external/mimic-iv-note/2.2")
+)
+
+QID_RE = re.compile(r"^ehrxqa_(?P<split>[a-zA-Z0-9-]+)_(?P<source_id>\d+)$")
+IMAGE_RE = re.compile(
+    r"(?:^|/)files/p\d+/p(?P<subject_id>\d+)/s(?P<study_id>\d+)/(?P<dicom_id>[^/]+)\.jpg$"
+)
+
+REFERENCE_TABLE_PREFIXES = ("d_",)
+REFERENCE_TABLES = {"d_icd_diagnoses", "d_icd_procedures", "d_items", "d_labitems"}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--input", type=Path, default=DEFAULT_INPUT)
+    parser.add_argument("--output-root", type=Path, default=DEFAULT_OUTPUT_ROOT)
+    parser.add_argument("--ehrxqa-root", type=Path, default=DEFAULT_EHRXQA_ROOT)
+    parser.add_argument(
+        "--cxr-root",
+        type=Path,
+        default=DEFAULT_CXR_ROOT,
+        help="MIMIC-CXR root containing files/ and mimic-cxr-reports/.",
+    )
+    parser.add_argument(
+        "--cxr-jpg-root",
+        type=Path,
+        default=DEFAULT_CXR_JPG_ROOT,
+        help="Optional MIMIC-CXR-JPG root or flat mimic-cxr2 export used as an image fallback.",
+    )
+    parser.add_argument("--mimiciv-root", type=Path, default=DEFAULT_MIMICIV_ROOT)
+    parser.add_argument(
+        "--mimic-iv-note-root",
+        type=Path,
+        default=DEFAULT_MIMIC_IV_NOTE_ROOT,
+        help="Optional MIMIC-IV-Note root kept for provenance; this EHRXQA build uses CXR report TXT files.",
+    )
+    parser.add_argument("--overwrite", action="store_true")
+    parser.add_argument(
+        "--allow-missing-nonlinked-assets",
+        action="store_true",
+        help=(
+            "Deprecated compatibility flag. Non-linked patient-context CXR assets "
+            "are optional; linked benchmark assets are still required."
+        ),
+    )
+    return parser.parse_args()
+
+
+def ensure_dir(path: Path) -> None:
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def reset_dir(path: Path, overwrite: bool) -> None:
+    if path.exists():
+        if not overwrite:
+            raise FileExistsError(f"Output root already exists: {path}")
+        shutil.rmtree(path)
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def link_or_copy(src: Path, dst: Path) -> None:
+    src = src.resolve()
+    ensure_dir(dst.parent)
+    if dst.exists():
+        return
+    try:
+        os.link(src, dst)
+    except OSError:
+        shutil.copy2(src, dst)
+
+
+def write_json(path: Path, payload: Any, *, compact: bool = False) -> None:
+    ensure_dir(path.parent)
+    kwargs = {"ensure_ascii": False}
+    if not compact:
+        kwargs["indent"] = 2
+    path.write_text(json.dumps(payload, **kwargs) + "\n", encoding="utf-8")
+
+
+def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
+    ensure_dir(path.parent)
+    with path.open("w", encoding="utf-8") as handle:
+        for row in rows:
+            handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n")
+
+
+def safe_int(value: Any) -> int | None:
+    if value is None or value == "":
+        return None
+    try:
+        if pd.isna(value):
+            return None
+    except TypeError:
+        pass
+    try:
+        return int(float(str(value).strip()))
+    except ValueError:
+        return None
+
+
+def normalize_ehrxqa_root(path: Path) -> tuple[Path, Path]:
+    """Return (release_root, ehrxqa_dir)."""
+    if (path / "ehrxqa" / "dataset").is_dir():
+        return path, path / "ehrxqa"
+    if (path / "dataset").is_dir() and (path / "database").is_dir():
+        return path.parent, path
+    raise FileNotFoundError(
+        f"Could not find EHRXQA dataset/database under {path}. "
+        "Pass either the 1.0.0 root or the 1.0.0/ehrxqa directory."
+    )
+
+
+def load_release_rows(input_path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    with input_path.open("r", encoding="utf-8") as handle:
+        for line_index, line in enumerate(handle):
+            if not line.strip():
+                continue
+            row = json.loads(line)
+            if row.get("source_benchmark") != "ehrxqa":
+                continue
+            match = QID_RE.match(str(row.get("qid") or ""))
+            if not match:
+                raise ValueError(f"Cannot parse EHRXQA qid: {row.get('qid')}")
+            row["_source_line_index"] = line_index
+            row["_source_split_from_qid"] = match.group("split")
+            row["_source_id_from_qid"] = int(match.group("source_id"))
+            rows.append(row)
+    return rows
+
+
+def strip_asset_prefix(path: str) -> str:
+    text = path.replace("\\", "/")
+    if "/" in text and text.split("/", 1)[0].endswith("OriginalLinked_v1"):
+        return text.split("/", 1)[1]
+    return text
+
+
+def parse_image_ref(path: str) -> dict[str, Any]:
+    stripped = strip_asset_prefix(path)
+    match = IMAGE_RE.search(stripped)
+    if not match:
+        raise ValueError(f"Cannot parse EHRXQA image path: {path}")
+    subject_id = int(match.group("subject_id"))
+    study_id = int(match.group("study_id"))
+    dicom_id = match.group("dicom_id")
+    nested_relpath = (
+        f"mimic-cxr/2.0.0/files/p{str(subject_id)[:2]}/p{subject_id}/"
+        f"s{study_id}/{dicom_id}.jpg"
+    )
+    report_relpath = (
+        f"mimic-cxr/2.0.0/mimic-cxr-reports/files/p{str(subject_id)[:2]}/"
+        f"p{subject_id}/s{study_id}.txt"
+    )
+    return {
+        "subject_id": subject_id,
+        "study_id": study_id,
+        "dicom_id": dicom_id,
+        "image_relpath": nested_relpath,
+        "report_relpath": report_relpath,
+    }
+
+
+def nested_file_relpath(subject_id: int, study_id: int, dicom_id: str) -> str:
+    return (
+        f"mimic-cxr/2.0.0/files/p{str(subject_id)[:2]}/p{subject_id}/"
+        f"s{study_id}/{dicom_id}.jpg"
+    )
+
+
+def nested_report_relpath(subject_id: int, study_id: int) -> str:
+    return (
+        f"mimic-cxr/2.0.0/mimic-cxr-reports/files/p{str(subject_id)[:2]}/"
+        f"p{subject_id}/s{study_id}.txt"
+    )
+
+
+def find_cxr_image(
+    cxr_root: Path,
+    cxr_jpg_root: Path,
+    subject_id: int,
+    study_id: int,
+    dicom_id: str,
+) -> Path | None:
+    nested = Path(nested_file_relpath(subject_id, study_id, dicom_id)).relative_to("mimic-cxr/2.0.0")
+    flat_name = f"p{str(subject_id)[:2]}_p{subject_id}_s{study_id}_{dicom_id}.jpg"
+    candidates = [
+        cxr_root / nested,
+        cxr_root / "files" / nested.relative_to("files"),
+        cxr_root / "mimic-cxr" / "2.0.0" / nested,
+        cxr_root / "2.0.0" / nested,
+        cxr_root / "2.1.0" / nested,
+        cxr_root / "2.1.0-lite" / nested,
+        cxr_root / "2.1.0-working-subset" / nested,
+        cxr_root / "mimic-cxr2" / flat_name,
+        cxr_root / flat_name,
+        cxr_jpg_root / nested,
+        cxr_jpg_root / "files" / nested.relative_to("files"),
+        cxr_jpg_root / "2.0.0" / nested,
+        cxr_jpg_root / "2.1.0" / nested,
+        cxr_jpg_root / "2.1.0-lite" / nested,
+        cxr_jpg_root / "2.1.0-working-subset" / nested,
+        cxr_jpg_root / "mimic-cxr2" / flat_name,
+        cxr_jpg_root / flat_name,
+    ]
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+    return None
+
+
+def find_cxr_report(cxr_root: Path, subject_id: int, study_id: int) -> Path | None:
+    nested = Path(nested_report_relpath(subject_id, study_id)).relative_to("mimic-cxr/2.0.0")
+    candidates = [
+        cxr_root / nested,
+        cxr_root / "mimic-cxr-reports" / nested.relative_to("mimic-cxr-reports"),
+        cxr_root / "mimic-cxr" / "2.0.0" / nested,
+        cxr_root / "2.0.0" / nested,
+    ]
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+    return None
+
+
+def table_is_reference(table_name: str) -> bool:
+    return table_name in REFERENCE_TABLES or table_name.startswith(REFERENCE_TABLE_PREFIXES)
+
+
+def load_source_records(ehrxqa_dir: Path, split: str, source_ids: set[int]) -> dict[int, dict[str, Any]]:
+    path = ehrxqa_dir / "dataset" / f"{split}.json"
+    rows = json.loads(path.read_text(encoding="utf-8"))
+    by_id = {int(row["id"]): row for row in rows if int(row["id"]) in source_ids}
+    missing = sorted(source_ids - set(by_id))
+    if missing:
+        raise ValueError(f"Missing EHRXQA source ids in {path}: {missing[:20]}")
+    return by_id
+
+
+def load_tb_cxr(
+    table_path: Path,
+    selected_subjects: set[int],
+    cxr_root: Path,
+    cxr_jpg_root: Path,
+) -> pd.DataFrame:
+    frame = pd.read_csv(table_path)
+    frame = frame[frame["subject_id"].isin(selected_subjects)].copy()
+    frame = frame.where(pd.notna(frame), None)
+    image_paths: list[str | None] = []
+    report_paths: list[str | None] = []
+    for row in frame.to_dict(orient="records"):
+        subject_id = safe_int(row.get("subject_id"))
+        study_id = safe_int(row.get("study_id"))
+        dicom_id = str(row.get("image_id") or "").strip()
+        if subject_id is None or study_id is None or not dicom_id:
+            image_paths.append(None)
+            report_paths.append(None)
+            continue
+        image_paths.append(
+            nested_file_relpath(subject_id, study_id, dicom_id)
+            if find_cxr_image(cxr_root, cxr_jpg_root, subject_id, study_id, dicom_id) is not None
+            else None
+        )
+        report_paths.append(nested_report_relpath(subject_id, study_id))
+    frame["image_path"] = image_paths
+    frame["report_path"] = report_paths
+    return frame
+
+
+def write_subset_tables(
+    *,
+    source_tables_dir: Path,
+    output_tables_dir: Path,
+    selected_subjects: set[int],
+    selected_tb_cxr: pd.DataFrame,
+) -> list[str]:
+    ensure_dir(output_tables_dir)
+    written: list[str] = []
+    for csv_path in sorted(source_tables_dir.glob("*.csv")):
+        table_name = csv_path.stem
+        if table_name == "tb_cxr":
+            frame = selected_tb_cxr
+        else:
+            header = pd.read_csv(csv_path, nrows=0)
+            if table_is_reference(table_name) or "subject_id" not in header.columns:
+                frame = pd.read_csv(csv_path)
+            else:
+                chunks = []
+                for chunk in pd.read_csv(csv_path, chunksize=200_000):
+                    chunks.append(chunk[chunk["subject_id"].isin(selected_subjects)])
+                frame = pd.concat(chunks, ignore_index=True) if chunks else header
+        frame = frame.where(pd.notna(frame), None)
+        out_path = output_tables_dir / csv_path.name
+        frame.to_csv(out_path, index=False)
+        written.append(table_name)
+    for extra_name in ("mimic_iv_cxr.sql", "index.html"):
+        src = source_tables_dir / extra_name
+        if src.exists():
+            link_or_copy(src, output_tables_dir / extra_name)
+    return written
+
+
+def write_sqlite_from_csvs(tables_dir: Path, sqlite_path: Path) -> None:
+    if sqlite_path.exists():
+        sqlite_path.unlink()
+    with sqlite3.connect(sqlite_path) as conn:
+        for csv_path in sorted(tables_dir.glob("*.csv")):
+            frame = pd.read_csv(csv_path)
+            frame = frame.where(pd.notna(frame), None)
+            frame.to_sql(csv_path.stem, conn, if_exists="replace", index=False)
+
+
+def copy_asset(src: Path | None, dst: Path, *, required: bool, label: str) -> bool:
+    if src is None:
+        if required:
+            raise FileNotFoundError(f"Missing required {label}: {dst}")
+        return False
+    link_or_copy(src, dst)
+    return True
+
+
+def main() -> None:
+    args = parse_args()
+    reset_dir(args.output_root, args.overwrite)
+
+    release_root, ehrxqa_dir = normalize_ehrxqa_root(args.ehrxqa_root)
+    rows = load_release_rows(args.input)
+    if not rows:
+        raise ValueError(f"No EHRXQA rows found in {args.input}")
+
+    split_ids: dict[str, set[int]] = {}
+    for row in rows:
+        split_ids.setdefault(row["_source_split_from_qid"], set()).add(row["_source_id_from_qid"])
+    if set(split_ids) != {"test"}:
+        raise ValueError(f"This release subset expects only EHRXQA test rows, got {sorted(split_ids)}")
+    source_by_id = load_source_records(ehrxqa_dir, "test", split_ids["test"])
+
+    linked_study_ids: set[int] = set()
+    linked_image_refs: dict[tuple[int, int, str], dict[str, Any]] = {}
+    for row in rows:
+        for image_path in row.get("image_paths") or []:
+            ref = parse_image_ref(image_path)
+            linked_study_ids.add(ref["study_id"])
+            linked_image_refs[(ref["subject_id"], ref["study_id"], ref["dicom_id"])] = ref
+
+    selected_subjects = {int(row["subject_id"]) for row in rows}
+    source_tables_dir = ehrxqa_dir / "database" / "gold"
+    selected_tb_cxr = load_tb_cxr(
+        source_tables_dir / "tb_cxr.csv",
+        selected_subjects,
+        args.cxr_root,
+        args.cxr_jpg_root,
+    )
+    tb_cxr_by_study = {
+        int(record["study_id"]): record
+        for record in selected_tb_cxr.to_dict(orient="records")
+        if safe_int(record.get("study_id")) is not None
+    }
+
+    output_ehrxqa_dir = args.output_root / "source_release" / "1.0.0" / "ehrxqa"
+    output_dataset_dir = output_ehrxqa_dir / "dataset"
+    output_tables_dir = output_ehrxqa_dir / "database" / "gold"
+    subset_source_rows = [source_by_id[row["_source_id_from_qid"]] for row in rows]
+    write_json(output_dataset_dir / "test.json", subset_source_rows)
+    written_tables = write_subset_tables(
+        source_tables_dir=source_tables_dir,
+        output_tables_dir=output_tables_dir,
+        selected_subjects=selected_subjects,
+        selected_tb_cxr=selected_tb_cxr,
+    )
+    sqlite_relpath = "source_release/1.0.0/ehrxqa/database/gold/mimic_iv_cxr.sqlite"
+    write_sqlite_from_csvs(output_tables_dir, args.output_root / sqlite_relpath)
+
+    for rel in ("index.html", "LICENSE.txt", "SHA256SUMS.txt"):
+        src = release_root / rel
+        if src.exists():
+            link_or_copy(src, args.output_root / "source_release" / "1.0.0" / rel)
+
+    copied_images = 0
+    copied_reports = 0
+    missing_nonlinked_assets = 0
+    asset_rows = selected_tb_cxr.to_dict(orient="records")
+    for asset_row in asset_rows:
+        subject_id = safe_int(asset_row.get("subject_id"))
+        study_id = safe_int(asset_row.get("study_id"))
+        dicom_id = str(asset_row.get("image_id") or "").strip()
+        if subject_id is None or study_id is None or not dicom_id:
+            continue
+        linked = (subject_id, study_id, dicom_id) in linked_image_refs
+        image_rel = nested_file_relpath(subject_id, study_id, dicom_id)
+        report_rel = nested_report_relpath(subject_id, study_id)
+        image_src = find_cxr_image(args.cxr_root, args.cxr_jpg_root, subject_id, study_id, dicom_id)
+        report_src = find_cxr_report(args.cxr_root, subject_id, study_id)
+        if copy_asset(image_src, args.output_root / image_rel, required=linked, label="CXR image"):
+            copied_images += 1
+        else:
+            missing_nonlinked_assets += 1
+        if copy_asset(report_src, args.output_root / report_rel, required=linked, label="CXR report"):
+            copied_reports += 1
+        else:
+            missing_nonlinked_assets += 1
+
+    manifest_rows: list[dict[str, Any]] = []
+    for row in rows:
+        source_id = row["_source_id_from_qid"]
+        source_row = source_by_id[source_id]
+        packaged_images = [strip_asset_prefix(path) for path in row.get("image_paths") or []]
+        packaged_reports = [strip_asset_prefix(path) for path in row.get("report_paths") or []]
+        study_ids = []
+        dicom_ids = []
+        raw_images = []
+        raw_reports = []
+        for image_path in packaged_images:
+            ref = parse_image_ref(image_path)
+            study_ids.append(ref["study_id"])
+            dicom_ids.append(ref["dicom_id"])
+            raw_images.append(str(Path("files") / Path(ref["image_relpath"]).relative_to("mimic-cxr/2.0.0/files")))
+        for report_path in packaged_reports:
+            raw_reports.append(
+                str(Path("mimic-cxr-reports") / Path(report_path).relative_to("mimic-cxr/2.0.0/mimic-cxr-reports"))
+            )
+        manifest_rows.append(
+            {
+                "qid": row.get("qid"),
+                "source_line_index": row.get("_source_line_index"),
+                "source_index": row.get("source_index"),
+                "source_benchmark": "ehrxqa",
+                "task": row.get("task"),
+                "source_split": row.get("source_split"),
+                "source_id": source_id,
+                "variant": "gold",
+                "subject_id": row.get("subject_id"),
+                "hadm_id": row.get("hadm_id"),
+                "stay_id": row.get("stay_id"),
+                "prediction_time": row.get("prediction_time"),
+                "question": row.get("question"),
+                "released_input_text": row.get("input_text"),
+                "source_question": source_row.get("question"),
+                "source_sql": source_row.get("query"),
+                "source_template": source_row.get("template"),
+                "source_value": source_row.get("value"),
+                "source_answer": source_row.get("answer"),
+                "ground_truth": row.get("ground_truth"),
+                "answer_type": row.get("answer_type"),
+                "modalities": row.get("modalities") or ["cxr_table", "cxr_image"],
+                "study_ids": study_ids,
+                "dicom_ids": dicom_ids,
+                "packaged_db_relpath": sqlite_relpath,
+                "packaged_table_root_relpath": "source_release/1.0.0/ehrxqa/database/gold",
+                "packaged_image_relpaths": packaged_images,
+                "packaged_report_relpaths": packaged_reports,
+                "raw_image_source_relpaths": raw_images,
+                "raw_report_source_relpaths": raw_reports,
+                "source_dataset_relpath": "source_release/1.0.0/ehrxqa/dataset/test.json",
+                "tb_cxr_context_rows": len(
+                    [record for record in asset_rows if safe_int(record.get("subject_id")) == row.get("subject_id")]
+                ),
+            }
+        )
+
+    write_jsonl(args.output_root / "linked_manifests" / "test.jsonl", manifest_rows)
+
+    readme = """# ClinSeek-MM-Bench-EHRXQA-source
+
+This package is the source-aligned EHRXQA subset used by ClinSeek MM-Bench.
+It contains only the EHRXQA rows present in `inputs/mm_bench.jsonl`.
+
+Required source downloads:
+
+- EHRXQA 1.0.0 answered release: `$EHRXQA_ROOT`
+- MIMIC-CXR / MIMIC-CXR-JPG files and reports: `$MIMIC_CXR_ROOT`
+- MIMIC-CXR-JPG fallback root: `$MIMIC_CXR_JPG_ROOT`
+- MIMIC-IV latest local release kept for provenance: `$MIMICIV_ROOT`
+- MIMIC-IV-Note kept for provenance when local notes are inspected: `$MIMIC_IV_NOTE_ROOT`
+
+Contents:
+
+- `source_release/1.0.0/ehrxqa/dataset/test.json`: official EHRXQA rows selected by ClinSeek.
+- `source_release/1.0.0/ehrxqa/database/gold/`: official-schema subset tables.
+- `source_release/1.0.0/ehrxqa/database/gold/mimic_iv_cxr.sqlite`: SQLite materialization of the subset tables.
+	- `linked_manifests/test.jsonl`: row-level provenance and package-relative asset paths.
+	- `mimic-cxr/2.0.0/...`: packaged CXR JPG and report TXT assets for selected patient context.
+
+The linked manifest is a provenance artifact. It contains gold answers and the
+original EHRXQA SQL fields, so it must not be used as the runtime model input.
+	"""
+    (args.output_root / "README.md").write_text(readme, encoding="utf-8")
+
+    metadata = {
+        "package_name": "ClinSeek-MM-Bench-EHRXQA-source",
+        "input": "CLINSEEK_MM_BENCH_JSONL",
+        "records": len(manifest_rows),
+        "subjects": len(selected_subjects),
+        "variant": "gold",
+        "source_splits": dict(Counter(row["source_split"] for row in manifest_rows)),
+        "written_tables": written_tables,
+        "tb_cxr_context_rows": len(asset_rows),
+        "unique_linked_images": len({p for row in manifest_rows for p in row["packaged_image_relpaths"]}),
+        "unique_linked_reports": len({p for row in manifest_rows for p in row["packaged_report_relpaths"]}),
+        "copied_images": copied_images,
+        "copied_reports": copied_reports,
+        "missing_nonlinked_context_assets": missing_nonlinked_assets,
+        "source_path_env_vars": {
+            "ehrxqa_root": "EHRXQA_ROOT",
+            "cxr_root": "MIMIC_CXR_ROOT",
+            "cxr_jpg_root": "MIMIC_CXR_JPG_ROOT",
+            "mimiciv_root": "MIMICIV_ROOT",
+            "mimic_iv_note_root": "MIMIC_IV_NOTE_ROOT",
+        },
+        "path_contract": {
+            "manifest_paths": "relative_to_package_root",
+            "packaged_image_relpaths": "relative_to_package_root",
+            "packaged_report_relpaths": "relative_to_package_root",
+            "raw_image_source_relpaths": "relative_to_MIMIC_CXR_ROOT_or_MIMIC_CXR_JPG_ROOT",
+            "raw_report_source_relpaths": "relative_to_MIMIC_CXR_ROOT",
+        },
+    }
+    write_json(args.output_root / "metadata.json", metadata)
+    print(json.dumps(metadata, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

rebuild/mm_bench/build_medmod_clinseek_mm_subset.py

@@ -0,0 +1,679 @@
+#!/usr/bin/env python3
+"""Convert a source-aligned MedMod subset into ClinSeek-MM-Bench format.
+
+Input is the package produced by build_medmod_release_original_subset.py.
+Output is a compact release tree with:
+
+- inputs/mm_bench_medmod.jsonl
+- data/mm_bench/medmod/database/patient_<subject_id>.db
+- data/mm_bench/medmod/mimic-cxr/2.0.0/files/...
+- data/mm_bench/medmod/table_description/*
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import os
+import shutil
+import sqlite3
+import sys
+from collections import Counter, defaultdict
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+SRC_ROOT = REPO_ROOT / "src"
+if str(SRC_ROOT) not in sys.path:
+    sys.path.insert(0, str(SRC_ROOT))
+
+DEFAULT_ORIGINAL_ROOT = Path(
+    os.environ.get(
+        "MEDMOD_ORIGINAL_SUBSET_ROOT",
+        "data/build/ClinSeek-MM-Bench-MedMod-source",
+    )
+)
+DEFAULT_OUTPUT_ROOT = Path(
+    os.environ.get(
+        "CLINSEEK_MEDMOD_MM_ROOT",
+        "data/build/ClinSeek-MM-Bench-MedMod",
+    )
+)
+
+LEAKY_STAY_COLUMNS = {
+    "outtime",
+    "los",
+    "dischtime",
+    "deathtime",
+    "dod",
+    "mortality_inunit",
+    "mortality",
+    "mortality_inhospital",
+}
+
+TIME_COLUMNS = {
+    "events": "charttime",
+    "stays": "intime",
+    "tb_cxr": "studydatetime",
+}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--original-root", type=Path, default=DEFAULT_ORIGINAL_ROOT)
+    parser.add_argument("--output-root", type=Path, default=DEFAULT_OUTPUT_ROOT)
+    parser.add_argument("--asset-prefix", default="MedModOriginalLinked_v1")
+    parser.add_argument("--max-table-rows", type=int, default=80)
+    parser.add_argument(
+        "--patient-db-scope",
+        choices=("selected_stays", "full_subject"),
+        default="selected_stays",
+        help=(
+            "Build patient DBs from only the official stays selected by the release manifest, or from the "
+            "whole extracted subject folder."
+        ),
+    )
+    parser.add_argument("--overwrite", action="store_true")
+    parser.add_argument(
+        "--render-input-text",
+        action="store_true",
+        help="Render input_text from the rebuilt patient DB instead of preserving the released HF JSONL field.",
+    )
+    return parser.parse_args()
+
+
+def ensure_dir(path: Path) -> None:
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def reset_dir(path: Path, overwrite: bool) -> None:
+    if path.exists():
+        if not overwrite:
+            raise FileExistsError(f"Output root already exists: {path}")
+        shutil.rmtree(path)
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def link_or_copy(src: Path, dst: Path) -> None:
+    src = src.resolve()
+    ensure_dir(dst.parent)
+    if dst.exists():
+        return
+    try:
+        os.link(src, dst)
+    except OSError:
+        shutil.copy2(src, dst)
+
+
+def write_json(path: Path, payload: Any) -> None:
+    ensure_dir(path.parent)
+    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
+def read_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows = []
+    with path.open("r", encoding="utf-8") as handle:
+        for line in handle:
+            rows.append(json.loads(line))
+    return rows
+
+
+def safe_int(value: Any) -> int | None:
+    if value is None or value == "":
+        return None
+    try:
+        if pd.isna(value):
+            return None
+    except TypeError:
+        pass
+    try:
+        return int(float(str(value).strip()))
+    except ValueError:
+        return None
+
+
+def compact_value(value: Any) -> Any:
+    try:
+        if pd.isna(value):
+            return ""
+    except TypeError:
+        pass
+    if hasattr(value, "isoformat"):
+        return value.isoformat(sep=" ")
+    return value
+
+
+def parse_datetime(value: Any) -> datetime | None:
+    if not value:
+        return None
+    if isinstance(value, datetime):
+        return value
+    text = str(value)
+    for fmt in ("%Y-%m-%d %H:%M:%S", "%Y-%m-%d %H:%M:%S.%f"):
+        try:
+            return datetime.strptime(text, fmt)
+        except ValueError:
+            pass
+    return None
+
+
+def study_datetime_from_metadata(record: dict[str, Any]) -> str | None:
+    date = record.get("StudyDate")
+    time = record.get("StudyTime")
+    if date in (None, "") or time in (None, ""):
+        return None
+    try:
+        time_text = f"{int(float(time)):06d}"
+        dt = datetime.strptime(f"{int(float(date))} {time_text}", "%Y%m%d %H%M%S")
+        return dt.strftime("%Y-%m-%d %H:%M:%S")
+    except (TypeError, ValueError):
+        return None
+
+
+def load_manifest(original_root: Path) -> list[dict[str, Any]]:
+    manifest = original_root / "linked_manifests" / "all.jsonl"
+    if not manifest.exists():
+        raise FileNotFoundError(f"Missing source manifest: {manifest}")
+    return read_jsonl(manifest)
+
+
+def load_cxr_metadata(original_root: Path) -> tuple[dict[str, dict[str, Any]], dict[str, str]]:
+    meta_root = original_root / "source_release" / "cxr_metadata"
+    metadata_path = meta_root / "mimic-cxr-2.0.0-metadata.csv"
+    if not metadata_path.exists():
+        raise FileNotFoundError(f"Missing packaged CXR metadata: {metadata_path}")
+    metadata_df = pd.read_csv(metadata_path)
+    metadata_by_dicom = {
+        str(record["dicom_id"]): record for record in metadata_df.to_dict(orient="records")
+    }
+
+    split_by_dicom: dict[str, str] = {}
+    split_path = meta_root / "mimic-cxr-2.0.0-split.csv"
+    if split_path.exists():
+        split_df = pd.read_csv(split_path)
+        if {"dicom_id", "split"}.issubset(split_df.columns):
+            split_by_dicom = {
+                str(record["dicom_id"]): str(record["split"])
+                for record in split_df.to_dict(orient="records")
+            }
+    return metadata_by_dicom, split_by_dicom
+
+
+def build_tb_cxr_rows(
+    manifest_rows: list[dict[str, Any]],
+    metadata_by_dicom: dict[str, dict[str, Any]],
+    split_by_dicom: dict[str, str],
+) -> dict[int, pd.DataFrame]:
+    rows_by_subject: dict[int, list[dict[str, Any]]] = defaultdict(list)
+    seen: set[tuple[int, int, str, int | None]] = set()
+    for sample in manifest_rows:
+        subject_id = safe_int(sample.get("subject_id"))
+        hadm_id = safe_int(sample.get("hadm_id"))
+        stay_id = safe_int(sample.get("stay_id"))
+        if subject_id is None:
+            continue
+        for study_id, dicom_id, image_relpath in zip(
+            sample.get("study_ids") or [],
+            sample.get("dicom_ids") or [],
+            sample.get("packaged_image_relpaths") or [],
+        ):
+            study_id_int = safe_int(study_id)
+            if study_id_int is None:
+                continue
+            key = (subject_id, study_id_int, str(dicom_id), stay_id)
+            if key in seen:
+                continue
+            seen.add(key)
+            metadata = metadata_by_dicom.get(str(dicom_id), {})
+            rows_by_subject[subject_id].append(
+                {
+                    "subject_id": subject_id,
+                    "study_id": study_id_int,
+                    "studydatetime": study_datetime_from_metadata(metadata)
+                    or sample.get("prediction_time"),
+                    "split": split_by_dicom.get(str(dicom_id), sample.get("source_split") or "test"),
+                    "image_id": str(dicom_id),
+                    "image_path": image_relpath,
+                    "viewposition": str(metadata.get("ViewPosition") or "AP"),
+                    "hadm_id": hadm_id,
+                    "stay_id": stay_id,
+                }
+            )
+    return {
+        subject_id: pd.DataFrame(rows).sort_values(["studydatetime", "study_id", "image_id"])
+        for subject_id, rows in rows_by_subject.items()
+    }
+
+
+def sanitize_stays(frame: pd.DataFrame) -> pd.DataFrame:
+    drop_cols = [col for col in frame.columns if col.lower() in LEAKY_STAY_COLUMNS]
+    return frame.drop(columns=drop_cols) if drop_cols else frame
+
+
+def write_frame(conn: sqlite3.Connection, table_name: str, frame: pd.DataFrame) -> None:
+    clean = frame.where(pd.notna(frame), None)
+    clean.to_sql(table_name, conn, if_exists="replace", index=False)
+
+
+def quote_identifier(name: str) -> str:
+    return '"' + name.replace('"', '""') + '"'
+
+
+def csv_value(value: Any) -> Any:
+    if value is None or value == "":
+        return None
+    return value
+
+
+def create_text_table(
+    conn: sqlite3.Connection,
+    table_name: str,
+    columns: list[str],
+    rows: list[list[Any]],
+) -> None:
+    q_table = quote_identifier(table_name)
+    column_sql = ", ".join(f"{quote_identifier(column)} TEXT" for column in columns)
+    conn.execute(f"CREATE TABLE {q_table} ({column_sql})")
+    if not rows:
+        return
+    placeholders = ", ".join(["?"] * len(columns))
+    conn.executemany(f"INSERT INTO {q_table} VALUES ({placeholders})", rows)
+
+
+def sample_stay_ids(samples: list[dict[str, Any]]) -> set[int]:
+    stay_ids: set[int] = set()
+    for sample in samples:
+        for candidate in (
+            sample.get("stay_id"),
+            (sample.get("official_data_full_row") or {}).get("stay_id")
+            if isinstance(sample.get("official_data_full_row"), dict)
+            else None,
+            (sample.get("official_listfile_row") or {}).get("stay_id")
+            if isinstance(sample.get("official_listfile_row"), dict)
+            else None,
+        ):
+            stay_id = safe_int(candidate)
+            if stay_id is not None:
+                stay_ids.add(stay_id)
+    return stay_ids
+
+
+def filter_frame_to_stays(frame: pd.DataFrame, stay_ids: set[int]) -> pd.DataFrame:
+    if not stay_ids or "stay_id" not in frame.columns:
+        return frame
+    numeric_stay_ids = pd.to_numeric(frame["stay_id"], errors="coerce").astype("Int64")
+    return frame[numeric_stay_ids.isin(stay_ids)].copy()
+
+
+def write_csv_table(
+    conn: sqlite3.Connection,
+    table_name: str,
+    csv_path: Path,
+    *,
+    stay_ids: set[int],
+    drop_lower_columns: set[str] | None = None,
+) -> None:
+    drop_lower_columns = drop_lower_columns or set()
+    with csv_path.open("r", encoding="utf-8", newline="") as handle:
+        reader = csv.reader(handle)
+        source_columns = next(reader)
+        keep_indexes = [
+            index
+            for index, column in enumerate(source_columns)
+            if column.lower() not in drop_lower_columns
+        ]
+        columns = [source_columns[index] for index in keep_indexes]
+        stay_index = source_columns.index("stay_id") if "stay_id" in source_columns else None
+        rows: list[list[Any]] = []
+        for row in reader:
+            if stay_ids and stay_index is not None:
+                stay_id = safe_int(row[stay_index] if stay_index < len(row) else None)
+                if stay_id not in stay_ids:
+                    continue
+            rows.append([csv_value(row[index]) if index < len(row) else None for index in keep_indexes])
+    create_text_table(conn, table_name, columns, rows)
+
+
+def build_patient_db(
+    *,
+    original_root: Path,
+    samples: list[dict[str, Any]],
+    output_db: Path,
+    tb_cxr: pd.DataFrame | None,
+    patient_db_scope: str,
+) -> None:
+    ensure_dir(output_db.parent)
+    if not samples:
+        raise ValueError("Cannot build MedMod patient DB from an empty sample list")
+    sample = samples[0]
+    subject_dirs = sample.get("ehr_subject_relpaths") or []
+    if not subject_dirs:
+        raise FileNotFoundError(f"Sample has no EHR subject path: {sample.get('qid')}")
+    subject_dir = original_root / subject_dirs[0]
+    if not subject_dir.is_dir():
+        raise FileNotFoundError(f"Missing EHR subject dir: {subject_dir}")
+    stay_ids = sample_stay_ids(samples) if patient_db_scope == "selected_stays" else set()
+    with sqlite3.connect(output_db) as conn:
+        conn.execute("PRAGMA journal_mode=OFF")
+        conn.execute("PRAGMA synchronous=OFF")
+        events_path = subject_dir / "events.csv"
+        stays_path = subject_dir / "stays.csv"
+        if events_path.exists():
+            write_csv_table(conn, "events", events_path, stay_ids=stay_ids)
+        if stays_path.exists():
+            write_csv_table(
+                conn,
+                "stays",
+                stays_path,
+                stay_ids=stay_ids,
+                drop_lower_columns=LEAKY_STAY_COLUMNS,
+            )
+        if tb_cxr is not None and not tb_cxr.empty:
+            write_frame(conn, "tb_cxr", filter_frame_to_stays(tb_cxr, stay_ids))
+        conn.commit()
+
+
+def materialize_patient_db(
+    *,
+    original_root: Path,
+    samples: list[dict[str, Any]],
+    output_db: Path,
+    tb_cxr: pd.DataFrame | None,
+    patient_db_scope: str,
+) -> str:
+    if not samples:
+        raise ValueError("Cannot materialize MedMod patient DB from an empty sample list")
+    sample = samples[0]
+    subject_id = safe_int(sample.get("subject_id"))
+    if subject_id is None:
+        raise ValueError(f"Missing subject_id for {sample.get('qid')}")
+    build_patient_db(
+        original_root=original_root,
+        samples=samples,
+        output_db=output_db,
+        tb_cxr=tb_cxr,
+        patient_db_scope=patient_db_scope,
+    )
+    return f"source_aligned_{patient_db_scope}"
+
+
+def filter_by_cutoff(table_name: str, frame: pd.DataFrame, cutoff: datetime | None) -> pd.DataFrame:
+    if cutoff is None:
+        return frame.copy()
+    column = TIME_COLUMNS.get(table_name)
+    if not column or column not in frame.columns:
+        return frame.copy()
+    parsed = pd.to_datetime(frame[column], errors="coerce")
+    return frame[parsed.isna() | (parsed <= pd.Timestamp(cutoff))].copy()
+
+
+def table_to_text(table_name: str, frame: pd.DataFrame, max_rows: int) -> str:
+    total = len(frame)
+    if total == 0:
+        return f"### {table_name}\nRows visible before cutoff: 0\n"
+    sort_col = TIME_COLUMNS.get(table_name)
+    display = frame
+    if sort_col and sort_col in display.columns:
+        display = display.sort_values(sort_col, kind="stable")
+    if max_rows and len(display) > max_rows:
+        display = display.tail(max_rows)
+        shown = f"latest {len(display)} of {total}"
+    else:
+        shown = f"{total} of {total}"
+    clean = display.copy()
+    for column in clean.columns:
+        clean[column] = clean[column].map(compact_value)
+    return (
+        f"### {table_name}\n"
+        f"Rows visible before cutoff: {total}; rows included below: {shown}\n"
+        f"{clean.to_csv(index=False)}"
+    )
+
+
+def render_ehr_context_from_manager(manager: Any, sample: dict[str, Any], max_table_rows: int) -> str:
+    manager.load_ehr_for_sample(str(sample["subject_id"]), sample["prediction_time"])
+    blocks = []
+    for table_name in sorted(manager.ehr_data):
+        blocks.append(table_to_text(table_name, manager.ehr_data[table_name], max_table_rows))
+    return "\n".join(blocks).strip()
+
+
+def render_ehr_context(db_path: Path, prediction_time: str, max_table_rows: int) -> str:
+    cutoff = parse_datetime(prediction_time)
+    blocks: list[str] = []
+    with sqlite3.connect(db_path) as conn:
+        table_names = [
+            row[0]
+            for row in conn.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
+        ]
+        for table_name in table_names:
+            frame = pd.read_sql_query(f'SELECT * FROM "{table_name}"', conn)
+            visible = filter_by_cutoff(table_name, frame, cutoff)
+            blocks.append(table_to_text(table_name, visible, max_table_rows))
+    return "\n".join(blocks).strip()
+
+
+def build_input_text(sample: dict[str, Any], image_paths: list[str], ehr_text: str) -> str:
+    return "\n\n".join(
+        [
+            str(sample.get("question") or "").strip(),
+            "<ehr_context>",
+            ehr_text,
+            "</ehr_context>",
+            "<image_inputs>",
+            "\n".join(f"- {path}" for path in image_paths) if image_paths else "NONE",
+            "</image_inputs>",
+        ]
+    )
+
+
+def write_table_descriptions(benchmark_root: Path) -> None:
+    database_root = benchmark_root / "database"
+    table_desc_root = benchmark_root / "table_description"
+    ensure_dir(table_desc_root)
+    schemas: dict[str, list[str]] = {}
+    for db_path in sorted(database_root.glob("patient_*.db"))[:50]:
+        with sqlite3.connect(db_path) as conn:
+            for (table_name,) in conn.execute("SELECT name FROM sqlite_master WHERE type='table'"):
+                columns = [row[1] for row in conn.execute(f'PRAGMA table_info("{table_name}")')]
+                known = schemas.setdefault(table_name, [])
+                for column in columns:
+                    if column not in known:
+                        known.append(column)
+    desc_records = [
+        {
+            "file_name": table_name,
+            "class": "ehr",
+            "description": f"Schema extracted from MedMod subset table '{table_name}'.",
+            "columns": [
+                {
+                    "column_name": column,
+                    "description": f"Column '{column}' in table '{table_name}'.",
+                }
+                for column in columns
+            ],
+        }
+        for table_name, columns in sorted(schemas.items())
+    ]
+    with (table_desc_root / "shorten_description.json").open("w", encoding="utf-8") as handle:
+        for record in desc_records:
+            handle.write(json.dumps(record, ensure_ascii=False) + "\n")
+    (table_desc_root / "link_information.json").write_text("", encoding="utf-8")
+
+
+def write_runtime_metadata(benchmark_root: Path) -> None:
+    write_json(
+        benchmark_root / "metadata.json",
+        {
+            "package_name": "ClinSeek-MM-Bench-MedMod-runtime",
+            "leakage_policy": {
+                "sanitize_datetime_columns": True,
+                "mask_future_datetime_columns": True,
+                "row_timestamp_columns": TIME_COLUMNS,
+                "datetime_columns": {
+                    "events": ["charttime"],
+                    "stays": ["intime", "admittime"],
+                    "tb_cxr": ["studydatetime"],
+                },
+                "drop_columns": {
+                    "stays": sorted(LEAKY_STAY_COLUMNS),
+                },
+            },
+            "path_contract": {
+                "db_path_hint": "relative_to_benchmark_root",
+                "image_paths": "relative_to_benchmark_root",
+                "report_paths": "relative_to_benchmark_root",
+                "tb_cxr.image_path": "relative_to_benchmark_root",
+            },
+        },
+    )
+
+
+def main() -> None:
+    args = parse_args()
+    reset_dir(args.output_root, args.overwrite)
+    manifest_rows = load_manifest(args.original_root)
+    metadata_by_dicom, split_by_dicom = load_cxr_metadata(args.original_root)
+    tb_cxr_by_subject = build_tb_cxr_rows(manifest_rows, metadata_by_dicom, split_by_dicom)
+
+    bench_root = args.output_root / "data" / "mm_bench" / "medmod"
+    database_root = bench_root / "database"
+    inputs_root = args.output_root / "inputs"
+    ensure_dir(database_root)
+    ensure_dir(inputs_root)
+
+    by_subject: dict[int, list[dict[str, Any]]] = defaultdict(list)
+    for sample in manifest_rows:
+        subject_id = safe_int(sample.get("subject_id"))
+        if subject_id is not None:
+            by_subject[subject_id].append(sample)
+
+    db_source_counts = Counter()
+    for subject_id, samples in sorted(by_subject.items()):
+        source = materialize_patient_db(
+            original_root=args.original_root,
+            samples=samples,
+            output_db=database_root / f"patient_{subject_id}.db",
+            tb_cxr=tb_cxr_by_subject.get(subject_id),
+            patient_db_scope=args.patient_db_scope,
+        )
+        db_source_counts[source] += 1
+
+    write_table_descriptions(bench_root)
+    write_runtime_metadata(bench_root)
+
+    ehr_manager = None
+    need_rendered_input_text = args.render_input_text or any(
+        not sample.get("released_input_text") for sample in manifest_rows
+    )
+    if need_rendered_input_text:
+        try:
+            from agentlite.commons.EHRManager import EHRManager  # type: ignore
+
+            ehr_manager = EHRManager(str(bench_root))
+        except Exception as exc:  # pragma: no cover - fallback for portable envs
+            print({"ehr_manager_unavailable": repr(exc)}, flush=True)
+
+    output_rows: list[dict[str, Any]] = []
+    stats = Counter()
+    for index, sample in enumerate(manifest_rows):
+        subject_id = safe_int(sample.get("subject_id"))
+        if subject_id is None:
+            raise ValueError(f"Missing subject_id: {sample.get('qid')}")
+        rel_images = list(sample.get("packaged_image_relpaths") or [])
+        rel_reports = list(sample.get("packaged_report_relpaths") or [])
+        for relpath in rel_images + rel_reports:
+            link_or_copy(args.original_root / relpath, bench_root / relpath)
+        prefixed_images = [f"{args.asset_prefix}/{relpath}" for relpath in rel_images]
+        prefixed_reports = [f"{args.asset_prefix}/{relpath}" for relpath in rel_reports]
+        db_path = database_root / f"patient_{subject_id}.db"
+        if args.render_input_text or not sample.get("released_input_text"):
+            if ehr_manager is not None:
+                ehr_text = render_ehr_context_from_manager(ehr_manager, sample, args.max_table_rows)
+            else:
+                ehr_text = render_ehr_context(db_path, str(sample.get("prediction_time")), args.max_table_rows)
+            input_text = build_input_text(sample, prefixed_images, ehr_text)
+        else:
+            input_text = sample.get("released_input_text")
+        output_rows.append(
+            {
+                "qid": sample.get("qid"),
+                "source_index": sample.get("source_index"),
+                "source_benchmark": "medmod",
+                "task": sample.get("source_task"),
+                "source_split": sample.get("source_split"),
+                "subject_id": sample.get("subject_id"),
+                "hadm_id": sample.get("hadm_id"),
+                "stay_id": sample.get("stay_id"),
+                "prediction_time": sample.get("prediction_time"),
+                "question": sample.get("question"),
+                "input_text": input_text,
+                "image_paths": prefixed_images,
+                "report_paths": prefixed_reports,
+                "ground_truth": sample.get("ground_truth"),
+                "answer_type": sample.get("answer_type"),
+                "modalities": sample.get("modalities") or ["ehr", "cxr"],
+            }
+        )
+        stats[f"task:{sample.get('source_task')}"] += 1
+        if (index + 1) % 100 == 0:
+            print({"rendered_rows": index + 1, "total": len(manifest_rows)}, flush=True)
+
+    output_path = inputs_root / "mm_bench_medmod.jsonl"
+    with output_path.open("w", encoding="utf-8") as handle:
+        for row in output_rows:
+            handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n")
+
+    metadata = {
+        "package_name": "ClinSeek-MM-Bench-MedMod",
+        "original_root": "MEDMOD_ORIGINAL_SUBSET_ROOT",
+        "records": len(output_rows),
+        "subjects": len(by_subject),
+        "patient_dbs": len(list(database_root.glob("patient_*.db"))),
+        "patient_db_sources": dict(sorted(db_source_counts.items())),
+        "patient_db_scope": args.patient_db_scope,
+        "unique_images": len({p for row in output_rows for p in row["image_paths"]}),
+        "unique_reports": len({p for row in output_rows for p in row["report_paths"]}),
+        "input_file": "inputs/mm_bench_medmod.jsonl",
+        "bench_root": "data/mm_bench/medmod",
+        "asset_prefix": args.asset_prefix,
+        "input_text_source": "rendered_from_db" if need_rendered_input_text else "released_hf_jsonl",
+        "stats": dict(sorted(stats.items())),
+        "path_contract": {
+            "image_paths": "strip asset_prefix, then resolve relative to bench_root",
+            "report_paths": "strip asset_prefix, then resolve relative to bench_root",
+            "patient_db": "data/mm_bench/medmod/database/patient_<subject_id>.db",
+        },
+        "leakage_policy": {
+            "ground_truth": "kept only in output JSONL field, never in input_text",
+            "stays_dropped_columns": sorted(LEAKY_STAY_COLUMNS),
+            "diagnoses_table": "not materialized in patient DB",
+            "runtime_cutoff_columns": TIME_COLUMNS,
+        },
+    }
+    write_json(args.output_root / "metadata.json", metadata)
+
+    readme = f"""# ClinSeek-MM-Bench-MedMod
+
+This directory contains the MedMod-derived portion of ClinSeek-MM-Bench.
+
+Use:
+
+- `inputs/mm_bench_medmod.jsonl`
+- `data/mm_bench/medmod`
+
+The JSONL contains both agentic fields (`question`, `image_paths`, `subject_id`)
+and one-shot fields (`input_text`, `image_paths`).  Patient SQLite DBs are under
+`data/mm_bench/medmod/database`.
+"""
+    (args.output_root / "README.md").write_text(readme, encoding="utf-8")
+    print(json.dumps(metadata, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

rebuild/mm_bench/build_medmod_release_original_subset.py

@@ -0,0 +1,929 @@
+#!/usr/bin/env python3
+"""Build the source-aligned MedMod subset used by ClinSeek MM-Bench.
+
+This script intentionally does not rebuild the full MedMod benchmark.  It reads
+the released ClinSeek multimodal input file, keeps only the MedMod rows that are
+actually evaluated, verifies them against the official MedMod listfiles and
+MIMIC-CXR labels/metadata, and packages the required source-format EHR folders
+and CXR files with relative paths.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shutil
+import sqlite3
+from collections import Counter, defaultdict
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+
+
+DEFAULT_INPUT = Path(
+    os.environ.get(
+        "CLINSEEK_MM_BENCH_JSONL",
+        "data/ClinSeek-Bench/inputs/mm_bench.jsonl",
+    )
+)
+DEFAULT_OUTPUT_ROOT = Path(
+    os.environ.get(
+        "MEDMOD_ORIGINAL_SUBSET_ROOT",
+        "data/build/ClinSeek-MM-Bench-MedMod-source",
+    )
+)
+DEFAULT_MEDMOD_REPO = Path(os.environ.get("MEDMOD_REPO_ROOT", "external/MedMod"))
+DEFAULT_CXR_JPG_ROOT = Path(
+    os.environ.get("MIMIC_CXR_JPG_ROOT", "external/mimic-cxr-jpg")
+)
+DEFAULT_CXR_META_ROOT = Path(
+    os.environ.get("MIMIC_CXR_META_ROOT", "external/mimic-cxr/2.0.0")
+)
+DEFAULT_MIMICIV_ROOT = Path(os.environ.get("MIMICIV_ROOT", "external/mimiciv/3.1"))
+
+IMAGE_RE = re.compile(
+    r"(?:^|/)files/p\d+/p(?P<subject_id>\d+)/s(?P<study_id>\d+)/(?P<dicom_id>[^/]+)\.jpg$"
+)
+
+TASK_MAP = {
+    "medmod_decompensation": "decompensation",
+    "medmod_in_hospital_mortality": "in-hospital-mortality",
+    "medmod_length_of_stay": "length-of-stay",
+    "medmod_phenotyping": "phenotyping",
+    "medmod_radiology": "radiology",
+    "decompensation": "decompensation",
+    "in-hospital-mortality": "in-hospital-mortality",
+    "length-of-stay": "length-of-stay",
+    "phenotyping": "phenotyping",
+    "radiology": "radiology",
+}
+
+PHENOTYPE_CLASSES = [
+    "Acute and unspecified renal failure",
+    "Acute cerebrovascular disease",
+    "Acute myocardial infarction",
+    "Cardiac dysrhythmias",
+    "Chronic kidney disease",
+    "Chronic obstructive pulmonary disease and bronchiectasis",
+    "Complications of surgical procedures or medical care",
+    "Conduction disorders",
+    "Congestive heart failure; nonhypertensive",
+    "Coronary atherosclerosis and other heart disease",
+    "Diabetes mellitus with complications",
+    "Diabetes mellitus without complication",
+    "Disorders of lipid metabolism",
+    "Essential hypertension",
+    "Fluid and electrolyte disorders",
+    "Gastrointestinal hemorrhage",
+    "Hypertension with complications and secondary hypertension",
+    "Other liver diseases",
+    "Other lower respiratory disease",
+    "Other upper respiratory disease",
+    "Pleurisy; pneumothorax; pulmonary collapse",
+    "Pneumonia (except that caused by tuberculosis or sexually transmitted disease)",
+    "Respiratory failure; insufficiency; arrest (adult)",
+    "Septicemia (except in labor)",
+    "Shock",
+]
+
+RADIOLOGY_CLASSES = [
+    "Atelectasis",
+    "Cardiomegaly",
+    "Consolidation",
+    "Edema",
+    "Enlarged Cardiomediastinum",
+    "Fracture",
+    "Lung Lesion",
+    "Lung Opacity",
+    "No Finding",
+    "Pleural Effusion",
+    "Pleural Other",
+    "Pneumonia",
+    "Pneumothorax",
+    "Support Devices",
+]
+
+LEAKY_STAY_COLUMNS = {
+    "outtime",
+    "los",
+    "dischtime",
+    "deathtime",
+    "dod",
+    "mortality_inunit",
+    "mortality",
+    "mortality_inhospital",
+}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--input", type=Path, default=DEFAULT_INPUT)
+    parser.add_argument("--output-root", type=Path, default=DEFAULT_OUTPUT_ROOT)
+    parser.add_argument("--medmod-repo-root", type=Path, default=DEFAULT_MEDMOD_REPO)
+    parser.add_argument("--cxr-jpg-root", type=Path, default=DEFAULT_CXR_JPG_ROOT)
+    parser.add_argument("--cxr-meta-root", type=Path, default=DEFAULT_CXR_META_ROOT)
+    parser.add_argument("--mimiciv-root", type=Path, default=DEFAULT_MIMICIV_ROOT)
+    parser.add_argument("--overwrite", action="store_true")
+    parser.add_argument(
+        "--include-reports",
+        action="store_true",
+        help="Also package CXR report TXT files. Keep disabled for the ClinSeek MedMod release.",
+    )
+    parser.add_argument(
+        "--allow-warnings",
+        action="store_true",
+        help="Deprecated compatibility flag; warnings are non-fatal unless --strict-official-match is set.",
+    )
+    parser.add_argument(
+        "--strict-official-match",
+        action="store_true",
+        help="Exit non-zero if official pairing/label validation warnings are found.",
+    )
+    return parser.parse_args()
+
+
+def ensure_dir(path: Path) -> None:
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def reset_dir(path: Path, overwrite: bool) -> None:
+    if path.exists():
+        if not overwrite:
+            raise FileExistsError(f"Output root already exists: {path}")
+        shutil.rmtree(path)
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def link_or_copy(src: Path, dst: Path) -> None:
+    src = src.resolve()
+    ensure_dir(dst.parent)
+    if dst.exists():
+        return
+    try:
+        os.link(src, dst)
+    except OSError:
+        shutil.copy2(src, dst)
+
+
+def copytree_links(src: Path, dst: Path) -> None:
+    if dst.exists():
+        return
+    shutil.copytree(src, dst, copy_function=lambda s, d: (link_or_copy(Path(s), Path(d)) or str(d)))
+
+
+def relpath_or_name(path: Path, root: Path) -> str:
+    try:
+        return str(path.resolve().relative_to(root.resolve()))
+    except ValueError:
+        return path.name
+
+
+def write_json(path: Path, payload: Any) -> None:
+    ensure_dir(path.parent)
+    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
+def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
+    ensure_dir(path.parent)
+    with path.open("w", encoding="utf-8") as handle:
+        for row in rows:
+            handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n")
+
+
+def safe_int(value: Any) -> int | None:
+    if value is None or value == "":
+        return None
+    try:
+        if pd.isna(value):
+            return None
+    except TypeError:
+        pass
+    try:
+        return int(float(str(value).strip()))
+    except ValueError:
+        return None
+
+
+def safe_float(value: Any) -> float | None:
+    if value is None or value == "":
+        return None
+    try:
+        if pd.isna(value):
+            return None
+    except TypeError:
+        pass
+    try:
+        return float(str(value).strip())
+    except ValueError:
+        return None
+
+
+def normalize_split(split: str) -> str:
+    return "valid" if split in {"val", "validate", "validation"} else split
+
+
+def medmod_listfile_name(split: str, *, mml_ssl: bool) -> str:
+    split = normalize_split(split)
+    if split == "valid":
+        return "validate_listfile.csv" if mml_ssl else "val_listfile.csv"
+    return f"{split}_listfile.csv"
+
+
+def canonical_task(task: str) -> str:
+    if task not in TASK_MAP:
+        raise ValueError(f"Unsupported MedMod task: {task}")
+    return TASK_MAP[task]
+
+
+def ground_truth_names(row: dict[str, Any]) -> list[str]:
+    values = row.get("ground_truth")
+    if values is None:
+        values = row.get("label")
+    if isinstance(values, list):
+        names = []
+        for item in values:
+            if isinstance(item, dict) and item.get("name") is not None:
+                names.append(str(item["name"]))
+            elif item is not None:
+                names.append(str(item))
+        return names
+    if values is None:
+        return []
+    return [str(values)]
+
+
+def parse_image_ref(path: str) -> dict[str, Any]:
+    stripped = path
+    if "/" in stripped and stripped.split("/", 1)[0].endswith("OriginalLinked_v1"):
+        stripped = stripped.split("/", 1)[1]
+    match = IMAGE_RE.search(stripped)
+    if not match:
+        raise ValueError(f"Cannot parse CXR image path: {path}")
+    subject_id = int(match.group("subject_id"))
+    study_id = int(match.group("study_id"))
+    dicom_id = match.group("dicom_id")
+    nested_relpath = (
+        f"mimic-cxr/2.0.0/files/p{str(subject_id)[:2]}/p{subject_id}/"
+        f"s{study_id}/{dicom_id}.jpg"
+    )
+    return {
+        "subject_id": subject_id,
+        "study_id": study_id,
+        "dicom_id": dicom_id,
+        "nested_relpath": nested_relpath,
+    }
+
+
+def parse_stay_period_from_qid(qid: str, task: str) -> tuple[int | None, float | None]:
+    if task == "radiology":
+        return None, None
+    try:
+        _, stay_text, period_text = qid.rsplit("_", 2)
+    except ValueError:
+        return None, None
+    return safe_int(stay_text), safe_float(period_text)
+
+
+def load_medmod_rows(input_path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    with input_path.open("r", encoding="utf-8") as handle:
+        for line_index, line in enumerate(handle):
+            row = json.loads(line)
+            if row.get("source_benchmark") != "medmod":
+                continue
+            task = canonical_task(str(row.get("task")))
+            stay_from_qid, period_from_qid = parse_stay_period_from_qid(str(row.get("qid")), task)
+            image_refs = [parse_image_ref(path) for path in row.get("image_paths") or []]
+            row["_source_line_index"] = line_index
+            row["_canonical_task"] = task
+            row["_stay_id_from_qid"] = stay_from_qid
+            row["_period_length_from_qid"] = period_from_qid
+            row["_image_refs"] = image_refs
+            rows.append(row)
+    return rows
+
+
+def row_key(row: dict[str, Any], task: str) -> tuple[int, float | None]:
+    stay_id = safe_int(row.get("stay_id"))
+    if stay_id is None:
+        raise ValueError(f"Listfile row missing stay_id: {row}")
+    if task in {"decompensation", "length-of-stay", "phenotyping"}:
+        period = safe_float(row.get("period_length"))
+        return stay_id, period
+    return stay_id, None
+
+
+def sample_key(sample: dict[str, Any]) -> tuple[int, float | None]:
+    task = sample["_canonical_task"]
+    stay_id = safe_int(sample.get("stay_id")) or sample.get("_stay_id_from_qid")
+    if stay_id is None:
+        raise ValueError(f"Sample missing stay_id: {sample.get('qid')}")
+    if task in {"decompensation", "length-of-stay", "phenotyping"}:
+        return int(stay_id), safe_float(sample.get("_period_length_from_qid"))
+    return int(stay_id), None
+
+
+def load_filtered_csv_index(
+    path: Path,
+    *,
+    task: str,
+    needed_keys: set[tuple[int, float | None]],
+) -> tuple[dict[tuple[int, float | None], dict[str, Any]], list[str]]:
+    if not path.exists():
+        return {}, []
+    rows: dict[tuple[int, float | None], dict[str, Any]] = {}
+    columns: list[str] = []
+    for chunk in pd.read_csv(path, chunksize=200_000):
+        if not columns:
+            columns = list(chunk.columns)
+        for record in chunk.to_dict(orient="records"):
+            key = row_key(record, task)
+            if key in needed_keys and key not in rows:
+                rows[key] = record
+        if len(rows) == len(needed_keys):
+            break
+    return rows, columns
+
+
+def load_listfile_index(
+    repo_root: Path,
+    task: str,
+    split: str,
+    needed_keys: set[tuple[int, float | None]],
+) -> dict[str, Any]:
+    split_name = normalize_split(split)
+    mml_path = repo_root / "mml-ssl-full" / task / medmod_listfile_name(split_name, mml_ssl=True)
+    data_path = repo_root / "data_full" / task / medmod_listfile_name(split_name, mml_ssl=False)
+    if not mml_path.exists():
+        raise FileNotFoundError(f"Missing official MedMod mml-ssl listfile: {mml_path}")
+    mml_by_key, mml_columns = load_filtered_csv_index(
+        mml_path,
+        task=task,
+        needed_keys=needed_keys,
+    )
+    data_by_key, data_columns = load_filtered_csv_index(
+        data_path,
+        task=task,
+        needed_keys=needed_keys,
+    )
+
+    return {
+        "mml_path": mml_path,
+        "data_path": data_path if data_path.exists() else None,
+        "mml_by_key": mml_by_key,
+        "data_by_key": data_by_key,
+        "mml_columns": mml_columns,
+        "data_columns": data_columns,
+    }
+
+
+def expected_label_from_listfile(task: str, record: dict[str, Any]) -> list[str]:
+    if task in {"decompensation", "in-hospital-mortality"}:
+        return ["yes" if safe_int(record.get("y_true")) == 1 else "no"]
+    if task == "phenotyping":
+        return [label for label in PHENOTYPE_CLASSES if safe_int(record.get(label)) == 1]
+    if task == "length-of-stay":
+        value = safe_float(record.get("y_true"))
+        return [] if value is None else [str(value)]
+    raise ValueError(f"No listfile label parser for task: {task}")
+
+
+def find_subject_dir(repo_root: Path, subject_id: int) -> tuple[Path, str]:
+    for split in ("test", "train"):
+        path = repo_root / "data_full" / "root" / split / str(subject_id)
+        if path.is_dir():
+            return path, split
+    raise FileNotFoundError(f"Missing MedMod subject directory for subject_id={subject_id}")
+
+
+def local_episode_filename(subject_id: int, official_stay: str | None) -> str | None:
+    if not official_stay:
+        return None
+    prefix = f"{subject_id}_"
+    if official_stay.startswith(prefix):
+        return official_stay[len(prefix) :]
+    return official_stay
+
+
+def task_data_split_dir(split: str) -> str:
+    split = normalize_split(split)
+    if split == "valid":
+        return "train"
+    return split
+
+
+def find_cxr_file(cxr_jpg_root: Path, image_ref: dict[str, Any], suffix: str) -> Path | None:
+    subject_id = image_ref["subject_id"]
+    study_id = image_ref["study_id"]
+    dicom_id = image_ref["dicom_id"]
+    flat_name = f"p{str(subject_id)[:2]}_p{subject_id}_s{study_id}_{dicom_id}.{suffix}"
+    nested = Path(image_ref["nested_relpath"]).with_suffix(f".{suffix}")
+    candidates = [
+        cxr_jpg_root / "mimic-cxr2" / flat_name,
+        cxr_jpg_root / nested.relative_to("mimic-cxr/2.0.0"),
+        cxr_jpg_root / "2.1.0-lite" / nested.relative_to("mimic-cxr/2.0.0"),
+        cxr_jpg_root / "2.1.0-working-subset" / nested.relative_to("mimic-cxr/2.0.0"),
+        cxr_jpg_root / nested,
+    ]
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+    return None
+
+
+def read_csv_subset(path: Path, column: str, values: set[Any]) -> pd.DataFrame:
+    if not path.exists():
+        return pd.DataFrame()
+    df = pd.read_csv(path)
+    if column not in df.columns:
+        return df.iloc[0:0].copy()
+    return df[df[column].isin(values)].copy()
+
+
+def build_metadata_indexes(cxr_meta_root: Path) -> dict[str, Any]:
+    metadata_path = cxr_meta_root / "mimic-cxr-2.0.0-metadata.csv"
+    chexpert_path = cxr_meta_root / "mimic-cxr-2.0.0-chexpert.csv"
+    if not metadata_path.exists():
+        raise FileNotFoundError(f"Missing MIMIC-CXR metadata: {metadata_path}")
+    if not chexpert_path.exists():
+        raise FileNotFoundError(f"Missing MIMIC-CXR CheXpert labels: {chexpert_path}")
+
+    metadata_df = pd.read_csv(metadata_path)
+    chexpert_df = pd.read_csv(chexpert_path)
+    chexpert_df[RADIOLOGY_CLASSES] = chexpert_df[RADIOLOGY_CLASSES].fillna(0)
+    chexpert_df = chexpert_df.replace(-1.0, 0.0)
+    metadata_by_dicom = {
+        str(record["dicom_id"]): record for record in metadata_df.to_dict(orient="records")
+    }
+    ap_rows_by_subject: dict[int, list[dict[str, Any]]] = defaultdict(list)
+    for record in metadata_df.to_dict(orient="records"):
+        if str(record.get("ViewPosition") or "").upper() != "AP":
+            continue
+        subject_id = safe_int(record.get("subject_id"))
+        study_id = safe_int(record.get("study_id"))
+        if subject_id is None or study_id is None:
+            continue
+        study_datetime = parse_cxr_datetime(record)
+        if study_datetime is None:
+            continue
+        ap_rows_by_subject[subject_id].append(
+            {
+                "subject_id": subject_id,
+                "study_id": study_id,
+                "dicom_id": str(record.get("dicom_id") or ""),
+                "study_datetime": study_datetime,
+                "view_position": "AP",
+            }
+        )
+    for rows in ap_rows_by_subject.values():
+        rows.sort(key=lambda item: item["study_datetime"])
+    chexpert_by_study: dict[int, list[str]] = {}
+    for record in chexpert_df.to_dict(orient="records"):
+        study_id = safe_int(record.get("study_id"))
+        if study_id is None:
+            continue
+        chexpert_by_study[study_id] = [
+            label for label in RADIOLOGY_CLASSES if safe_float(record.get(label)) == 1.0
+        ]
+    return {
+        "metadata_path": metadata_path,
+        "chexpert_path": chexpert_path,
+        "metadata_df": metadata_df,
+        "chexpert_df": chexpert_df,
+        "metadata_by_dicom": metadata_by_dicom,
+        "ap_rows_by_subject": ap_rows_by_subject,
+        "chexpert_by_study": chexpert_by_study,
+    }
+
+
+def parse_cxr_datetime(record: dict[str, Any]) -> pd.Timestamp | None:
+    date = record.get("StudyDate")
+    time = record.get("StudyTime")
+    if date in (None, "") or time in (None, ""):
+        return None
+    try:
+        time_text = f"{int(float(time)):06d}"
+        return pd.Timestamp(datetime.strptime(f"{int(float(date))} {time_text}", "%Y%m%d %H%M%S"))
+    except (TypeError, ValueError):
+        return None
+
+
+def parse_timestamp(value: Any) -> pd.Timestamp | None:
+    if value in (None, ""):
+        return None
+    try:
+        parsed = pd.Timestamp(value)
+    except (TypeError, ValueError):
+        return None
+    if pd.isna(parsed):
+        return None
+    return parsed
+
+
+def validate_latest_ap_pairing(
+    sample: dict[str, Any],
+    official_row: dict[str, Any] | None,
+    cxr_indexes: dict[str, Any],
+) -> list[str]:
+    if official_row is None:
+        return []
+    task = sample["_canonical_task"]
+    if task == "radiology":
+        return []
+
+    subject_id = safe_int(sample.get("subject_id"))
+    selected_study_ids = {ref["study_id"] for ref in sample["_image_refs"]}
+    intime = parse_timestamp(official_row.get("intime"))
+    prediction_time = parse_timestamp(sample.get("prediction_time") or official_row.get("prediction_time"))
+    if subject_id is None or intime is None or prediction_time is None or not selected_study_ids:
+        return ["pairing_window_unverifiable"]
+
+    in_window = [
+        row
+        for row in cxr_indexes["ap_rows_by_subject"].get(subject_id, [])
+        if row["study_datetime"] >= intime and row["study_datetime"] <= prediction_time
+    ]
+    if not in_window:
+        return ["official_pairing_no_ap_in_window"]
+    latest_time = max(row["study_datetime"] for row in in_window)
+    latest_studies = {row["study_id"] for row in in_window if row["study_datetime"] == latest_time}
+    if selected_study_ids.isdisjoint(latest_studies):
+        return [
+            "official_pairing_latest_ap_mismatch "
+            f"expected_study_ids={sorted(latest_studies)} got={sorted(selected_study_ids)}"
+        ]
+    return []
+
+
+def same_label_set(left: list[str], right: list[str]) -> bool:
+    return set(left) == set(right)
+
+
+def validate_sample(
+    sample: dict[str, Any],
+    *,
+    list_indexes: dict[tuple[str, str], dict[str, Any]],
+    cxr_indexes: dict[str, Any],
+) -> tuple[dict[str, Any], list[str], dict[str, Any] | None, dict[str, Any] | None]:
+    task = sample["_canonical_task"]
+    split = normalize_split(str(sample.get("source_split") or "test"))
+    gt = ground_truth_names(sample)
+    warnings: list[str] = []
+    official_row = None
+    official_source_row = None
+
+    if task == "radiology":
+        study_ids = [ref["study_id"] for ref in sample["_image_refs"]]
+        expected = sorted({label for study_id in study_ids for label in cxr_indexes["chexpert_by_study"].get(study_id, [])})
+        if not same_label_set(gt, expected):
+            warnings.append(f"radiology_label_mismatch expected={expected} got={gt}")
+    else:
+        index = list_indexes[(task, split)]
+        key = sample_key(sample)
+        official_row = index["mml_by_key"].get(key)
+        official_source_row = index["data_by_key"].get(key)
+        if official_row is None:
+            warnings.append(f"missing_official_listfile_row key={key}")
+        else:
+            expected = expected_label_from_listfile(task, official_row)
+            if not same_label_set(gt, expected):
+                warnings.append(f"listfile_label_mismatch expected={expected} got={gt}")
+            for field in ("subject_id", "hadm_id", "prediction_time"):
+                if field in official_row and sample.get(field) is not None:
+                    if str(official_row.get(field)) != str(sample.get(field)):
+                        warnings.append(
+                            f"{field}_mismatch official={official_row.get(field)} got={sample.get(field)}"
+                        )
+            warnings.extend(validate_latest_ap_pairing(sample, official_row, cxr_indexes))
+
+    for image_ref in sample["_image_refs"]:
+        metadata = cxr_indexes["metadata_by_dicom"].get(image_ref["dicom_id"])
+        if metadata is None:
+            warnings.append(f"missing_cxr_metadata dicom_id={image_ref['dicom_id']}")
+            continue
+        if safe_int(metadata.get("study_id")) != image_ref["study_id"]:
+            warnings.append(f"cxr_metadata_study_mismatch dicom_id={image_ref['dicom_id']}")
+        if str(metadata.get("ViewPosition") or "").upper() != "AP":
+            warnings.append(f"cxr_not_ap dicom_id={image_ref['dicom_id']}")
+
+    validation = {
+        "official_match_ok": not warnings,
+        "warnings": warnings,
+    }
+    return validation, warnings, official_row, official_source_row
+
+
+def write_subset_csvs(
+    *,
+    output_root: Path,
+    medmod_repo_root: Path,
+    rows_by_task_split: dict[tuple[str, str], list[dict[str, Any]]],
+    list_indexes: dict[tuple[str, str], dict[str, Any]],
+) -> None:
+    for (task, split), rows in sorted(rows_by_task_split.items()):
+        if task == "radiology":
+            continue
+        index = list_indexes[(task, split)]
+        mml_rows = [row["official_listfile_row"] for row in rows if row.get("official_listfile_row")]
+        data_rows = [row["official_data_full_row"] for row in rows if row.get("official_data_full_row")]
+        mml_out = (
+            output_root
+            / "source_release"
+            / "mml-ssl-full"
+            / task
+            / medmod_listfile_name(split, mml_ssl=True)
+        )
+        ensure_dir(mml_out.parent)
+        pd.DataFrame(mml_rows, columns=index["mml_columns"]).to_csv(mml_out, index=False)
+        if data_rows:
+            data_out = (
+                output_root
+                / "source_release"
+                / "data_full"
+                / task
+                / medmod_listfile_name(split, mml_ssl=False)
+            )
+            ensure_dir(data_out.parent)
+            pd.DataFrame(data_rows, columns=index["data_columns"]).to_csv(data_out, index=False)
+
+    for name in ("README.md", "LICENSE"):
+        src = medmod_repo_root / name
+        if src.exists():
+            link_or_copy(src, output_root / "source_release" / "repo_docs" / name)
+
+
+def write_root_table_subsets(output_root: Path, repo_root: Path, subject_ids: set[int], stay_ids: set[int]) -> None:
+    root_out = output_root / "source_release" / "root_tables"
+    ensure_dir(root_out)
+    for table_name in ("all_stays.csv", "all_diagnoses.csv", "diagnosis_counts.csv", "phenotype_labels.csv"):
+        src = repo_root / "data_full" / "root" / table_name
+        if not src.exists():
+            continue
+        df = pd.read_csv(src)
+        if "subject_id" in df.columns:
+            df = df[df["subject_id"].isin(subject_ids)].copy()
+        if "stay_id" in df.columns and stay_ids:
+            stay_filtered = df[df["stay_id"].isin(stay_ids)].copy()
+            if not stay_filtered.empty:
+                df = stay_filtered
+        df.to_csv(root_out / table_name, index=False)
+
+
+def write_cxr_metadata_subsets(output_root: Path, cxr_meta_root: Path, cxr_indexes: dict[str, Any], image_refs: list[dict[str, Any]]) -> None:
+    meta_out = output_root / "source_release" / "cxr_metadata"
+    ensure_dir(meta_out)
+    dicom_ids = {ref["dicom_id"] for ref in image_refs}
+    study_ids = {ref["study_id"] for ref in image_refs}
+
+    cxr_indexes["metadata_df"][cxr_indexes["metadata_df"]["dicom_id"].isin(dicom_ids)].to_csv(
+        meta_out / "mimic-cxr-2.0.0-metadata.csv", index=False
+    )
+    cxr_indexes["chexpert_df"][cxr_indexes["chexpert_df"]["study_id"].isin(study_ids)].to_csv(
+        meta_out / "mimic-cxr-2.0.0-chexpert.csv", index=False
+    )
+
+    optional_specs = [
+        ("mimic-cxr-2.0.0-split.csv", "dicom_id", dicom_ids),
+        ("mimic-cxr-ehr-split.csv", "dicom_id", dicom_ids),
+    ]
+    for filename, column, values in optional_specs:
+        subset = read_csv_subset(cxr_meta_root / filename, column, values)
+        if not subset.empty:
+            subset.to_csv(meta_out / filename, index=False)
+
+
+def main() -> None:
+    args = parse_args()
+    reset_dir(args.output_root, args.overwrite)
+
+    rows = load_medmod_rows(args.input)
+    if not rows:
+        raise ValueError(f"No MedMod rows found in {args.input}")
+
+    needed_keys_by_index: dict[tuple[str, str], set[tuple[int, float | None]]] = defaultdict(set)
+    for row in rows:
+        task = row["_canonical_task"]
+        if task == "radiology":
+            continue
+        split = normalize_split(str(row.get("source_split") or "test"))
+        needed_keys_by_index[(task, split)].add(sample_key(row))
+
+    list_indexes = {
+        key: load_listfile_index(
+            args.medmod_repo_root,
+            key[0],
+            key[1],
+            needed_keys=needed_keys,
+        )
+        for key, needed_keys in sorted(needed_keys_by_index.items())
+    }
+    cxr_indexes = build_metadata_indexes(args.cxr_meta_root)
+
+    manifest_rows: list[dict[str, Any]] = []
+    rows_by_task_split: dict[tuple[str, str], list[dict[str, Any]]] = defaultdict(list)
+    subject_ids: set[int] = set()
+    stay_ids: set[int] = set()
+    all_image_refs: list[dict[str, Any]] = []
+    stats = Counter()
+    warning_rows: list[dict[str, Any]] = []
+
+    for row in rows:
+        task = row["_canonical_task"]
+        split = normalize_split(str(row.get("source_split") or "test"))
+        validation, warnings, official_row, official_source_row = validate_sample(
+            row,
+            list_indexes=list_indexes,
+            cxr_indexes=cxr_indexes,
+        )
+        if warnings:
+            stats["rows_with_warnings"] += 1
+            warning_rows.append({"qid": row.get("qid"), "warnings": warnings})
+
+        subject_id = safe_int(row.get("subject_id"))
+        stay_id = safe_int(row.get("stay_id"))
+        if subject_id is None:
+            raise ValueError(f"Sample missing subject_id: {row.get('qid')}")
+        subject_ids.add(subject_id)
+        if stay_id is not None:
+            stay_ids.add(stay_id)
+
+        subject_dir, subject_partition = find_subject_dir(args.medmod_repo_root, subject_id)
+        subject_rel = f"source_release/data_full/root/{subject_partition}/{subject_id}"
+        copytree_links(subject_dir, args.output_root / subject_rel)
+
+        official_stay = None
+        if official_row is not None:
+            official_stay = official_row.get("stay")
+        if official_stay is None and official_source_row is not None:
+            official_stay = official_source_row.get("stay")
+        official_stay = str(official_stay) if official_stay not in (None, "") else None
+        official_period = None
+        if official_row is not None:
+            official_period = official_row.get("period_length")
+        if official_period is None and official_source_row is not None:
+            official_period = official_source_row.get("period_length")
+        local_stay = local_episode_filename(subject_id, official_stay)
+        ehr_timeseries_relpath = f"{subject_rel}/{local_stay}" if local_stay else None
+        ehr_episode_relpath = None
+        if local_stay and local_stay.endswith("_timeseries.csv"):
+            candidate_episode = f"{subject_rel}/{local_stay.replace('_timeseries.csv', '.csv')}"
+            if (args.output_root / candidate_episode).exists():
+                ehr_episode_relpath = candidate_episode
+        ehr_task_timeseries_relpath = None
+        if official_stay and task != "radiology":
+            split_dir = task_data_split_dir(split)
+            task_src = args.medmod_repo_root / "data_full" / task / split_dir / official_stay
+            if task_src.exists():
+                ehr_task_timeseries_relpath = (
+                    f"source_release/data_full/{task}/{split_dir}/{official_stay}"
+                )
+                link_or_copy(task_src, args.output_root / ehr_task_timeseries_relpath)
+
+        packaged_images: list[str] = []
+        packaged_reports: list[str] = []
+        raw_images: list[str] = []
+        raw_reports: list[str] = []
+        for image_ref in row["_image_refs"]:
+            all_image_refs.append(image_ref)
+            jpg_src = find_cxr_file(args.cxr_jpg_root, image_ref, "jpg")
+            if jpg_src is None:
+                raise FileNotFoundError(f"Missing CXR JPG for {row.get('qid')}: {image_ref}")
+            jpg_rel = image_ref["nested_relpath"]
+            link_or_copy(jpg_src, args.output_root / jpg_rel)
+            packaged_images.append(jpg_rel)
+            raw_images.append(relpath_or_name(jpg_src, args.cxr_jpg_root))
+
+            txt_src = find_cxr_file(args.cxr_jpg_root, image_ref, "txt") if args.include_reports else None
+            if txt_src is not None:
+                txt_rel = str(Path(jpg_rel).with_suffix(".txt"))
+                link_or_copy(txt_src, args.output_root / txt_rel)
+                packaged_reports.append(txt_rel)
+                raw_reports.append(relpath_or_name(txt_src, args.cxr_jpg_root))
+
+        sidecar = {
+            "qid": row.get("qid"),
+            "source_line_index": row.get("_source_line_index"),
+            "source_index": row.get("source_index"),
+            "task": task,
+            "source_task": row.get("task"),
+            "source_split": split,
+            "subject_id": row.get("subject_id"),
+            "hadm_id": row.get("hadm_id"),
+            "stay_id": row.get("stay_id"),
+            "prediction_time": row.get("prediction_time"),
+            "question": row.get("question"),
+            "released_input_text": row.get("input_text"),
+            "ground_truth": row.get("ground_truth"),
+            "answer_type": row.get("answer_type"),
+            "modalities": row.get("modalities") or ["ehr", "cxr"],
+            "study_ids": [ref["study_id"] for ref in row["_image_refs"]],
+            "dicom_ids": [ref["dicom_id"] for ref in row["_image_refs"]],
+            "packaged_image_relpaths": packaged_images,
+            "packaged_report_relpaths": packaged_reports,
+            "raw_image_source_relpaths": raw_images,
+            "raw_report_source_relpaths": raw_reports,
+            "ehr_subject_relpaths": [subject_rel],
+            "official_stay": official_stay,
+            "official_period_length": official_period,
+            "ehr_timeseries_relpath": ehr_timeseries_relpath,
+            "ehr_episode_relpath": ehr_episode_relpath,
+            "ehr_task_timeseries_relpath": ehr_task_timeseries_relpath,
+            "official_listfile_row": official_row,
+            "official_data_full_row": official_source_row,
+            "official_validation": validation,
+            "raw_join_key": {
+                "stay_id": row.get("stay_id"),
+                "period_length_hours": row.get("_period_length_from_qid"),
+            },
+        }
+        manifest_rows.append(sidecar)
+        rows_by_task_split[(task, split)].append(sidecar)
+        stats[f"task:{task}"] += 1
+        stats[f"split:{split}"] += 1
+
+    write_subset_csvs(
+        output_root=args.output_root,
+        medmod_repo_root=args.medmod_repo_root,
+        rows_by_task_split=rows_by_task_split,
+        list_indexes=list_indexes,
+    )
+    write_root_table_subsets(args.output_root, args.medmod_repo_root, subject_ids, stay_ids)
+    write_cxr_metadata_subsets(args.output_root, args.cxr_meta_root, cxr_indexes, all_image_refs)
+
+    write_jsonl(args.output_root / "linked_manifests" / "all.jsonl", manifest_rows)
+    for (task, split), task_rows in sorted(rows_by_task_split.items()):
+        write_jsonl(args.output_root / "linked_manifests" / task / f"{split}.jsonl", task_rows)
+
+    readme = f"""# ClinSeek-MM-Bench-MedMod-source
+
+This package is the source-aligned MedMod subset used by ClinSeek MM-Bench.
+It contains only the MedMod rows present in `$CLINSEEK_MM_BENCH_JSONL`.
+
+The layout preserves the official MedMod task/listfile style where possible:
+
+- `source_release/mml-ssl-full/<task>/*_listfile.csv`: subset of official MedMod rows.
+- `source_release/data_full/<task>/*_listfile.csv`: subset of original task listfiles when available.
+- `source_release/data_full/root/<split>/<subject_id>/`: official extracted MedMod EHR folders.
+- `source_release/root_tables/`: filtered MedMod root tables kept only for provenance.
+  Some files in this directory contain labels and must not be mounted as runtime
+  EHR tables for agent inference.
+- `source_release/cxr_metadata/`: subset MIMIC-CXR metadata and CheXpert labels.
+- `mimic-cxr/2.0.0/files/...`: packaged JPG files. TXT reports are only included
+  when `--include-reports` is explicitly set.
+- `linked_manifests/`: row-level sidecar manifests with questions, gold labels, and relative paths.
+
+Important: each manifest row records `official_stay`, `ehr_timeseries_relpath`,
+and `ehr_episode_relpath` so downstream rendering can use the exact MedMod
+episode from the official listfile instead of all episodes for the same subject.
+
+Input root contract:
+
+- ClinSeek multimodal input: `$CLINSEEK_MM_BENCH_JSONL`
+- MedMod repository: `$MEDMOD_REPO_ROOT`
+- Raw MIMIC-CXR JPG root: `$MIMIC_CXR_JPG_ROOT`
+- Raw MIMIC-CXR metadata root: `$MIMIC_CXR_META_ROOT`
+- Raw MIMIC-IV latest local release kept for provenance: `$MIMICIV_ROOT`
+"""
+    (args.output_root / "README.md").write_text(readme, encoding="utf-8")
+
+    metadata = {
+        "package_name": "ClinSeek-MM-Bench-MedMod-source",
+        "input": "CLINSEEK_MM_BENCH_JSONL",
+        "records": len(manifest_rows),
+        "subjects": len(subject_ids),
+        "unique_images": len({p for row in manifest_rows for p in row["packaged_image_relpaths"]}),
+        "unique_reports": len({p for row in manifest_rows for p in row["packaged_report_relpaths"]}),
+        "reports_included": bool(args.include_reports),
+        "stats": dict(sorted(stats.items())),
+        "warning_rows": warning_rows,
+        "source_path_env_vars": {
+            "medmod_repo_root": "MEDMOD_REPO_ROOT",
+            "cxr_jpg_root": "MIMIC_CXR_JPG_ROOT",
+            "cxr_meta_root": "MIMIC_CXR_META_ROOT",
+            "mimiciv_root": "MIMICIV_ROOT",
+        },
+        "path_contract": {
+            "manifest_paths": "relative_to_package_root",
+            "packaged_image_relpaths": "relative_to_package_root",
+            "packaged_report_relpaths": "relative_to_package_root",
+            "ehr_subject_relpaths": "relative_to_package_root",
+            "raw_image_source_relpaths": "relative_to_MIMIC_CXR_JPG_ROOT",
+            "raw_report_source_relpaths": "relative_to_MIMIC_CXR_JPG_ROOT",
+        },
+    }
+    write_json(args.output_root / "metadata.json", metadata)
+
+    if warning_rows and args.strict_official_match and not args.allow_warnings:
+        raise SystemExit(
+            f"Built package but found {len(warning_rows)} validation warning rows. "
+            "Inspect metadata.json or rerun without --strict-official-match."
+        )
+    print(json.dumps(metadata, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

rebuild/mm_bench/combine_clinseek_mm_bench.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+"""Combine EHRXQA and MedMod subsets into the ClinSeek-MM-Bench package."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+from pathlib import Path
+from typing import Any
+
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+DEFAULT_REFERENCE_INPUT = Path(
+    os.environ.get(
+        "CLINSEEK_MM_BENCH_JSONL",
+        str(REPO_ROOT / "inputs" / "mm_bench.jsonl"),
+    )
+)
+DEFAULT_EHRXQA_SUBSET_ROOT = Path(
+    os.environ.get("CLINSEEK_EHRXQA_MM_ROOT", "data/build/ClinSeek-MM-Bench-EHRXQA")
+)
+DEFAULT_MEDMOD_SUBSET_ROOT = Path(
+    os.environ.get("CLINSEEK_MEDMOD_MM_ROOT", "data/build/ClinSeek-MM-Bench-MedMod")
+)
+DEFAULT_OUTPUT_ROOT = Path(
+    os.environ.get("CLINSEEK_MM_RELEASE_ROOT", "data/build/ClinSeek-MM-Bench")
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--reference-input", type=Path, default=DEFAULT_REFERENCE_INPUT)
+    parser.add_argument("--ehrxqa-root", type=Path, default=DEFAULT_EHRXQA_SUBSET_ROOT)
+    parser.add_argument("--medmod-root", type=Path, default=DEFAULT_MEDMOD_SUBSET_ROOT)
+    parser.add_argument("--output-root", type=Path, default=DEFAULT_OUTPUT_ROOT)
+    parser.add_argument("--overwrite", action="store_true")
+    return parser.parse_args()
+
+
+def ensure_dir(path: Path) -> None:
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def reset_dir(path: Path, overwrite: bool) -> None:
+    if path.exists():
+        if not overwrite:
+            raise FileExistsError(f"Output root already exists: {path}")
+        shutil.rmtree(path)
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def link_or_copy(src: Path, dst: Path) -> None:
+    src = src.resolve()
+    ensure_dir(dst.parent)
+    if dst.exists():
+        return
+    try:
+        os.link(src, dst)
+    except OSError:
+        shutil.copy2(src, dst)
+
+
+def copytree_links(src: Path, dst: Path) -> None:
+    if not src.exists():
+        raise FileNotFoundError(f"Missing source directory: {src}")
+    if dst.exists():
+        return
+    shutil.copytree(src, dst, copy_function=lambda s, d: (link_or_copy(Path(s), Path(d)) or str(d)))
+
+
+def drop_runtime_sidecars(output_root: Path) -> None:
+    """Keep final data/mm_bench file layout aligned with the HF release tree."""
+    for relpath in (
+        "data/mm_bench/ehrxqa/database/reference_table.db",
+        "data/mm_bench/ehrxqa/metadata.json",
+        "data/mm_bench/medmod/metadata.json",
+    ):
+        path = output_root / relpath
+        if path.exists():
+            path.unlink()
+
+
+def read_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    with path.open("r", encoding="utf-8") as handle:
+        for line in handle:
+            if line.strip():
+                rows.append(json.loads(line))
+    return rows
+
+
+def write_json(path: Path, payload: Any) -> None:
+    ensure_dir(path.parent)
+    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
+def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
+    ensure_dir(path.parent)
+    with path.open("w", encoding="utf-8") as handle:
+        for row in rows:
+            handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n")
+
+
+def load_subset_rows(root: Path, filename: str) -> dict[str, dict[str, Any]]:
+    path = root / "inputs" / filename
+    rows = read_jsonl(path)
+    return {str(row["qid"]): row for row in rows}
+
+
+def main() -> None:
+    args = parse_args()
+    reset_dir(args.output_root, args.overwrite)
+
+    reference_rows = read_jsonl(args.reference_input)
+    ehrxqa_by_qid = load_subset_rows(args.ehrxqa_root, "mm_bench_ehrxqa.jsonl")
+    medmod_by_qid = load_subset_rows(args.medmod_root, "mm_bench_medmod.jsonl")
+    by_qid = {**ehrxqa_by_qid, **medmod_by_qid}
+
+    missing = [row["qid"] for row in reference_rows if row.get("qid") not in by_qid]
+    extra = sorted(set(by_qid) - {row.get("qid") for row in reference_rows})
+    if missing or extra:
+        raise ValueError({"missing": missing[:20], "extra": extra[:20]})
+
+    output_rows = [by_qid[str(row["qid"])] for row in reference_rows]
+    write_jsonl(args.output_root / "inputs" / "mm_bench.jsonl", output_rows)
+
+    copytree_links(
+        args.ehrxqa_root / "data" / "mm_bench" / "ehrxqa",
+        args.output_root / "data" / "mm_bench" / "ehrxqa",
+    )
+    copytree_links(
+        args.medmod_root / "data" / "mm_bench" / "medmod",
+        args.output_root / "data" / "mm_bench" / "medmod",
+    )
+    drop_runtime_sidecars(args.output_root)
+
+    metadata = {
+        "package_name": "ClinSeek-MM-Bench",
+        "reference_input": "CLINSEEK_MM_BENCH_JSONL",
+        "ehrxqa_root": "CLINSEEK_EHRXQA_MM_ROOT",
+        "medmod_root": "CLINSEEK_MEDMOD_MM_ROOT",
+        "records": len(output_rows),
+        "source_counts": {
+            "ehrxqa": len(ehrxqa_by_qid),
+            "medmod": len(medmod_by_qid),
+        },
+        "input_file": "inputs/mm_bench.jsonl",
+        "bench_root": "data/mm_bench",
+    }
+    write_json(args.output_root / "metadata.json", metadata)
+
+    readme = """# ClinSeek-MM-Bench
+
+This package combines the EHRXQA-derived and MedMod-derived subsets into the
+final ClinSeek multimodal benchmark layout.
+
+Use:
+
+- `inputs/mm_bench.jsonl`
+- `data/mm_bench`
+"""
+    (args.output_root / "README.md").write_text(readme, encoding="utf-8")
+    print(json.dumps(metadata, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

rebuild/mm_bench/validate_multimodal_release.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+"""Validate the released ClinSeek multimodal benchmark manifest or package.
+
+The validator checks the ClinSeek-MM-Bench release tree:
+
+- every row in inputs/mm_bench.jsonl has an expected source/task distribution;
+- in package mode, every referenced patient database exists;
+- in package mode, every referenced image/report path resolves under data/mm_bench/<source>/;
+- in manifest-only mode, protected MIMIC-derived assets are not required;
+- optional git-tree mode can validate a Hugging Face repository checkout without
+  downloading all LFS file contents.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Any
+
+
+EXPECTED_SOURCE_COUNTS = {"ehrxqa": 497, "medmod": 492}
+EXPECTED_TASK_COUNTS = {
+    "ehrxqa_image": 497,
+    "medmod_decompensation": 125,
+    "medmod_in_hospital_mortality": 125,
+    "medmod_phenotyping": 120,
+    "medmod_radiology": 122,
+}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--bench-root",
+        type=Path,
+        default=Path("data/ClinSeek-Bench"),
+        help="Root of the ClinSeek-Bench repository or downloaded package.",
+    )
+    parser.add_argument(
+        "--input",
+        type=Path,
+        default=None,
+        help="Optional explicit mm_bench.jsonl path. Defaults to <bench-root>/inputs/mm_bench.jsonl.",
+    )
+    parser.add_argument(
+        "--use-git-tree",
+        action="store_true",
+        help="Validate file presence against git ls-tree instead of local filesystem contents.",
+    )
+    parser.add_argument(
+        "--manifest-only",
+        action="store_true",
+        help="Validate only inputs/mm_bench.jsonl counts/schema and referenced path strings. Do not require DB/JPG/report files.",
+    )
+    parser.add_argument(
+        "--allow-unexpected-counts",
+        action="store_true",
+        help="Do not fail if source/task counts differ from the frozen release counts.",
+    )
+    return parser.parse_args()
+
+
+def read_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    with path.open("r", encoding="utf-8") as handle:
+        for line in handle:
+            if line.strip():
+                rows.append(json.loads(line))
+    return rows
+
+
+def safe_int(value: Any) -> int | None:
+    if value is None or value == "":
+        return None
+    try:
+        return int(float(str(value)))
+    except ValueError:
+        return None
+
+
+def git_tree_paths(root: Path) -> set[str]:
+    output = subprocess.check_output(
+        ["git", "-C", str(root), "ls-tree", "-r", "--name-only", "HEAD"],
+        text=True,
+    )
+    return {line.strip() for line in output.splitlines() if line.strip()}
+
+
+def release_asset_relpath(source: str, raw_path: str) -> str:
+    """Map JSONL asset paths to their release-relative locations.
+
+    The JSONL preserves original package prefixes such as
+    EHRXQAOriginalLinked_v1/ or MedModOriginalLinked_v1/.  The released HF tree
+    stores the actual assets under data/mm_bench/<source>/.
+    """
+    parts = Path(raw_path).parts
+    if parts and parts[0].endswith("OriginalLinked_v1"):
+        parts = parts[1:]
+    return str(Path("data") / "mm_bench" / source / Path(*parts))
+
+
+def exists(path: str, *, root: Path, tree: set[str] | None) -> bool:
+    if tree is not None:
+        return path in tree
+    return (root / path).exists()
+
+
+def validate(args: argparse.Namespace) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    bench_root = args.bench_root
+    input_path = args.input or bench_root / "inputs" / "mm_bench.jsonl"
+    rows = read_jsonl(input_path)
+    tree = git_tree_paths(bench_root) if args.use_git_tree and not args.manifest_only else None
+
+    source_counts = Counter(row.get("source_benchmark") for row in rows)
+    task_counts = Counter(row.get("task") for row in rows)
+    subjects_by_source: dict[str, set[int]] = defaultdict(set)
+    images_by_source: dict[str, set[str]] = defaultdict(set)
+    reports_by_source: dict[str, set[str]] = defaultdict(set)
+
+    errors: list[dict[str, Any]] = []
+    missing_by_kind = Counter()
+
+    for row in rows:
+        qid = row.get("qid")
+        source = str(row.get("source_benchmark") or "")
+        subject_id = safe_int(row.get("subject_id"))
+        if source not in {"ehrxqa", "medmod"}:
+            errors.append({"qid": qid, "kind": "bad_source", "value": source})
+            continue
+        if subject_id is None:
+            errors.append({"qid": qid, "kind": "missing_subject_id"})
+            continue
+
+        subjects_by_source[source].add(subject_id)
+        db_rel = str(Path("data") / "mm_bench" / source / "database" / f"patient_{subject_id}.db")
+        if not args.manifest_only and not exists(db_rel, root=bench_root, tree=tree):
+            missing_by_kind["database"] += 1
+            errors.append({"qid": qid, "kind": "missing_database", "path": db_rel})
+
+        for raw_path in row.get("image_paths") or []:
+            rel = release_asset_relpath(source, str(raw_path))
+            images_by_source[source].add(rel)
+            if not args.manifest_only and not exists(rel, root=bench_root, tree=tree):
+                missing_by_kind["image"] += 1
+                errors.append({"qid": qid, "kind": "missing_image", "path": rel})
+
+        for raw_path in row.get("report_paths") or []:
+            rel = release_asset_relpath(source, str(raw_path))
+            reports_by_source[source].add(rel)
+            if not args.manifest_only and not exists(rel, root=bench_root, tree=tree):
+                missing_by_kind["report"] += 1
+                errors.append({"qid": qid, "kind": "missing_report", "path": rel})
+
+    if not args.allow_unexpected_counts:
+        if dict(source_counts) != EXPECTED_SOURCE_COUNTS:
+            errors.append(
+                {
+                    "kind": "unexpected_source_counts",
+                    "actual": dict(source_counts),
+                    "expected": EXPECTED_SOURCE_COUNTS,
+                }
+            )
+        if dict(task_counts) != EXPECTED_TASK_COUNTS:
+            errors.append(
+                {
+                    "kind": "unexpected_task_counts",
+                    "actual": dict(task_counts),
+                    "expected": EXPECTED_TASK_COUNTS,
+                }
+            )
+
+    summary = {
+        "rows": len(rows),
+        "source_counts": dict(source_counts),
+        "task_counts": dict(task_counts),
+        "subjects": {key: len(value) for key, value in subjects_by_source.items()},
+        "unique_images": {key: len(value) for key, value in images_by_source.items()},
+        "unique_reports": {key: len(value) for key, value in reports_by_source.items()},
+        "missing_by_kind": dict(missing_by_kind),
+        "error_count": len(errors),
+        "validated_against": "manifest_only"
+        if args.manifest_only
+        else ("git_tree" if args.use_git_tree else "filesystem"),
+        "bench_root": str(bench_root),
+        "input": str(input_path),
+    }
+    return summary, errors
+
+
+def main() -> int:
+    args = parse_args()
+    summary, errors = validate(args)
+    print(json.dumps(summary, ensure_ascii=False, indent=2))
+    if errors:
+        print("First errors:", file=sys.stderr)
+        for error in errors[:20]:
+            print(json.dumps(error, ensure_ascii=False), file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())