feat(researcher): DCE-MRI BBB permeability bridge + drug-dose adjuster

Adds the only legitimate BBB <-> MRI bridge in the platform — researcher
lane only. Fusion engine still excludes BBB as a diagnostic modality.

Modules:
- src/models/bbb_permeability_map.py: scalar BBB leakage score in [0,1]
with two modes. heuristic_proxy (default) reuses the 2D resnet18
Alzheimer classifier and computes 1 - P(NonDemented). dce_onnx loads
a real 4D DCE-MRI ONNX model from BBB_PERMEABILITY_DCE_PATH and
averages a normalised Ktrans map; raises a clear FileNotFoundError
with contract documentation when no artifact exists.
- src/research/drug_dose_adjuster.py: pure-function dose revision keyed
on (BBB intact?, drug BBB-permeable?). Permeable drugs see an
aggressive linear cut floored at 30%; non-permeable drugs see a mild
cut floored at 60%; intact BBB returns baseline unchanged. Unknown
drug permeability is treated as permeable (safer). Rationale always
includes the 'research suggestion, not medical advice' disclaimer.

API:
- POST /predict/bbb_permeability_map (request: input_path + mode)
- POST /research/drug_dose_adjustment (request: smiles? + baseline_dose
+ bbb_score + drug_permeable?). When smiles is provided, the BBB
classifier auto-resolves drug_permeable, closing the researcher loop
end-to-end.
- New research_router mounted in src/api/main.py.

Agent tools (orchestrator-callable):
- compute_bbb_leakage_score (wraps the BBB permeability route)
- adjust_drug_dose (wraps the dose-adjustment route, BBB classifier
auto-resolves drug permeability when smiles is given)

Frontend:
- New 'Researcher' Streamlit tab with a 2-column flow: BBB leakage
scorer on the left, dose-adjuster on the right, with risk-level
emoji and rationale card.

Tests: 361 passed, 2 skipped (was 330+2; +31 tests, 0 regressions).
- tests/models/test_bbb_permeability_map.py: heuristic_proxy + DCE
contract; case-insensitive label matching; threshold semantics.
- tests/research/test_drug_dose_adjuster.py: all four (BBB x drug-perm)
quadrants; safety floors; monotonicity; rationale disclaimer; pydantic
validation edges.
- tests/api/test_bbb_research_routes.py: both new routes end-to-end.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

README.md

@@ -42,6 +42,7 @@ short_description: Living decision system for BBB, EEG, and MRI clinical ML
 | 9 | Agent/RAG hardening + MRI DL decision layer | Guarded orchestration + `POST /predict/mri` ONNX surface | Shipped — 242 passed, 2 skipped |
 | 10 | Multi-modal fusion engine | `POST /fusion/predict` + `run_fusion` agent tool — MRI + EEG + clinical scores → per-disease confidence with attribution | Shipped — 295 passed, 1 skipped |
 | 11 | External assets integration | 2D resnet18 MRI Alzheimer's path · TF-IDF clinical RAG with TR query expansion · stub-able EEG pretrained classifier | Shipped — 330 passed, 2 skipped |
+| 12 | DCE-MRI BBB bridge + drug-dose adjuster | `POST /predict/bbb_permeability_map` (heuristic_proxy or dce_onnx) + `POST /research/drug_dose_adjustment` + Researcher Streamlit tab + `compute_bbb_leakage_score` & `adjust_drug_dose` agent tools | Shipped |
 
 ### Fusion Engine
 
@@ -96,6 +97,49 @@ The Turkish keywords `alzheimer`, `parkinson`, `egzersiz`, `beslenme`,
 `tani`, `tedavi`, `risk`, `unutkanlik`, `titreme`, `demans` auto-expand
 to English equivalents so Turkish queries hit English chunks.
 
