iints-sdk-python35 1.5.12__py3-none-any.whl → 1.5.13__py3-none-any.whl

iints/__init__.py

@@ -11,7 +11,7 @@ except ImportError:  # pragma: no cover - Python < 3.8 fallback
 try:
     __version__ = version("iints-sdk-python35")
 except PackageNotFoundError:  # pragma: no cover - source tree fallback
-    __version__ = "1.5.12"
+    __version__ = "1.5.13"
 
 # Note to developers: this SDK is currently maintained by a single author.
 # Please report bugs via GitHub issues and feel free to contribute fixes via PRs.

iints/analysis/clinical_benchmark.py

@@ -14,7 +14,7 @@ from rich.panel import Panel
 from rich.progress import Progress, SpinnerColumn, TextColumn
 
 # Add project root to path
-project_root = Path(__file__).parent.parent.parent
+project_root = Path(__file__).parent.parent.parent.parent
 sys.path.insert(0, str(project_root))
 
 from iints.data.adapter import DataAdapter
@@ -81,7 +81,7 @@ class ClinicalBenchmark:
         """Display benchmark results in formatted table with visualization"""
         
         # Import visualization tools
-        from tools.glucose_visualizer import GlucoseVisualizer
+        from tools.analysis.glucose_visualizer import GlucoseVisualizer
         viz = GlucoseVisualizer()
         
         # Show patient overview first

iints/analysis/explainable_ai.py

@@ -9,13 +9,59 @@ from datetime import datetime, timedelta
 from pathlib import Path
 import numpy as np
 
+# Import the local Ollama backend
+from iints.ai.backends.ollama import OllamaBackend
+
 class ClinicalAuditTrail:
     """Explainable AI system for clinical decision transparency"""
     
     def __init__(self):
         self.audit_log = []
         self.decision_context = {}
+        self.ollama = None
+        
+    def _init_ollama(self):
+        if self.ollama is None:
+            self.ollama = OllamaBackend()
+            try:
+                self.ollama.ensure_model_ready()
+            except Exception as e:
+                print(f"Warning: Local AI not available: {e}")
+
+    def generate_ollama_insight(self, times, glucose, ffa, ketones, insulin):
+        """
+        Sends the raw physiological arrays to the local Mistral LLM via Ollama
+        for an Explainable AI clinical diagnosis.
+        """
+        self._init_ollama()
+        if not self.ollama or not self.ollama.available():
+            return "ERROR: Local Ollama AI is not running or available."
+            
+        # Format the data arrays for the LLM
+        data_summary = (
+            f"Time (min): {times[-5:]}\n"
+            f"Glucose (mg/dL): {[round(g, 1) for g in glucose[-5:]]}\n"
+            f"Insulin (U): {[round(i, 2) for i in insulin[-5:]]}\n"
+            f"FFA (mmol/L): {[round(f, 2) for f in ffa[-5:]]}\n"
+            f"Ketones (mmol/L): {[round(k, 2) for k in ketones[-5:]]}\n"
+        )
         
+        system_prompt = (
+            "You are an Explainable AI for a Type 1 Diabetes Digital Twin. "
+            "You analyze raw mathematical arrays from the simulation and provide a clinical explanation. "
+            "Explain what the math is doing to the patient. If insulin is 0, mention hepatic glucose production. "
+            "If FFA and Ketones are rising, diagnose the lipotoxicity and Diabetic Ketoacidosis (DKA). "
+            "Keep the response professional, clinical, and under 4 sentences."
+        )
+        
+        user_prompt = f"Analyze the following patient state from the last 25 minutes of the simulation:\n{data_summary}"
+        
+        try:
+            response = self.ollama.complete(system_prompt=system_prompt, user_prompt=user_prompt)
+            return response
+        except Exception as e:
+            return f"AI Generation Failed: {e}"
+
     def log_decision(self, timestamp, glucose_current, glucose_trend, insulin_decision, 
                     algorithm_confidence, safety_override=False, context=None):
         """Log AI decision with clinical reasoning"""

iints/cli/cli.py

@@ -8501,6 +8501,10 @@ def sources(
 
 research_app = typer.Typer(help="Research pipeline: dataset preparation and quality reporting.")
 app.add_typer(research_app, name="research")
+glucose_model_app = typer.Typer(
+    help="Dedicated glucose forecasting model workflow for training and Hugging Face export."
+)
+research_app.add_typer(glucose_model_app, name="glucose-model")
 
 
 @research_app.command(name="prepare-azt1d")
@@ -9602,6 +9606,302 @@ def research_forecast_run(
     )
 
 
+@glucose_model_app.command(name="build-dataset")
+def research_glucose_model_build_dataset(
+    input_paths: Annotated[
+        List[Path],
+        typer.Option(
+            "--input",
+            "-i",
+            help="Prepared glucose dataset CSV/Parquet. Repeat for Ohio, AZT1D, simulator exports, etc.",
+        ),
+    ],
+    output_dir: Annotated[
+        Path,
+        typer.Option(help="Output folder for normalized training dataset, manifest, and config."),
+    ] = Path("models/iints-glucose-forecast-v0/dataset"),
+    labels_csv: Annotated[
+        Optional[str],
+        typer.Option(
+            "--labels",
+            help="Optional comma-separated labels matching --input order, e.g. ohio_train,sim_10k.",
+        ),
+    ] = None,
+    profile: Annotated[str, typer.Option(help="Training profile: smoke, quick, long, or paper.")] = "long",
+    output_format: Annotated[str, typer.Option(help="Dataset output format: csv or parquet.")] = "csv",
+    history_minutes: Annotated[int, typer.Option(help="Model history window in minutes.")] = 360,
+    horizon_minutes: Annotated[int, typer.Option(help="Prediction horizon in minutes.")] = 120,
+    time_step_minutes: Annotated[int, typer.Option(help="Expected CGM sample interval in minutes.")] = 5,
+) -> None:
+    """Build the dedicated IINTS glucose-forecast training pack."""
+    console = Console()
+    labels = None
+    if labels_csv:
+        labels = [item.strip() for item in labels_csv.split(",") if item.strip()]
+    try:
+        from iints.research.glucose_model import build_glucose_training_pack
+
+        pack = build_glucose_training_pack(
+            input_paths,
+            output_dir,
+            labels=labels,
+            output_format=output_format,
+            profile=profile,
+            history_minutes=history_minutes,
+            horizon_minutes=horizon_minutes,
+            time_step_minutes=time_step_minutes,
+        )
+    except Exception as exc:
+        console.print(f"[bold red]glucose-model build-dataset failed:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    table = Table(title="IINTS Glucose Model Training Pack")
+    table.add_column("Artifact", style="cyan")
+    table.add_column("Value", overflow="fold")
+    table.add_row("Rows", str(pack.row_count))
+    table.add_row("Subjects", str(pack.subject_count))
+    table.add_row("Sources", str(pack.source_count))
+    table.add_row("Dataset", str(pack.dataset_path))
+    table.add_row("Config", str(pack.config_path))
+    table.add_row("Manifest", str(pack.manifest_path))
+    table.add_row("Intent", str(pack.model_intent_path))
+    console.print(table)
+    console.print(
+        "[green]Next:[/green] "
+        f"iints research glucose-model train --data {pack.dataset_path} "
+        f"--config {pack.config_path} --output-dir models/iints-glucose-forecast-v0"
+    )
+
+
+@glucose_model_app.command(name="init")
+def research_glucose_model_init(
+    output_dir: Annotated[Path, typer.Option(help="Output directory for the glucose model starter files.")] = Path(
+        "models/iints-glucose-forecast-v0"
+    ),
+    profile: Annotated[str, typer.Option(help="Training profile: smoke, quick, long, or paper.")] = "long",
+    history_minutes: Annotated[int, typer.Option(help="Model history window in minutes.")] = 360,
+    horizon_minutes: Annotated[int, typer.Option(help="Prediction horizon in minutes.")] = 120,
+    time_step_minutes: Annotated[int, typer.Option(help="Expected CGM sample interval in minutes.")] = 5,
+) -> None:
+    """Create a glucose-model config and intent file without touching data."""
+    console = Console()
+    try:
+        from iints.research.glucose_model import _render_model_intent, write_glucose_model_config
+
+        output_dir.mkdir(parents=True, exist_ok=True)
+        config_path = output_dir / "glucose_model_config.yaml"
+        payload = write_glucose_model_config(
+            config_path,
+            profile=profile,
+            history_minutes=history_minutes,
+            horizon_minutes=horizon_minutes,
+            time_step_minutes=time_step_minutes,
+        )
+        intent_payload = {
+            "row_count": "pending",
+            "subject_count": "pending",
+            "source_count": "pending",
+            "history_minutes": history_minutes,
+            "horizon_minutes": horizon_minutes,
+        }
+        intent_path = output_dir / "MODEL_INTENT.md"
+        intent_path.write_text(_render_model_intent(intent_payload))
+    except Exception as exc:
+        console.print(f"[bold red]glucose-model init failed:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    console.print(f"[green]Config written:[/green] {config_path}")
+    console.print(f"[green]Intent written:[/green] {intent_path}")
+    console.print(f"Profile: {payload['iints_glucose_model']['profile']}")
+
+
+@glucose_model_app.command(name="train")
+def research_glucose_model_train(
+    data: Annotated[Path, typer.Option(help="Normalized glucose training dataset CSV/Parquet.")],
+    output_dir: Annotated[Path, typer.Option(help="Output directory for predictor.pt and training_report.json.")] = Path(
+        "models/iints-glucose-forecast-v0"
+    ),
+    config: Annotated[Optional[Path], typer.Option(help="Config YAML. If omitted, one is generated.")] = None,
+    profile: Annotated[str, typer.Option(help="Generated config profile: smoke, quick, long, or paper.")] = "long",
+    epochs: Annotated[Optional[int], typer.Option(help="Override training.epochs for long local runs.")] = None,
+    batch_size: Annotated[Optional[int], typer.Option(help="Override training.batch_size.")] = None,
+    learning_rate: Annotated[Optional[float], typer.Option(help="Override training.learning_rate.")] = None,
+    warm_start: Annotated[Optional[Path], typer.Option(help="Optional predictor.pt warm-start checkpoint.")] = None,
+    export_hf: Annotated[
+        bool,
+        typer.Option("--export-hf/--no-export-hf", help="Build a Hugging Face-ready folder after training."),
+    ] = True,
+    repo_id: Annotated[Optional[str], typer.Option(help="Optional Hugging Face repo id for model card hints.")] = None,
+    dataset_manifest: Annotated[Optional[Path], typer.Option(help="Optional dataset manifest for HF public metadata.")] = None,
+    comparison_dir: Annotated[
+        Optional[Path],
+        typer.Option(help="Optional glucose-model compare output directory to bundle with the Hugging Face export."),
+    ] = None,
+) -> None:
+    """Train the dedicated IINTS glucose-forecast model using the existing predictor engine."""
+    console = Console()
+    if not data.exists():
+        console.print(f"[bold red]Dataset not found: {data}[/bold red]")
+        raise typer.Exit(code=1)
+
+    try:
+        from iints.research.glucose_model import write_glucose_model_config, write_huggingface_export_bundle
+
+        output_dir.mkdir(parents=True, exist_ok=True)
+        resolved_config = output_dir / "glucose_model_config.resolved.yaml"
+        if config is None:
+            payload = write_glucose_model_config(output_dir / "glucose_model_config.yaml", profile=profile)
+        else:
+            payload = yaml.safe_load(config.read_text())
+        if epochs is not None:
+            payload.setdefault("training", {})["epochs"] = int(epochs)
+        if batch_size is not None:
+            payload.setdefault("training", {})["batch_size"] = int(batch_size)
+        if learning_rate is not None:
+            payload.setdefault("training", {})["learning_rate"] = float(learning_rate)
+        resolved_config.write_text(yaml.safe_dump(payload, sort_keys=False))
+
+        script = Path(__file__).resolve().parents[3] / "research" / "train_predictor.py"
+        cmd = [
+            sys.executable,
+            str(script),
+            "--data",
+            str(data),
+            "--config",
+            str(resolved_config),
+            "--out",
+            str(output_dir),
+        ]
+        if warm_start is not None:
+            cmd.extend(["--warm-start", str(warm_start)])
+        subprocess.run(cmd, check=True)
+        hf_outputs = None
+        if export_hf:
+            manifest = dataset_manifest
+            if manifest is None:
+                candidate = data.parent / "glucose_dataset_manifest.json"
+                manifest = candidate if candidate.exists() else None
+            hf_outputs = write_huggingface_export_bundle(
+                model_dir=output_dir,
+                output_dir=output_dir / "huggingface",
+                repo_id=repo_id,
+                dataset_manifest=manifest,
+                comparison_dir=comparison_dir,
+            )
+    except subprocess.CalledProcessError as exc:
+        console.print(f"[bold red]glucose-model train failed with exit code {exc.returncode}[/bold red]")
+        raise typer.Exit(code=exc.returncode)
+    except Exception as exc:
+        console.print(f"[bold red]glucose-model train failed:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    console.print(f"[green]Model written:[/green] {output_dir / 'predictor.pt'}")
+    console.print(f"[green]Training report:[/green] {output_dir / 'training_report.json'}")
+    if hf_outputs:
+        console.print(f"[green]Hugging Face bundle:[/green] {hf_outputs['output_dir']}")
+
+
+@glucose_model_app.command(name="export-hf")
+def research_glucose_model_export_hf(
+    model_dir: Annotated[Path, typer.Option(help="Directory containing predictor.pt and training_report.json.")] = Path(
+        "models/iints-glucose-forecast-v0"
+    ),
+    output_dir: Annotated[Path, typer.Option(help="Output directory for the Hugging Face-ready bundle.")] = Path(
+        "models/iints-glucose-forecast-v0/huggingface"
+    ),
+    repo_id: Annotated[Optional[str], typer.Option(help="Optional Hugging Face repo id, e.g. user/iints-glucose-forecast-v0.")] = None,
+    dataset_manifest: Annotated[Optional[Path], typer.Option(help="Optional private manifest to redact into public metadata.")] = None,
+    comparison_dir: Annotated[
+        Optional[Path],
+        typer.Option(help="Optional glucose-model compare output directory to include comparison metrics and reports."),
+    ] = None,
+) -> None:
+    """Export predictor.pt plus a research-safe Hugging Face model card."""
+    console = Console()
+    try:
+        from iints.research.glucose_model import write_huggingface_export_bundle
+
+        outputs = write_huggingface_export_bundle(
+            model_dir=model_dir,
+            output_dir=output_dir,
+            repo_id=repo_id,
+            dataset_manifest=dataset_manifest,
+            comparison_dir=comparison_dir,
+        )
+    except Exception as exc:
+        console.print(f"[bold red]glucose-model export-hf failed:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    table = Table(title="Hugging Face Export Bundle")
+    table.add_column("Artifact", style="cyan")
+    table.add_column("Path", overflow="fold")
+    for key, value in outputs.items():
+        table.add_row(key, value)
+    console.print(table)
+    console.print("[yellow]Recommended:[/yellow] upload private first, review README.md, then decide whether public is allowed.")
+
+
+@glucose_model_app.command(name="compare")
+def research_glucose_model_compare(
+    data: Annotated[Path, typer.Option(help="Normalized glucose dataset CSV/Parquet to evaluate on.")],
+    output_dir: Annotated[Path, typer.Option(help="Output directory for comparison reports.")] = Path(
+        "results/glucose_model_comparison"
+    ),
+    model_specs: Annotated[
+        Optional[List[str]],
+        typer.Option(
+            "--model",
+            "-m",
+            help="Model checkpoint as label=path/to/predictor.pt. Repeat for MSE/Band/PINN models.",
+        ),
+    ] = None,
+    config: Annotated[Optional[Path], typer.Option(help="Comparison config YAML. Defaults to glucose-model quick config.")] = None,
+    include_baselines: Annotated[
+        bool,
+        typer.Option("--include-baselines/--no-baselines", help="Compare transparent LastValue/LinearTrend/Physiology baselines."),
+    ] = True,
+    mc_samples: Annotated[int, typer.Option(help="MC dropout samples for checkpoint uncertainty. Use 0 to disable.")] = 0,
+    max_roc_mgdl_min: Annotated[
+        float,
+        typer.Option(help="Maximum plausible predicted glucose rate-of-change in mg/dL/min."),
+    ] = 10.0,
+) -> None:
+    """Compare MSE/Band/PINN glucose models against baselines and physiology gates."""
+    console = Console()
+    try:
+        from iints.research.glucose_model import compare_glucose_models, parse_model_specs
+
+        bundle = compare_glucose_models(
+            data_path=data,
+            output_dir=output_dir,
+            model_specs=parse_model_specs(model_specs or []),
+            config_path=config,
+            include_baselines=include_baselines,
+            mc_samples=mc_samples,
+            max_roc_mgdl_min=max_roc_mgdl_min,
+        )
+    except Exception as exc:
+        console.print(f"[bold red]glucose-model compare failed:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    table = Table(title="IINTS Glucose Model Comparison")
+    table.add_column("Artifact", style="cyan")
+    table.add_column("Path / Value", overflow="fold")
+    table.add_row("Rows", str(bundle.row_count))
+    table.add_row("Models", str(bundle.model_count))
+    table.add_row("Report JSON", str(bundle.report_json))
+    table.add_row("Report Markdown", str(bundle.report_md))
+    table.add_row("Horizon metrics", str(bundle.horizon_metrics_csv))
+    table.add_row("Physiology violations", str(bundle.physiological_violations_csv))
+    table.add_row("Hypo detection", str(bundle.hypo_detection_csv))
+    table.add_row("Model-card metrics", str(bundle.model_card_metrics_json))
+    console.print(table)
+    console.print(
+        "[yellow]Promotion rule:[/yellow] do not promote a model just because MAE improves; "
+        "also inspect missed hypo rate, uncertainty, and physiological violations."
+    )
+
+
 @research_app.command(name="parity-check")
 def research_parity_check(
     model: Annotated[Path, typer.Option(help="Predictor checkpoint (.pt)")],

iints/core/devices/models.py

@@ -22,12 +22,12 @@ class SensorModel:
 
     def __init__(
         self,
-        noise_std: float = 0.0,
+        noise_std: float = 8.5,
         bias: float = 0.0,
-        lag_minutes: int = 0,
+        lag_minutes: int = 5,
         isf_tau_minutes: float = 5.0,
         noise_ar1_phi: float = 0.85,
-        noise_fbm_hurst: Optional[float] = None,
+        noise_fbm_hurst: Optional[float] = 0.78,
         dropout_prob: float = 0.0,
         seed: Optional[int] = None,
         drift_std_per_hour: float = 0.0,

iints/core/patient/__init__.py

@@ -3,7 +3,9 @@ from .models import PatientModel
 
 try:
     from .bergman_model import BergmanPatientModel
+    from .advanced_metabolic_model import AdvancedMetabolicModel
 except ImportError:  # pragma: no cover - scipy may not be installed
     BergmanPatientModel = None  # type: ignore[assignment,misc]
+    AdvancedMetabolicModel = None
 
-__all__ = ["PatientProfile", "PatientModel", "BergmanPatientModel"]
+__all__ = ["PatientProfile", "PatientModel", "BergmanPatientModel", "AdvancedMetabolicModel"]

iints/core/patient/advanced_metabolic_model.py

@@ -0,0 +1,226 @@
+import numpy as np
+from typing import Any, Dict, List, Optional
+from scipy.integrate import solve_ivp
+
+from .bergman_model import BergmanPatientModel, BergmanParameters
+
+class AdvancedMetabolicModel(BergmanPatientModel):
+    """
+    Advanced Metabolic Model for IINTS-AF.
+    Extends the 13-state Bergman model to a 16-state model including:
+    - F: Free Fatty Acids (FFA) (mmol/L)
+    - K: Ketone Bodies (mmol/L)
+    - Beta: Residual Beta-cell mass fraction (0.0 to 1.0)
+    
+    Includes lipotoxicity (high FFA causes insulin resistance) and 
+    DKA (Ketone production under extreme insulin deficiency).
+    """
+
+    def __init__(
+        self,
+        initial_beta_mass: float = 0.0,  # 0.0 = completely destroyed, 1.0 = healthy
+        autoimmune_aggressiveness: float = 7e-6,  # Decay rate of beta cells per min
+        initial_ffa: float = 0.4,
+        initial_ketones: float = 0.1,
+        gamma_healthy: float = 0.005,
+        **kwargs,
+    ) -> None:
+        self.initial_beta_mass = initial_beta_mass
+        self.autoimmune_aggressiveness = autoimmune_aggressiveness
+        self.initial_ffa = initial_ffa
+        self.initial_ketones = initial_ketones
+        self.gamma_healthy = gamma_healthy
+        
+        super().__init__(**kwargs)
+        
+        # Override the 13-state with 16-state
+        # State vector: [G, X, I, Q_sto1, Q_sto2, Q_gut, S1, S2, Y1, Y2, Gamma, x_gluc, HAAF, F, K, Beta]
+        self._state = np.array([
+            self.initial_glucose,  # 0: G
+            0.0,                   # 1: X
+            self.params.Ib,        # 2: I
+            0.0,                   # 3: Q_sto1
+            0.0,                   # 4: Q_sto2
+            0.0,                   # 5: Q_gut
+            0.0,                   # 6: S1
+            0.0,                   # 7: S2
+            0.0,                   # 8: Y1
+            0.0,                   # 9: Y2
+            0.0,                   # 10: Gamma
+            0.0,                   # 11: x_gluc
+            0.0,                   # 12: HAAF
+            self.initial_ffa,      # 13: F (FFA)
+            self.initial_ketones,  # 14: K (Ketones)
+            self.initial_beta_mass,# 15: Beta
+        ], dtype=np.float64)
+
+    def reset(self) -> None:
+        super().reset()
+        self._state = np.array([
+            self.initial_glucose, 0.0, self.params.Ib, 0.0, 0.0, 0.0, 0.0, 0.0,
+            0.0, 0.0, 0.0, 0.0, 0.0, self.initial_ffa, self.initial_ketones, self.initial_beta_mass
+        ], dtype=np.float64)
+
+    def get_patient_state(self) -> Dict[str, float]:
+        state_dict = super().get_patient_state()
+        state_dict.update({
+            "plasma_ffa_mmol_L": float(self._state[13]),
+            "plasma_ketones_mmol_L": float(self._state[14]),
+            "residual_beta_cell_mass": float(self._state[15]),
+        })
+        return state_dict
+
+    def set_state(self, state: Dict[str, Any]) -> None:
+        if "ode_state" in state:
+            ode_state = np.array(state["ode_state"], dtype=np.float64)
+            if ode_state.size == 13:
+                # Upgrade legacy 13-state to 16-state
+                ode_state = np.append(ode_state, [self.initial_ffa, self.initial_ketones, self.initial_beta_mass])
+            self._state = ode_state
+        # Call super for the rest, but temporarly pop ode_state so super doesn't overwrite it
+        st_copy = state.copy()
+        if "ode_state" in st_copy:
+            del st_copy["ode_state"]
+        super().set_state(st_copy)
+
+    def _ode(
+        self,
+        t: float,
+        y: np.ndarray,
+        u_insulin_mu_per_min: float,
+        u_glucagon_pg_per_min: float,
+        current_time: float,
+    ) -> np.ndarray:
+        # Unpack 16 states
+        G, X, I, Q_sto1, Q_sto2, Q_gut, S1, S2, Y1, Y2, Gamma, x_gluc, HAAF, F, K, Beta = y
+        p = self.params
+
+        Vg_abs = p.Vg * p.body_weight_kg   # dL
+        Vi_abs = p.Vi * p.body_weight_kg    # L
+        V_glucagon = p.V_glucagon_per_kg * p.body_weight_kg
+
+        # --- Glucose rate of appearance from gut ---
+        Ra = (p.k_abs * Q_gut) / Vg_abs  # mg/dL/min
+
+        # --- Exogenous Glucagon Kinetics ---
+        dY1_dt = u_glucagon_pg_per_min - Y1 / p.t_max_glucagon
+        dY2_dt = Y1 / p.t_max_glucagon - Y2 / p.t_max_glucagon
+        U_Gamma = Y2 / p.t_max_glucagon
+        dGamma_dt = U_Gamma / V_glucagon - p.k_e_glucagon * Gamma
+        dx_gluc_dt = -p.k_a_glucagon * x_gluc + p.S_glucagon * p.k_a_glucagon * Gamma
+
+        # --- Dawn phenomenon ---
+        dawn = 0.0
+        if self.dawn_phenomenon_strength > 0:
+            minutes_in_day = current_time % 1440
+            ds = self.dawn_start_hour * 60
+            de = self.dawn_end_hour * 60
+            if ds <= minutes_in_day <= de:
+                dawn = self.dawn_phenomenon_strength / 60.0  # mg/dL/min
+
+        # --- Exercise & Stress Physiologic Impact ---
+        exercise_p1_multiplier = 1.0
+        exercise_p3_multiplier = 1.0
+        exercise_glucose_uptake = 0.0
+        if self.is_exercising:
+            exercise_p1_multiplier = 1.0 + 2.0 * self.exercise_intensity
+            exercise_p3_multiplier = 1.0 + 2.0 * self.exercise_intensity
+            exercise_glucose_uptake = self.exercise_intensity * self.exercise_glucose_consumption_rate
+
+        stress_p1_multiplier = 1.0
+        stress_p3_multiplier = 1.0
+        stress_Gb_multiplier = 1.0
+        if self.is_stressed:
+            stress_p1_multiplier = 1.0 - 0.2 * self.stress_intensity
+            stress_p3_multiplier = 1.0 - 0.7 * self.stress_intensity
+            stress_Gb_multiplier = 1.0 + 0.5 * self.stress_intensity
+
+        # --- Endogenous Rescue & HAAF ---
+        hypo_delta = max(0.0, 70.0 - G)
+        rescue_multiplier = 1.0 + (hypo_delta / 10.0) * (1.0 - HAAF)
+
+        # HAAF Memory Dynamics
+        k_haaf_build = 0.005
+        k_haaf_decay = 1.0 / (24 * 60)
+        dHAAF_dt = k_haaf_build * hypo_delta * (1.0 - HAAF) - k_haaf_decay * HAAF
+
+        # --- NEW: Beta-cell autoimmune decay ---
+        dBeta_dt = -self.autoimmune_aggressiveness * Beta
+
+        # --- NEW: FFA & Ketone Dynamics ---
+        # F basal = 0.4. Max = 2.0. Insulin sharply suppresses lipolysis.
+        l_0 = 0.2
+        l_1 = 0.23
+        k_f = 0.1
+        dF_dt = l_0 * np.exp(-l_1 * I) - k_f * F
+
+        # K basal = 0.1. Max = 5.0. Ketone production driven by high F and very low I.
+        k_0 = 0.125
+        k_1 = 0.33
+        k_2 = 0.05
+        dK_dt = k_0 * F * np.exp(-k_1 * I) - k_2 * K
+
+        # --- Lipotoxicity (Insulin Resistance via FFAs) ---
+        # Normal F is 0.4. If F rises to 2.0, sensitivity (p3) drops to 0.4 / 2.0 = 20%
+        lipotoxicity_factor = 0.4 / max(0.4, F)
+
+        p1_eff = p.p1 * exercise_p1_multiplier * stress_p1_multiplier
+        p3_eff = p.p3 * exercise_p3_multiplier * stress_p3_multiplier * lipotoxicity_factor
+        
+        # In T1D with zero insulin, the liver aggressively produces glucose (EGP).
+        # We model this by increasing the basal glucose target Gb_eff exponentially 
+        # as insulin drops and FFAs rise (hepatic insulin resistance).
+        starvation_factor = np.exp(-0.4 * I) * (max(F, 0.4) / 0.4)
+        hepatic_glucose_production_multiplier = 1.0 + 3.0 * starvation_factor
+
+        # Gb is multiplied by stress, rescue adrenaline, exogenous glucagon, and hepatic starvation
+        Gb_eff = p.Gb * stress_Gb_multiplier * rescue_multiplier * max(0.0, 1.0 + x_gluc) * hepatic_glucose_production_multiplier
+
+        # --- Physiological Renal Clearance ---
+        smooth_threshold_diff = G - 162.0
+        softplus_diff = 10.0 * np.log1p(np.exp(smooth_threshold_diff / 10.0))
+        F_R = 0.003 * softplus_diff
+
+        # --- dG/dt (INSTABILITY UPGRADE) ---
+        # In the original model: dGdt = -(p1_eff + X)*G + p1_eff*Gb_eff + ...
+        # This forces G to magically return to Gb_eff (Homeostasis).
+        # We decouple this to make it a true T1D unstable model.
+        # Basal Endogenous Glucose Production:
+        EGP = p1_eff * Gb_eff
+        
+        # In T1D, Glucose Effectiveness at zero insulin (GEZI) is very low. 
+        # We drop the automatic -p1_eff * G tissue uptake and ONLY rely on insulin (X).
+        dGdt = -X * G + EGP + Ra + dawn - exercise_glucose_uptake - F_R
+
+        # --- dX/dt ---
+        dXdt = -p.p2 * X + p3_eff * max(I - p.Ib, 0.0)
+
+        # --- dS1/dt, dS2/dt (Subcutaneous Insulin Absorption) ---
+        dS1dt = u_insulin_mu_per_min - p.k_a * S1
+        dS2dt = p.k_a * S1 - p.k_a * S2
+
+        # Rate of appearance of insulin into plasma (mU/min)
+        Ra_I = p.k_a * S2
+
+        # --- dI/dt (Including residual beta-cell endogenous secretion) ---
+        # Beta is fraction of healthy beta cells.
+        endogenous_secretion = Beta * self.gamma_healthy * max(G - p.h, 0.0)
+        
+        # In T1D, basal endogenous insulin (p.Ib) should be proportional to Beta mass.
+        # If Beta = 0, and pump is off, insulin should decay to ZERO, not p.Ib.
+        target_Ib = p.Ib * Beta
+        
+        dIdt = -p.n * (I - target_Ib) + endogenous_secretion + Ra_I / Vi_abs
+
+        # --- Dalla Man Multi-compartment Meal Kinetcs ---
+        gastric_emptying_rate = 1.0 / max(float(p.tau_meal), 1.0)
+        solid_to_liquid_rate = gastric_emptying_rate * 1.5 
+        dQ_sto1_dt = -solid_to_liquid_rate * Q_sto1
+        dQ_sto2_dt = solid_to_liquid_rate * Q_sto1 - gastric_emptying_rate * Q_sto2
+        dQ_gut_dt = gastric_emptying_rate * Q_sto2 - p.k_abs * Q_gut
+
+        return np.array([
+            dGdt, dXdt, dIdt, dQ_sto1_dt, dQ_sto2_dt, dQ_gut_dt, 
+            dS1dt, dS2dt, dY1_dt, dY2_dt, dGamma_dt, dx_gluc_dt, 
+            dHAAF_dt, dF_dt, dK_dt, dBeta_dt
+        ])