+### DCE-MRI BBB Bridge + Drug-Dose Adjuster (Researcher persona)
+
+Clinical fact: Dynamic Contrast-Enhanced (DCE) MRI measures BBB leakage by
+tracking gadolinium contrast washout. A leaky BBB lets drugs cross into
+the brain at unsafe levels, so concentrations need revising.
+
+This is the **only legitimate place where BBB and MRI couple** in the
+platform — the Researcher lane only. The fusion engine's "BBB is NOT a
+diagnostic modality" rule is preserved.
+
+**`POST /predict/bbb_permeability_map`** — two modes:
+
+- `heuristic_proxy` (default, demo-ready): reuses the 2D resnet18
+  Alzheimer's classifier; score = `1 - P(NonDemented)`. Anchored in the
+  published correlation between disease severity and BBB breakdown.
+- `dce_onnx` (real DCE artifact, swap-in later): loads an ONNX model
+  trained on 4D DCE-MRI data, emits a Ktrans map normalised to `[0, 1]`.
+  Drop the artifact at `data/processed/bbb_permeability_dce.onnx` (or set
+  `BBB_PERMEABILITY_DCE_PATH`).
+
+**`POST /research/drug_dose_adjustment`** — pure-function logic:
+
+| BBB score | Drug BBB-permeable | Recommended dose |
+|---|---|---|
+| < 0.20 (intact) | any | 100% of baseline (low risk) |
+| ≥ 0.20 (leaky) | yes | `max(30%, 1 − 0.7·score)` of baseline (moderate / high risk) |
+| ≥ 0.20 (leaky) | no | `max(60%, 1 − 0.4·score)` of baseline (moderate risk) |
+| ≥ 0.20 (leaky) | unknown | treated as permeable (safer assumption) |
+
+When `smiles` is supplied, the BBB classifier auto-resolves the drug's
+permeability — closes the researcher loop end-to-end. The rationale always
+includes the sentence "Research suggestion, not medical advice."
+
+Streamlit `Researcher` tab combines both into a single 2-column flow:
+left side picks an MRI image and runs the leakage scorer; right side
+takes a SMILES + baseline dose and computes a revised dose with risk
+badge and rationale card.
+
+Agent tools (orchestrator-callable):
+
+- `compute_bbb_leakage_score` — wraps `/predict/bbb_permeability_map`.
+- `adjust_drug_dose` — wraps `/research/drug_dose_adjustment`.
+
 ### EEG Pretrained Classifier (stub-able for demo)
 
 `POST /predict/eeg` runs an sklearn-style classifier (any `predict_proba`

docs/superpowers/plans/2026-05-02-bbb-mri-bridge-and-dose-adjuster.md

@@ -0,0 +1,72 @@
+# BBB ↔ MRI Bridge + Drug-Dose Adjuster — Implementation Notes
+
+> Implemented inline on `feat/external-assets-integration`. This document is the design record.
+
+## Why
+
+Clinical fact: **DCE-MRI** (Dynamic Contrast-Enhanced MRI) measures BBB leakage by tracking gadolinium contrast washout — Ktrans, Kep, Ve maps. Compromised BBB lets molecules cross into the brain that normally wouldn't. Two consequences:
+
+1. A "BBB Permeability Map" or scalar score from a patient's MRI is the **primary data point for the researcher persona**.
+2. **If the BBB is leaky, drug concentrations need revising** — a CNS-permeable drug crosses too easily; even a non-CNS drug may now reach the brain at unsafe levels.
+
+This plan adds both: the bridge (MRI → BBB permeability score) and the adjuster (drug dose revision based on the score).
+
+## Independence
+
+This is the **only legitimate place BBB and MRI couple** in the platform — and it sits in the **researcher** lane, not the doctor's diagnostic lane. The fusion engine's "BBB is NOT a fusion modality" rule is preserved: this bridge does not feed into Alzheimer's/Parkinson's confidence.
+
+## Architecture (two modules + two routes + two agent tools)
+
+```
+src/models/bbb_permeability_map.py    pure-Python scorer with two modes
+src/research/drug_dose_adjuster.py    pure-function dose revision logic
+
+POST /predict/bbb_permeability_map     {input_path, mode} -> {score, interpretation, method}
+POST /research/drug_dose_adjustment    {smiles?, baseline_dose_mg, bbb_score, drug_permeable?}
+                                       -> {recommended_dose_mg, factor, risk_level, rationale}
+
+agent tool: compute_bbb_leakage_score
+agent tool: adjust_drug_dose
+```
+
+### Permeability scoring modes
+
+- **`heuristic_proxy`** (default, demo-ready). Uses the existing 2D resnet18 4-class
+  classifier's class probabilities. Score = `1 - P(NonDemented)` — published
+  literature shows BBB breakdown correlates with disease severity. Auditable
+  and demonstrable today.
+- **`dce_onnx`** (real-DCE artifact, swap-in later). Loads an ONNX model from
+  `data/processed/bbb_permeability_dce.onnx` (env: `BBB_PERMEABILITY_DCE_PATH`).
+  Contract: input 4D NIfTI `(X, Y, Z, T)`, output a 3D Ktrans map normalized
+  to `[0, 1]`. Stub for now; works when artifact lands.
+
+### Dose-adjustment math
+
+`adjust(baseline_mg, perm_score, drug_permeable, safety_factor=0.5)`:
+
+| BBB intact (score < 0.2) | any drug | factor=1.0, risk=low |
+| BBB leaky, drug permeable | factor = max(0.3, 1 - 0.7·score), risk = high if score > 0.6 else moderate |
+| BBB leaky, drug NOT permeable | factor = max(0.6, 1 - 0.4·score), risk = moderate |
+| drug_permeable=None (unknown) | treat as permeable (safer assumption) |
+
+The adjuster is a **pure function**. The route can optionally call `bbb_model.predict_one(smiles)` to populate `drug_permeable` from the existing BBB classifier — closing the researcher loop end-to-end.
+
+## Tests
+
+- `tests/models/test_bbb_permeability_map.py` — heuristic-proxy correctness, mode dispatch, missing-artifact errors.
+- `tests/research/test_drug_dose_adjuster.py` — all four (BBB × drug-permeability) quadrants, monotonicity, safety-floor invariants.
+- `tests/api/test_bbb_research_routes.py` — both new routes end-to-end.
+
+## What this does NOT do
+
+- Does not retrain anything.
+- Does not compute real Ktrans/Kep/Ve from DCE data — that requires a 4D pharmacokinetic model we don't ship. The `dce_onnx` mode is a contract for an external trainer.
+- Does not feed into the fusion engine. Researcher-only flow.
+- Does not prescribe — the rationale string explicitly says "research suggestion, not medical advice".
+
+## Demo path
+
+1. Researcher pastes a SMILES (e.g., `CCO`) and a baseline dose (e.g., `200 mg`).
+2. Researcher uploads/picks an MRI image.
+3. Streamlit calls `/predict/mri` (resnet18_2d if active, else volumetric ONNX) → BBB classifier on SMILES → `/research/drug_dose_adjustment`.
+4. Card shows: BBB leakage gauge, drug BBB permeability badge, recommended dose with adjustment factor, plain-language rationale.

src/agents/schemas.py

@@ -34,6 +34,40 @@ class MRIPipelineInput(BaseModel):
     )
 
 
+class BBBPermeabilityMapInput(BaseModel):
+    """Input for `compute_bbb_leakage_score` — MRI input + scoring mode."""
+    input_path: str = Field(..., description="Path to MRI input (2D image for heuristic_proxy; 4D NIfTI for dce_onnx).")
+    mode: Literal["heuristic_proxy", "dce_onnx"] = Field(
+        "heuristic_proxy",
+        description="'heuristic_proxy' (default) | 'dce_onnx' (real DCE artifact)",
+    )
+
+
+class BBBPermeabilityMapOutput(BaseModel):
+    permeability_score: float
+    interpretation: str
+    method: str
+    voxel_map_available: bool
+
+
+class DrugDoseAdjustmentInput(BaseModel):
+    """Input for `adjust_drug_dose` — baseline + patient + drug profile."""
+    baseline_dose_mg: float = Field(..., gt=0.0)
+    bbb_permeability_score: float = Field(..., ge=0.0, le=1.0)
+    drug_bbb_permeable: bool | None = None
+    smiles: str | None = Field(
+        None, description="Optional SMILES; auto-resolves drug_bbb_permeable when given.",
+    )
+
+
+class DrugDoseAdjustmentOutput(BaseModel):
+    recommended_dose_mg: float
+    adjustment_factor: float
+    risk_level: str
+    rationale: str
+    drug_bbb_permeable: bool | None = None
+
+
 class RetrieveContextInput(BaseModel):
     """Input for `retrieve_context` — natural-language query into the KB."""
     query: str = Field(..., min_length=2, description="Search query for the knowledge base")

src/agents/tools.py

@@ -1,7 +1,7 @@
 """Tool dataclass + registry. Wraps each pipeline + the RAG retriever as a
 function-callable tool the orchestrator can invoke.
 
-Public entry: `build_default_tools(rag_index_dir)` returns the 5 tools.
+Public entry: `build_default_tools(rag_index_dir)` returns the 7 tools.
 """
 from __future__ import annotations
 
@@ -12,8 +12,12 @@ from typing import Any, Callable
 from pydantic import BaseModel, ValidationError
 
 from src.agents.schemas import (
+    BBBPermeabilityMapInput,
+    BBBPermeabilityMapOutput,
     BBBPipelineInput,
     BBBPipelineOutput,
+    DrugDoseAdjustmentInput,
+    DrugDoseAdjustmentOutput,
     EEGPipelineInput,
     EEGPipelineOutput,
     MRIPipelineInput,
@@ -203,6 +207,59 @@ def _make_retrieve_executor(
     return execute
 
 
+def _make_bbb_permeability_executor() -> Callable[[BBBPermeabilityMapInput], BBBPermeabilityMapOutput]:
+    def execute(inp: BBBPermeabilityMapInput) -> BBBPermeabilityMapOutput:
+        from src.models import bbb_permeability_map as bbb_perm
+        result = bbb_perm.compute_permeability(
+            input_path=Path(inp.input_path),
+            mode=inp.mode,
+        )
+        return BBBPermeabilityMapOutput(
+            permeability_score=float(result["permeability_score"]),
+            interpretation=str(result["interpretation"]),
+            method=str(result["method"]),
+            voxel_map_available=bool(result.get("voxel_map_available", False)),
+        )
+
+    return execute
+
+
+def _make_dose_adjuster_executor() -> Callable[[DrugDoseAdjustmentInput], DrugDoseAdjustmentOutput]:
+    def execute(inp: DrugDoseAdjustmentInput) -> DrugDoseAdjustmentOutput:
+        from src.research import drug_dose_adjuster
+
+        drug_permeable = inp.drug_bbb_permeable
+        if inp.smiles:
+            try:
+                from src.models import bbb_model
+                import os as _os
+                artifact = Path(_os.environ.get("BBB_MODEL_PATH", "data/processed/bbb_model.pkl"))
+                if artifact.exists():
+                    model = bbb_model.load_model(artifact)
+                    pred = bbb_model.predict_one(model, inp.smiles)
+                    drug_permeable = bool(pred["label"] == 1)
+            except (FileNotFoundError, ValueError, KeyError) as e:
+                logger.warning(
+                    "agent dose-adjuster could not auto-resolve BBB for smiles=%s: %s",
+                    inp.smiles, e,
+                )
+
+        adj = drug_dose_adjuster.adjust(
+            baseline_dose_mg=inp.baseline_dose_mg,
+            bbb_permeability_score=inp.bbb_permeability_score,
+            drug_bbb_permeable=drug_permeable,
+        )
+        return DrugDoseAdjustmentOutput(
+            recommended_dose_mg=adj.recommended_dose_mg,
+            adjustment_factor=adj.adjustment_factor,
+            risk_level=adj.risk_level,
+            rationale=adj.rationale,
+            drug_bbb_permeable=drug_permeable,
+        )
+
+    return execute
+
+
 def build_default_tools(
     rag_index_dir: Path | None,
     processed_dir: Path = Path("data/processed"),
@@ -272,4 +329,29 @@ def build_default_tools(
             output_model=FusionOutput,
             execute=lambda inp: fuse_engine(inp),
         ),
+        Tool(
+            name="compute_bbb_leakage_score",
+            description=(
+                "Researcher-only. Compute a BBB permeability score (0..1) "
+                "from a patient MRI. Mode 'heuristic_proxy' (default) uses "
+                "the 2D Alzheimer's classifier; 'dce_onnx' uses a real DCE "
+                "ONNX model when available."
+            ),
+            input_model=BBBPermeabilityMapInput,
+            output_model=BBBPermeabilityMapOutput,
+            execute=_make_bbb_permeability_executor(),
+        ),
+        Tool(
+            name="adjust_drug_dose",
+            description=(
+                "Researcher-only. Suggest a revised drug dose given the patient's "
+                "BBB permeability score and the drug's BBB classification. If "
+                "smiles is supplied, the BBB classifier auto-resolves whether "
+                "the drug crosses the BBB. Output is a research suggestion, "
+                "NOT medical advice."
+            ),
+            input_model=DrugDoseAdjustmentInput,
+            output_model=DrugDoseAdjustmentOutput,
+            execute=_make_dose_adjuster_executor(),
+        ),
     ]

src/api/main.py

@@ -12,7 +12,8 @@ from src.api.routes import (
     explain_router,
     experiments_router,
     agent_router,
-    fusion_router,   # NEW
+    fusion_router,
+    research_router,
 )
 from src.api.schemas import HealthResponse
 
@@ -28,6 +29,7 @@ app.include_router(explain_router)
 app.include_router(experiments_router)
 app.include_router(agent_router)
 app.include_router(fusion_router)
+app.include_router(research_router)
 
 
 @app.get("/health", response_model=HealthResponse)

src/api/routes.py

@@ -27,6 +27,10 @@ from src.api.schemas import (
     BBBPredictResponse,
     BBBRequest,
     CalibrationContext,
+    BBBPermeabilityMapRequest,
+    BBBPermeabilityMapResponse,
+    DrugDoseAdjustmentRequest,
+    DrugDoseAdjustmentResponse,
     EEGClassProbability,
     EEGExplainRequest,
     EEGPredictRequest,
@@ -63,6 +67,7 @@ router = APIRouter(prefix="/pipeline")
 predict_router = APIRouter(prefix="/predict")
 explain_router = APIRouter(prefix="/explain")
 experiments_router = APIRouter(prefix="/experiments")
+research_router = APIRouter(prefix="/research")
 
 
 def _wrap(
@@ -320,6 +325,79 @@ def predict_bbb(req: BBBPredictRequest) -> BBBPredictResponse:
     )
 
 
+@predict_router.post("/bbb_permeability_map", response_model=BBBPermeabilityMapResponse)
+def predict_bbb_permeability_map(req: BBBPermeabilityMapRequest) -> BBBPermeabilityMapResponse:
+    """Compute a BBB permeability score from MRI input.
+
+    Two modes:
+    - heuristic_proxy (default): reuses the 2D resnet18 4-class classifier;
+      score = 1 - P(NonDemented). Demo-ready today.
+    - dce_onnx (real DCE artifact): loads an ONNX model trained on 4D DCE
+      data; emits a Ktrans map normalised to [0, 1]. Stub — drop the real
+      artifact at data/processed/bbb_permeability_dce.onnx (or set
+      BBB_PERMEABILITY_DCE_PATH).
+
+    Researcher-persona route — does NOT feed into the fusion engine.
+    """
+    from src.models import bbb_permeability_map as bbb_perm
+
+    try:
+        result = bbb_perm.compute_permeability(
+            input_path=Path(req.input_path),
+            mode=req.mode,  # type: ignore[arg-type]
+        )
+    except FileNotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+    return BBBPermeabilityMapResponse(
+        permeability_score=float(result["permeability_score"]),
+        interpretation=str(result["interpretation"]),
+        method=str(result["method"]),
+        voxel_map_available=bool(result.get("voxel_map_available", False)),
+    )
+
+
+@research_router.post("/drug_dose_adjustment", response_model=DrugDoseAdjustmentResponse)
+def research_drug_dose_adjustment(req: DrugDoseAdjustmentRequest) -> DrugDoseAdjustmentResponse:
+    """Suggest a revised drug dose given patient BBB permeability + drug profile.
+
+    If `smiles` is supplied, the BBB classifier is consulted to populate
+    `drug_bbb_permeable` (overriding any explicit value). Researcher-persona
+    route — output is a research suggestion, NOT medical advice.
+    """
+    from src.research import drug_dose_adjuster
+
+    drug_permeable: bool | None = req.drug_bbb_permeable
+    if req.smiles:
+        try:
+            artifact = _bbb_model_path()
+            if artifact.exists():
+                model = bbb_model.load_model(artifact)
+                bbb_pred = bbb_model.predict_one(model, req.smiles)
+                drug_permeable = bool(bbb_pred["label"] == 1)
+        except (FileNotFoundError, ValueError, KeyError) as e:
+            logger.warning("could not auto-resolve BBB permeability for smiles=%s: %s", req.smiles, e)
+
+    try:
+        adj = drug_dose_adjuster.adjust(
+            baseline_dose_mg=req.baseline_dose_mg,
+            bbb_permeability_score=req.bbb_permeability_score,
+            drug_bbb_permeable=drug_permeable,
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+    return DrugDoseAdjustmentResponse(
+        recommended_dose_mg=adj.recommended_dose_mg,
+        adjustment_factor=adj.adjustment_factor,
+        risk_level=adj.risk_level,
+        rationale=adj.rationale,
+        drug_bbb_permeable=drug_permeable,
+    )
+
+
 @predict_router.post("/eeg", response_model=EEGPredictResponse)
 def predict_eeg(req: EEGPredictRequest) -> EEGPredictResponse:
     """Predict from EEG features using an externally-trained sklearn classifier.

src/api/schemas.py

@@ -113,6 +113,61 @@ class BBBPredictResponse(BaseModel):
     )
 
 
+class BBBPermeabilityMapRequest(BaseModel):
+    """Compute a per-patient BBB permeability score from MRI input."""
+    input_path: str = Field(
+        ...,
+        description=(
+            "Path to MRI input. heuristic_proxy mode: 2D image (.png/.jpg) "
+            "consumed by the resnet18 4-class Alzheimer's classifier. "
+            "dce_onnx mode: 4D NIfTI (X,Y,Z,T) for the DCE Ktrans pipeline."
+        ),
+    )
+    mode: str = Field(
+        "heuristic_proxy",
+        description="'heuristic_proxy' (default, demo-ready) | 'dce_onnx' (real DCE artifact)",
+    )
+
+
+class BBBPermeabilityMapResponse(BaseModel):
+    """Researcher-persona BBB leakage payload."""
+    permeability_score: float = Field(..., ge=0.0, le=1.0,
+        description="Scalar in [0,1]; 0=intact, 1=fully leaky.")
+    interpretation: str = Field(..., description="'BBB intact' | 'mild leakage' | 'moderate leakage' | 'severe leakage'")
+    method: str = Field(..., description="'heuristic_proxy' | 'dce_onnx'")
+    voxel_map_available: bool = False
+
+
+class DrugDoseAdjustmentRequest(BaseModel):
+    """Researcher-persona dose-revision request, given patient BBB + drug profile."""
+    smiles: str | None = Field(
+        None,
+        description=(
+            "Optional SMILES. When provided, the route auto-resolves "
+            "drug_bbb_permeable via the BBB classifier (overrides any "
+            "explicit value below)."
+        ),
+    )
+    baseline_dose_mg: float = Field(..., gt=0.0, description="Standard adult dose in mg.")
+    bbb_permeability_score: float = Field(..., ge=0.0, le=1.0)
+    drug_bbb_permeable: bool | None = Field(
+        None,
+        description="If known, whether the drug crosses the BBB. Auto-resolved when smiles is given.",
+    )
+
+
+class DrugDoseAdjustmentResponse(BaseModel):
+    """Recommended dose with rationale. NOT medical advice."""
+    recommended_dose_mg: float
+    adjustment_factor: float = Field(..., ge=0.0, le=1.0)
+    risk_level: str = Field(..., description="'low' | 'moderate' | 'high'")
+    rationale: str
+    drug_bbb_permeable: bool | None = Field(
+        None,
+        description="Echoed back; reflects what was used in the calculation (auto-resolved if smiles was given).",
+    )
+
+
 class EEGPredictRequest(BaseModel):
     """Single-subject EEG-features prediction request."""
     features: list[float] = Field(

src/frontend/app.py

@@ -1678,6 +1678,94 @@ def _render_combat_diagnostics(result: dict) -> None:
                     st.error(f"Cannot reach FastAPI: {e!r}")
 
 
+def _render_researcher_tab() -> None:
+    """Drug researcher view: BBB permeability map + dose adjustment."""
+    st.markdown("### Drug Researcher")
+    st.caption(
+        "DCE-MRI inspired BBB leakage score → revised dose suggestion. "
+        "Output is a research signal, NOT medical advice."
+    )
+
+    col_left, col_right = st.columns(2)
+    with col_left:
+        st.markdown("**1. Patient BBB permeability**")
+        mri_path = st.text_input(
+            "MRI image path (server-side)",
+            "tests/fixtures/mri_sample/subject_0_axial.png",
+            key="researcher_mri_path",
+        )
+        mode = st.selectbox(
+            "Scoring mode",
+            ["heuristic_proxy", "dce_onnx"],
+            index=0,
+            key="researcher_perm_mode",
+            help="heuristic_proxy uses the 2D classifier; dce_onnx requires a trained DCE artifact.",
+        )
+        if st.button("Compute BBB leakage score", key="researcher_compute_perm"):
+            with st.spinner("Running BBB permeability scorer..."):
+                try:
+                    result = _post(
+                        "/predict/bbb_permeability_map",
+                        {"input_path": mri_path, "mode": mode},
+                        timeout=60.0,
+                    )
+                except httpx.HTTPStatusError as e:
+                    st.error(f"BBB permeability failed (HTTP {e.response.status_code}): {e.response.text}")
+                except httpx.RequestError as e:
+                    st.error(f"Cannot reach FastAPI: {e!r}")
+                else:
+                    st.session_state["researcher_perm"] = result
+                    st.metric(
+                        label=result.get("interpretation", "BBB"),
+                        value=f"{float(result['permeability_score']) * 100:.1f}%",
+                        help=f"method={result.get('method', '?')}",
+                    )
+
+    with col_right:
+        st.markdown("**2. Drug + baseline dose**")
+        smiles = st.text_input("SMILES", "CCO", key="researcher_smiles")
+        baseline = st.number_input(
+            "Baseline dose (mg)",
+            min_value=0.1, max_value=2000.0, value=100.0, step=10.0,
+            key="researcher_baseline",
+        )
+        score_default = float(
+            st.session_state.get("researcher_perm", {}).get("permeability_score", 0.0)
+        )
+        score = st.number_input(
+            "BBB permeability score",
+            min_value=0.0, max_value=1.0, value=score_default, step=0.05,
+            key="researcher_score",
+            help="Auto-fills from the BBB leakage score above; override manually if you want.",
+        )
+        if st.button("Suggest revised dose", key="researcher_compute_dose"):
+            payload = {
+                "smiles": smiles or None,
+                "baseline_dose_mg": float(baseline),
+                "bbb_permeability_score": float(score),
+            }
+            with st.spinner("Computing dose adjustment..."):
+                try:
+                    result = _post("/research/drug_dose_adjustment", payload, timeout=30.0)
+                except httpx.HTTPStatusError as e:
+                    st.error(f"Dose adjustment failed (HTTP {e.response.status_code}): {e.response.text}")
+                except httpx.RequestError as e:
+                    st.error(f"Cannot reach FastAPI: {e!r}")
+                else:
+                    risk = result.get("risk_level", "unknown")
+                    risk_emoji = {"low": "🟢", "moderate": "🟡", "high": "🔴"}.get(risk, "⚪️")
+                    st.metric(
+                        label=f"{risk_emoji} Recommended dose",
+                        value=f"{result['recommended_dose_mg']:.1f} mg",
+                        delta=f"{(result['adjustment_factor'] - 1.0) * 100:+.0f}%",
+                        delta_color="inverse",
+                    )
+                    drug_perm = result.get("drug_bbb_permeable")
+                    if drug_perm is not None:
+                        st.caption(f"Drug BBB-permeable: **{drug_perm}**")
+                    st.info(result.get("rationale", ""))
+
+
 def _render_ai_assistant_tab() -> None:
     """Chat-style explainer for the most recent BBB prediction."""
     _render_section(
@@ -1889,10 +1977,11 @@ def main() -> None:
             "Run `uvicorn src.api.main:app --port 8000` or `docker compose up`."
         )
 
-    bbb_tab, eeg_tab, mri_tab, assistant_tab, experiments_tab, agent_tab = st.tabs([
+    bbb_tab, eeg_tab, mri_tab, researcher_tab, assistant_tab, experiments_tab, agent_tab = st.tabs([
         "Molecule",
         "Signal",
         "Image",
+        "Researcher",
         "AI Assistant",
         "Experiments",
         "🤖 Agent",
@@ -1904,6 +1993,8 @@ def main() -> None:
         _render_eeg_tab()
     with mri_tab:
         _render_mri_tab()
+    with researcher_tab:
+        _render_researcher_tab()
     with assistant_tab:
         _render_ai_assistant_tab()
     with experiments_tab:

src/models/bbb_permeability_map.py

@@ -0,0 +1,146 @@
+"""BBB Permeability Map / Score from MRI input.
+
+Two modes:
+- `heuristic_proxy` (default, demo-ready): reuses the 2D resnet18 4-class
+  Alzheimer's classifier output. Score = 1 - P(NonDemented). Anchored in the
+  published correlation between disease severity and BBB breakdown.
+- `dce_onnx` (real-DCE artifact, future): loads an ONNX model trained on
+  4D DCE-MRI inputs that emit per-voxel Ktrans maps. Stub for now; works
+  when the artifact drops in.
+
+Researcher-persona module. Does NOT feed into the fusion engine — fusion's
+'BBB is NOT a modality' rule is preserved. The only legitimate place where
+BBB and MRI couple in this platform.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any, Literal
+
+import numpy as np
+
+from src.core.logger import get_logger
+
+logger = get_logger(__name__)
+
+PermeabilityMode = Literal["heuristic_proxy", "dce_onnx"]
+DEFAULT_MODE: PermeabilityMode = "heuristic_proxy"
+
+
+def _interpret(score: float) -> str:
+    if score < 0.2:
+        return "BBB intact"
+    if score < 0.4:
+        return "mild leakage"
+    if score < 0.7:
+        return "moderate leakage"
+    return "severe leakage"
+
+
+def compute_from_classifier_probs(probabilities: list[dict[str, Any]]) -> float:
+    """Heuristic: 1 - P(NonDemented) from a 4-class probability list.
+
+    Accepts the standard prediction-dict shape used across this repo
+    (`probabilities=[{"label_text", "probability"}, ...]`).
+    """
+    p_nondemented = 0.0
+    for entry in probabilities:
+        if str(entry.get("label_text", "")).lower() == "nondemented":
+            p_nondemented = float(entry.get("probability", 0.0))
+            break
+    score = max(0.0, min(1.0, 1.0 - p_nondemented))
+    return float(score)
+
+
+def heuristic_proxy_score(input_path: Path, checkpoint_path: Path) -> dict[str, Any]:
+    """Run the 2D resnet18 classifier and derive the permeability score from
+    its NonDemented probability.
+    """
+    from src.models import mri_dl_2d
+
+    model = mri_dl_2d.load(checkpoint_path)
+    pred = mri_dl_2d.predict_image(model, input_path)
+    score = compute_from_classifier_probs(pred["probabilities"])
+    return {
+        "permeability_score": score,
+        "interpretation": _interpret(score),
+        "method": "heuristic_proxy",
+        "voxel_map_available": False,
+        "source_class_probabilities": pred["probabilities"],
+    }
+
+
+def dce_onnx_score(input_path: Path, checkpoint_path: Path) -> dict[str, Any]:
+    """Load a DCE-MRI ONNX model and compute per-voxel Ktrans → scalar score.
+
+    Contract for the future artifact:
+    - Input: 4D NIfTI `(X, Y, Z, T)` with at least one timepoint.
+    - Output: 3D Ktrans map (mL/min/100g). We normalise to `[0, 1]` by
+      dividing by a clinically-conservative cap (`_DCE_KTRANS_CAP_MAX`)
+      and clipping. Mean over the brain mask becomes the scalar score.
+
+    No real artifact ships with the repo — this raises a clear error
+    explaining the contract until one lands at `data/processed/bbb_permeability_dce.onnx`
+    (override via `BBB_PERMEABILITY_DCE_PATH`).
+    """
+    checkpoint_path = Path(checkpoint_path)
+    if not checkpoint_path.exists():
+        raise FileNotFoundError(
+            f"DCE-MRI BBB permeability artifact not found at {checkpoint_path}. "
+            "Train and export an ONNX model that consumes a 4D DCE volume "
+            "(X, Y, Z, T) and emits a 3D Ktrans map; drop it at this path or "
+            "set BBB_PERMEABILITY_DCE_PATH."
+        )
+    import nibabel as nib
+    import onnxruntime as ort
+
+    img = nib.load(str(input_path))
+    arr = np.asarray(img.get_fdata(dtype=np.float32), dtype=np.float32)
+    if arr.ndim != 4:
+        raise ValueError(
+            f"DCE-MRI mode expects a 4D NIfTI (X,Y,Z,T); got shape {arr.shape}."
+        )
+    session = ort.InferenceSession(str(checkpoint_path), providers=["CPUExecutionProvider"])
+    input_name = session.get_inputs()[0].name
+    ktrans = session.run(None, {input_name: arr[np.newaxis, ...]})[0]
+    # Normalise to [0, 1]; clinically-conservative cap of 0.5 mL/min/100g.
+    _DCE_KTRANS_CAP = 0.5
+    normalised = np.clip(ktrans / _DCE_KTRANS_CAP, 0.0, 1.0).astype(np.float32)
+    score = float(np.mean(normalised))
+    return {
+        "permeability_score": score,
+        "interpretation": _interpret(score),
+        "method": "dce_onnx",
+        "voxel_map_available": True,
+        "voxel_map_shape": list(normalised.shape),
+    }
+
+
+def compute_permeability(
+    input_path: Path,
+    mode: PermeabilityMode = DEFAULT_MODE,
+    checkpoint_path: Path | None = None,
+) -> dict[str, Any]:
+    """Dispatch to the requested mode and return a unified payload."""
+    input_path = Path(input_path)
+    if not input_path.exists():
+        raise FileNotFoundError(f"MRI input not found: {input_path}")
+
+    if mode == "heuristic_proxy":
+        ckpt = checkpoint_path or Path(os.environ.get(
+            "MRI_MODEL_PATH_2D", "data/processed/mri_dl_2d/best_model.pt",
+        ))
+        return heuristic_proxy_score(input_path, ckpt)
+
+    if mode == "dce_onnx":
+        ckpt = checkpoint_path or Path(os.environ.get(
+            "BBB_PERMEABILITY_DCE_PATH",
+            "data/processed/bbb_permeability_dce.onnx",
+        ))
+        return dce_onnx_score(input_path, ckpt)
+
+    raise ValueError(
+        f"unknown BBB permeability mode={mode!r}; expected one of "
+        "('heuristic_proxy', 'dce_onnx')"
+    )

src/research/drug_dose_adjuster.py

@@ -0,0 +1,103 @@
+"""Drug-dose adjustment given patient BBB permeability + drug BBB classification.
+
+Pure-function logic. Researcher-persona module — does NOT touch the fusion
+engine. Output is a research suggestion, NOT medical advice.
+
+Decision matrix:
+
+    BBB intact (perm < 0.2)              -> factor=1.0, risk=low
+    BBB leaky, drug BBB-permeable        -> factor=max(0.3, 1 - 0.7*perm),
+                                             risk=high if perm > 0.6 else moderate
+    BBB leaky, drug NOT permeable        -> factor=max(0.6, 1 - 0.4*perm),
+                                             risk=moderate
+    drug_permeable=None (unknown)        -> treat as permeable (safer)
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+RiskLevel = Literal["low", "moderate", "high"]
+
+
+@dataclass(frozen=True)
+class DoseAdjustment:
+    recommended_dose_mg: float
+    adjustment_factor: float  # 0..1; 1.0 = no change
+    risk_level: RiskLevel
+    rationale: str
+
+
+# Threshold below which BBB is considered intact and no adjustment applies.
+_INTACT_THRESHOLD = 0.2
+
+# Floor on the adjustment factor (we never recommend going below this fraction
+# of the baseline dose — anything more aggressive belongs to a clinician).
+_PERMEABLE_DRUG_MIN_FACTOR = 0.3
+_NON_PERMEABLE_DRUG_MIN_FACTOR = 0.6
+
+# Slope on the linear adjustment.
+_PERMEABLE_DRUG_SLOPE = 0.7
+_NON_PERMEABLE_DRUG_SLOPE = 0.4
+
+
+def adjust(
+    baseline_dose_mg: float,
+    bbb_permeability_score: float,
+    drug_bbb_permeable: bool | None = None,
+) -> DoseAdjustment:
+    """Return a DoseAdjustment for the (patient, drug) pair."""
+    if baseline_dose_mg <= 0.0:
+        raise ValueError(f"baseline_dose_mg must be > 0; got {baseline_dose_mg}")
+    if not 0.0 <= bbb_permeability_score <= 1.0:
+        raise ValueError(
+            f"bbb_permeability_score must be in [0, 1]; got {bbb_permeability_score}"
+        )
+
+    if bbb_permeability_score < _INTACT_THRESHOLD:
+        return DoseAdjustment(
+            recommended_dose_mg=baseline_dose_mg,
+            adjustment_factor=1.0,
+            risk_level="low",
+            rationale=(
+                f"BBB permeability score {bbb_permeability_score:.2f} is below the "
+                f"intact threshold ({_INTACT_THRESHOLD:.2f}). No dose adjustment "
+                "recommended. Research suggestion, not medical advice."
+            ),
+        )
+
+    # Treat unknown permeability conservatively as 'permeable'.
+    permeable = True if drug_bbb_permeable is None else bool(drug_bbb_permeable)
+
+    if permeable:
+        factor = max(
+            _PERMEABLE_DRUG_MIN_FACTOR,
+            1.0 - _PERMEABLE_DRUG_SLOPE * bbb_permeability_score,
+        )
+        risk: RiskLevel = "high" if bbb_permeability_score > 0.6 else "moderate"
+        permeable_note = (
+            "Drug is BBB-permeable" if drug_bbb_permeable is True
+            else "Drug BBB permeability is unknown (treated as permeable for safety)"
+        )
+    else:
+        factor = max(
+            _NON_PERMEABLE_DRUG_MIN_FACTOR,
+            1.0 - _NON_PERMEABLE_DRUG_SLOPE * bbb_permeability_score,
+        )
+        risk = "moderate"
+        permeable_note = "Drug is normally BBB-excluded"
+
+    recommended = baseline_dose_mg * factor
+    rationale = (
+        f"BBB permeability score {bbb_permeability_score:.2f} indicates "
+        f"compromised barrier. {permeable_note}; recommended dose reduced "
+        f"to {factor*100:.0f}% of baseline ({recommended:.1f} mg of "
+        f"{baseline_dose_mg:.1f} mg). Risk level: {risk}. "
+        "Research suggestion, not medical advice."
+    )
+    return DoseAdjustment(
+        recommended_dose_mg=float(recommended),
+        adjustment_factor=float(factor),
+        risk_level=risk,
+        rationale=rationale,
+    )

tests/agents/test_tools.py

@@ -70,7 +70,7 @@ class TestTool:
 
 
 class TestBuildDefaultTools:
-    def test_default_set_has_four_tools(self, tmp_path: Path) -> None:
+    def test_default_set_has_seven_tools(self, tmp_path: Path) -> None:
         # build with placeholder paths; tools won't be invoked here
         tools = build_default_tools(rag_index_dir=None)
         names = {t.name for t in tools}
@@ -80,6 +80,8 @@ class TestBuildDefaultTools:
             "run_mri_pipeline",
             "retrieve_context",
             "run_fusion",
+            "compute_bbb_leakage_score",
+            "adjust_drug_dose",
         }
 
     def test_each_tool_has_pydantic_input_model(self) -> None:
@@ -116,8 +118,8 @@ class TestBuildDefaultTools:
     def test_default_processed_dir_when_omitted(self) -> None:
         # backwards-compat: omitting processed_dir keeps existing behavior
         tools = build_default_tools(rag_index_dir=None)
-        # just ensure no exception and 5 tools returned
-        assert len(tools) == 5
+        # just ensure no exception and 7 tools returned
+        assert len(tools) == 7
 
     def test_bbb_executor_translates_httpexception_to_valueerror(self) -> None:
         from fastapi import HTTPException

tests/api/test_bbb_research_routes.py

@@ -0,0 +1,113 @@
+"""Integration tests for /predict/bbb_permeability_map and /research/drug_dose_adjustment."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+import pytest
+from fastapi.testclient import TestClient
+from PIL import Image
+
+from src.api.main import app
+from tests.fixtures.build_dummy_resnet18_2d import build as build_dummy_2d
+
+
+def _png(path: Path) -> Path:
+    arr = (np.random.RandomState(0).rand(170, 170, 3) * 255).astype(np.uint8)
+    Image.fromarray(arr, mode="RGB").save(str(path))
+    return path
+
+
+@pytest.fixture()
+def client_proxy(monkeypatch, tmp_path):
+    ckpt = build_dummy_2d(tmp_path / "best.pt")
+    monkeypatch.setenv("MRI_MODEL_PATH_2D", str(ckpt))
+    return TestClient(app), tmp_path
+
+
+class TestBBBPermeabilityMapRoute:
+    def test_heuristic_proxy_happy_path(self, client_proxy) -> None:
+        client, tmp_path = client_proxy
+        img = _png(tmp_path / "scan.png")
+        r = client.post(
+            "/predict/bbb_permeability_map",
+            json={"input_path": str(img), "mode": "heuristic_proxy"},
+        )
+        assert r.status_code == 200, r.text
+        data = r.json()
+        assert 0.0 <= data["permeability_score"] <= 1.0
+        assert data["interpretation"] in {
+            "BBB intact", "mild leakage", "moderate leakage", "severe leakage",
+        }
+        assert data["method"] == "heuristic_proxy"
+        assert data["voxel_map_available"] is False
+
+    def test_unknown_mode_returns_400(self, client_proxy) -> None:
+        client, tmp_path = client_proxy
+        img = _png(tmp_path / "scan.png")
+        r = client.post(
+            "/predict/bbb_permeability_map",
+            json={"input_path": str(img), "mode": "bogus_mode"},
+        )
+        assert r.status_code == 400
+
+    def test_missing_input_returns_404(self, client_proxy) -> None:
+        client, tmp_path = client_proxy
+        r = client.post(
+            "/predict/bbb_permeability_map",
+            json={"input_path": str(tmp_path / "missing.png"), "mode": "heuristic_proxy"},
+        )
+        assert r.status_code == 404
+
+
+class TestDrugDoseAdjustmentRoute:
+    def test_intact_bbb_returns_baseline(self) -> None:
+        client = TestClient(app)
+        r = client.post("/research/drug_dose_adjustment", json={
+            "baseline_dose_mg": 100.0,
+            "bbb_permeability_score": 0.05,
+            "drug_bbb_permeable": True,
+        })
+        assert r.status_code == 200, r.text
+        data = r.json()
+        assert data["recommended_dose_mg"] == pytest.approx(100.0)
+        assert data["risk_level"] == "low"
+
+    def test_leaky_bbb_permeable_drug_reduced(self) -> None:
+        client = TestClient(app)
+        r = client.post("/research/drug_dose_adjustment", json={
+            "baseline_dose_mg": 100.0,
+            "bbb_permeability_score": 0.5,
+            "drug_bbb_permeable": True,
+        })
+        assert r.status_code == 200
+        data = r.json()
+        assert data["recommended_dose_mg"] == pytest.approx(65.0)
+        assert data["risk_level"] == "moderate"
+        assert "research suggestion" in data["rationale"].lower()
+
+    def test_severe_leakage_high_risk(self) -> None:
+        client = TestClient(app)
+        r = client.post("/research/drug_dose_adjustment", json={
+            "baseline_dose_mg": 100.0,
+            "bbb_permeability_score": 0.85,
+            "drug_bbb_permeable": True,
+        })
+        data = r.json()
+        assert data["risk_level"] == "high"
+
+    def test_negative_baseline_returns_422(self) -> None:
+        client = TestClient(app)
+        r = client.post("/research/drug_dose_adjustment", json={
+            "baseline_dose_mg": -1.0,
+            "bbb_permeability_score": 0.5,
+        })
+        assert r.status_code == 422  # pydantic gt=0.0 validation
+
+    def test_score_out_of_range_returns_422(self) -> None:
+        client = TestClient(app)
+        r = client.post("/research/drug_dose_adjustment", json={
+            "baseline_dose_mg": 100.0,
+            "bbb_permeability_score": 1.5,
+        })
+        assert r.status_code == 422

tests/models/test_bbb_permeability_map.py

@@ -0,0 +1,86 @@
+"""Tests for src.models.bbb_permeability_map — researcher BBB scorer."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+import pytest
+from PIL import Image
+
+from src.models import bbb_permeability_map as bbb_perm
+from tests.fixtures.build_dummy_resnet18_2d import build as build_dummy_2d
+
+
+def _png(path: Path, size: tuple[int, int] = (170, 170)) -> Path:
+    arr = (np.random.RandomState(0).rand(size[1], size[0], 3) * 255).astype(np.uint8)
+    Image.fromarray(arr, mode="RGB").save(str(path))
+    return path
+
+
+class TestComputeFromClassifierProbs:
+    def test_full_nondemented_yields_zero_score(self) -> None:
+        probs = [
+            {"label_text": "MildDemented", "probability": 0.0},
+            {"label_text": "ModerateDemented", "probability": 0.0},
+            {"label_text": "NonDemented", "probability": 1.0},
+            {"label_text": "VeryMildDemented", "probability": 0.0},
+        ]
+        assert bbb_perm.compute_from_classifier_probs(probs) == pytest.approx(0.0)
+
+    def test_no_nondemented_yields_one(self) -> None:
+        probs = [
+            {"label_text": "MildDemented", "probability": 0.5},
+            {"label_text": "ModerateDemented", "probability": 0.5},
+        ]
+        assert bbb_perm.compute_from_classifier_probs(probs) == pytest.approx(1.0)
+
+    def test_partial_yields_complement(self) -> None:
+        probs = [
+            {"label_text": "NonDemented", "probability": 0.7},
+            {"label_text": "MildDemented", "probability": 0.3},
+        ]
+        assert bbb_perm.compute_from_classifier_probs(probs) == pytest.approx(0.3)
+
+    def test_case_insensitive_label_match(self) -> None:
+        probs = [{"label_text": "nondemented", "probability": 0.6}]
+        assert bbb_perm.compute_from_classifier_probs(probs) == pytest.approx(0.4)
+
+
+class TestComputePermeability:
+    def test_heuristic_proxy_with_dummy_2d(self, tmp_path: Path) -> None:
+        ckpt = build_dummy_2d(tmp_path / "best.pt")
+        img = _png(tmp_path / "scan.png")
+        result = bbb_perm.compute_permeability(
+            input_path=img, mode="heuristic_proxy", checkpoint_path=ckpt,
+        )
+        assert 0.0 <= result["permeability_score"] <= 1.0
+        assert result["interpretation"] in {
+            "BBB intact", "mild leakage", "moderate leakage", "severe leakage",
+        }
+        assert result["method"] == "heuristic_proxy"
+        assert result["voxel_map_available"] is False
+
+    def test_unknown_mode_raises(self, tmp_path: Path) -> None:
+        img = _png(tmp_path / "scan.png")
+        with pytest.raises(ValueError, match="unknown BBB permeability mode"):
+            bbb_perm.compute_permeability(input_path=img, mode="bogus")  # type: ignore[arg-type]
+
+    def test_missing_input_raises(self, tmp_path: Path) -> None:
+        with pytest.raises(FileNotFoundError, match="MRI input not found"):
+            bbb_perm.compute_permeability(input_path=tmp_path / "nope.png")
+
+    def test_dce_mode_without_artifact_raises(self, tmp_path: Path) -> None:
+        # Existence check on the input is the first gate; placeholder file is fine.
+        img = tmp_path / "fake_dce.nii.gz"
+        img.write_bytes(b"")
+        with pytest.raises(FileNotFoundError, match="DCE-MRI BBB permeability artifact"):
+            bbb_perm.compute_permeability(
+                input_path=img, mode="dce_onnx",
+                checkpoint_path=tmp_path / "missing.onnx",
+            )
+
+    def test_interpretation_thresholds(self) -> None:
+        assert bbb_perm._interpret(0.10) == "BBB intact"
+        assert bbb_perm._interpret(0.30) == "mild leakage"
+        assert bbb_perm._interpret(0.55) == "moderate leakage"
+        assert bbb_perm._interpret(0.80) == "severe leakage"

tests/research/test_drug_dose_adjuster.py

@@ -0,0 +1,100 @@
+"""Tests for src.research.drug_dose_adjuster — pure-function dose revision."""
+from __future__ import annotations
+
+import pytest
+
+from src.research.drug_dose_adjuster import adjust
+
+
+class TestAdjust:
+    # --- BBB intact ---------------------------------------------------------
+
+    def test_intact_bbb_no_change_permeable_drug(self) -> None:
+        out = adjust(baseline_dose_mg=100.0, bbb_permeability_score=0.05, drug_bbb_permeable=True)
+        assert out.recommended_dose_mg == pytest.approx(100.0)
+        assert out.adjustment_factor == 1.0
+        assert out.risk_level == "low"
+
+    def test_intact_bbb_no_change_non_permeable_drug(self) -> None:
+        out = adjust(baseline_dose_mg=200.0, bbb_permeability_score=0.0, drug_bbb_permeable=False)
+        assert out.adjustment_factor == 1.0
+        assert out.risk_level == "low"
+
+    # --- BBB leaky, drug permeable -----------------------------------------
+
+    def test_leaky_bbb_permeable_drug_reduces_dose(self) -> None:
+        out = adjust(baseline_dose_mg=100.0, bbb_permeability_score=0.5, drug_bbb_permeable=True)
+        # factor = max(0.3, 1 - 0.7*0.5) = max(0.3, 0.65) = 0.65
+        assert out.adjustment_factor == pytest.approx(0.65)
+        assert out.recommended_dose_mg == pytest.approx(65.0)
+        assert out.risk_level == "moderate"
+
+    def test_severe_leakage_permeable_drug_high_risk(self) -> None:
+        out = adjust(baseline_dose_mg=100.0, bbb_permeability_score=0.8, drug_bbb_permeable=True)
+        assert out.risk_level == "high"
+        # factor = max(0.3, 1 - 0.7*0.8) = max(0.3, 0.44) = 0.44
+        assert out.adjustment_factor == pytest.approx(0.44)
+
+    def test_safety_floor_not_breached(self) -> None:
+        # At perm=1.0: 1 - 0.7 = 0.3 — the floor.
+        out = adjust(baseline_dose_mg=100.0, bbb_permeability_score=1.0, drug_bbb_permeable=True)
+        assert out.adjustment_factor >= 0.3 - 1e-9
+        # And anything above 1.0 (clipped by validator) — won't get there.
+
+    # --- BBB leaky, drug NOT permeable -------------------------------------
+
+    def test_leaky_bbb_non_permeable_drug_mild_reduction(self) -> None:
+        out = adjust(baseline_dose_mg=100.0, bbb_permeability_score=0.5, drug_bbb_permeable=False)
+        # factor = max(0.6, 1 - 0.4*0.5) = max(0.6, 0.8) = 0.8
+        assert out.adjustment_factor == pytest.approx(0.8)
+        assert out.risk_level == "moderate"
+
+    def test_non_permeable_drug_safety_floor(self) -> None:
+        out = adjust(baseline_dose_mg=100.0, bbb_permeability_score=1.0, drug_bbb_permeable=False)
+        assert out.adjustment_factor == pytest.approx(0.6)
+
+    # --- Drug permeability unknown -----------------------------------------
+
+    def test_unknown_permeability_treated_as_permeable(self) -> None:
+        out_unknown = adjust(baseline_dose_mg=100.0, bbb_permeability_score=0.5, drug_bbb_permeable=None)
+        out_perm    = adjust(baseline_dose_mg=100.0, bbb_permeability_score=0.5, drug_bbb_permeable=True)
+        assert out_unknown.adjustment_factor == pytest.approx(out_perm.adjustment_factor)
+
+    def test_unknown_permeability_rationale_says_so(self) -> None:
+        out = adjust(baseline_dose_mg=100.0, bbb_permeability_score=0.5, drug_bbb_permeable=None)
+        assert "unknown" in out.rationale.lower()
+
+    # --- Validation ---------------------------------------------------------
+
+    def test_zero_baseline_raises(self) -> None:
+        with pytest.raises(ValueError, match="baseline_dose_mg must be > 0"):
+            adjust(baseline_dose_mg=0.0, bbb_permeability_score=0.5)
+
+    def test_negative_baseline_raises(self) -> None:
+        with pytest.raises(ValueError, match="baseline_dose_mg must be > 0"):
+            adjust(baseline_dose_mg=-10.0, bbb_permeability_score=0.5)
+
+    def test_score_out_of_range_raises(self) -> None:
+        with pytest.raises(ValueError, match="bbb_permeability_score must be in"):
+            adjust(baseline_dose_mg=100.0, bbb_permeability_score=1.5)
+        with pytest.raises(ValueError, match="bbb_permeability_score must be in"):
+            adjust(baseline_dose_mg=100.0, bbb_permeability_score=-0.1)
+
+    # --- Monotonicity ------------------------------------------------------
+
+    def test_increasing_leakage_lowers_recommended_dose_for_permeable_drug(self) -> None:
+        scores = [0.25, 0.4, 0.55, 0.7, 0.85]
+        doses = [
+            adjust(100.0, s, drug_bbb_permeable=True).recommended_dose_mg
+            for s in scores
+        ]
+        # Strictly non-increasing.
+        assert all(a >= b - 1e-9 for a, b in zip(doses, doses[1:]))
+
+    # --- Rationale always says it's not medical advice --------------------
+
+    def test_rationale_disclaims_medical_advice(self) -> None:
+        for score in [0.0, 0.3, 0.7, 1.0]:
+            out = adjust(100.0, score, drug_bbb_permeable=True)
+            assert "research suggestion" in out.rationale.lower()
+            assert "medical advice" in out.rationale.lower()