iints-sdk-python35 1.5.6__py3-none-any.whl → 1.5.7__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.6"
+    __version__ = "1.5.7"
 
 # 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/cli/cli.py

@@ -137,6 +137,15 @@ from iints.live_patient.uno_q import (
     run_uno_q_bridge_test,
     uno_q_bridge_environment_report,
 )
+from iints.live_patient.pico_pump import (
+    PICO_PUMP_BAUDRATE,
+    PICO_PUMP_CONFIRMATION,
+    build_pico_pump_bundle,
+    create_pico_pump_lab,
+    export_pico_pump_firmware,
+    run_pico_pump_serial_self_test,
+    upload_pico_pump_bundle,
+)
 from iints.mdmp.backend import (
     MDMP_GRADE_ORDER,
     active_mdmp_backend,
@@ -232,6 +241,7 @@ plugin_app = typer.Typer(help="Install and manage local IINTS extension plugins.
 plugin_register_app = typer.Typer(help="Register a local plugin file by extension kind.")
 patientmodel_app = typer.Typer(help="Patient model registry and extension discovery.")
 edge_app = typer.Typer(help="Single-board computer and edge deployment tools.")
+edge_pump_app = typer.Typer(help="Bench-only Raspberry Pi Pico pump research workflow.")
 makerfaire_app = typer.Typer(help="Maker Faire booth startup helpers for the physical virtual patient setup.")
 jetson_app = typer.Typer(help="NVIDIA Jetson headless research tooling.")
 jetson_endurance_app = typer.Typer(help="Headless long-running adversarial endurance tests.")
@@ -247,6 +257,7 @@ app.add_typer(plugin_app, name="plugin")
 plugin_app.add_typer(plugin_register_app, name="register")
 app.add_typer(patientmodel_app, name="patientmodel")
 app.add_typer(edge_app, name="edge")
+edge_app.add_typer(edge_pump_app, name="pump")
 app.add_typer(makerfaire_app, name="makerfaire")
 app.add_typer(patient_app, name="patient")
 app.add_typer(jetson_app, name="jetson")
@@ -4077,7 +4088,7 @@ def presets_create(
         f"basal_insulin_rate: {basal_insulin_rate}\n"
         f"insulin_sensitivity: {insulin_sensitivity}\n"
         f"carb_factor: {carb_factor}\n"
-        "glucose_decay_rate: 0.03\n"
+        "glucose_decay_rate: 0.003\n"
         f"initial_glucose: {initial_glucose}\n"
         "glucose_absorption_rate: 0.03\n"
         "insulin_action_duration: 300.0\n"
@@ -7174,6 +7185,96 @@ def research_evaluate_controller(
     console.print(f"[green]Evaluation report:[/green] {report['artifacts']['report_md']}")
 
 
+@research_app.command(name="local-ai-lab")
+def research_local_ai_lab(
+    run: Annotated[
+        List[str],
+        typer.Option(
+            "--run",
+            help="Repeatable run input in label=path form; path may contain a Jetson endurance bundle.",
+        ),
+    ],
+    output_dir: Annotated[Path, typer.Option(help="Output directory for datasets, models, and reports")] = Path(
+        "results/local_ai_lab"
+    ),
+    train_predictor: Annotated[
+        bool,
+        typer.Option(
+            "--train-predictor/--skip-predictor",
+            help="Train the local glucose predictor from the generated predictor dataset.",
+        ),
+    ] = True,
+    train_neural: Annotated[
+        bool,
+        typer.Option(
+            "--train-neural/--skip-neural",
+            help="Train the PyTorch controller in addition to the auditable linear controller.",
+        ),
+    ] = True,
+    evaluate: Annotated[
+        bool,
+        typer.Option(
+            "--evaluate/--skip-evaluation",
+            help="Run held-out closed-loop evaluation after training.",
+        ),
+    ] = True,
+    predictor_config: Annotated[
+        Optional[Path],
+        typer.Option(help="Optional predictor config YAML. Defaults to research/configs/predictor.yaml."),
+    ] = None,
+    duration_minutes: Annotated[int, typer.Option(help="Duration per held-out controller-evaluation run.")] = 1440,
+):
+    """Turn completed runs into local AI datasets, models, and evaluation evidence."""
+    console = Console()
+    if not run:
+        console.print("[bold red]At least one --run label=path value is required.[/bold red]")
+        raise typer.Exit(code=1)
+    parsed_runs: list[tuple[str, Path]] = []
+    for item in run:
+        if "=" not in item:
+            console.print(f"[bold red]Invalid --run value:[/bold red] {item}")
+            raise typer.Exit(code=1)
+        label, raw_path = item.split("=", 1)
+        path = Path(raw_path)
+        if not label.strip() or not path.exists():
+            console.print(f"[bold red]Invalid or missing run:[/bold red] {item}")
+            raise typer.Exit(code=1)
+        parsed_runs.append((label.strip(), path))
+
+    from iints.research.local_ai import run_local_ai_lab
+
+    try:
+        report = run_local_ai_lab(
+            parsed_runs,
+            output_dir=output_dir,
+            repo_root=Path(__file__).resolve().parents[3],
+            train_predictor=train_predictor,
+            predictor_config_path=predictor_config,
+            train_neural=train_neural,
+            evaluate=evaluate,
+            evaluation_duration_minutes=duration_minutes,
+        )
+    except Exception as exc:
+        console.print(f"[bold red]Local AI lab failed:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    table = Table(title="Local AI Research Lab")
+    table.add_column("Artifact", style="cyan")
+    table.add_column("Value", overflow="fold")
+    table.add_row("Predictor rows", str(report["predictor_dataset"]["rows"]))
+    table.add_row("Controller rows", str(report["controller_dataset"]["rows"]))
+    table.add_row("Linear controller", report["linear_controller"]["model_path"])
+    table.add_row("Neural status", report["neural_controller"]["status"])
+    table.add_row("Predictor status", report["predictor_training"]["status"])
+    table.add_row("Evaluation status", report["closed_loop_evaluation"]["status"])
+    table.add_row("Report", report["artifacts"]["report_md"])
+    console.print(table)
+    console.print(
+        "[yellow]Research only:[/yellow] trained artifacts are for simulator research, "
+        "not medical treatment or pump dosing."
+    )
+
+
 @research_app.command(name="export-onnx")
 def research_export_onnx(
     model: Annotated[Path, typer.Option(help="Predictor checkpoint (.pt)")] = Path("models/hupa_finetuned_v2/predictor.pt"),
@@ -8158,6 +8259,10 @@ def _print_endurance_status(console: Console, status: Dict[str, Any]) -> None:
         ("Interventions", status.get("interventions")),
         ("Critical events", status.get("critical_events")),
         ("Worst glucose", status.get("worst_glucose_mgdl")),
+        ("Physiology warnings", status.get("physiology_warning_count")),
+        ("Fail-soft rows", status.get("input_validator_fail_soft_rows")),
+        ("Blind hyperglycemia rows", status.get("algorithm_blind_hyperglycemia_rows")),
+        ("Truth/sensor gap", status.get("mean_abs_truth_sensor_gap_mgdl")),
         ("Last checkpoint minute", status.get("last_checkpoint_minute")),
         ("Resume count", status.get("resume_count")),
         ("Wall elapsed seconds", status.get("wall_elapsed_seconds")),
@@ -8208,7 +8313,7 @@ def jetson_endurance_start(
     output_dir: Annotated[Path, typer.Option(help="Output directory for the endurance study")] = Path("results/jetson_endurance"),
     profile: Annotated[str, typer.Option(help="Endurance profile name")] = "mixed_adversarial",
     seed: Annotated[int, typer.Option(help="Deterministic simulation seed")] = 42,
-    patient_model: Annotated[str, typer.Option(help="Patient model name passed to PatientFactory")] = "auto",
+    patient_model: Annotated[str, typer.Option(help="Patient model name passed to PatientFactory")] = "bergman",
     sensor_profile: Annotated[str, typer.Option(help="Sensor profile for the simulated CGM stream")] = "free_living_cgm",
     custom_profile: Annotated[Optional[Path], typer.Option(help="YAML file for --profile custom")] = None,
     time_step: Annotated[int, typer.Option(help="Simulation step size in minutes")] = 5,
@@ -10215,6 +10320,131 @@ def edge_hardware_bridge(
     console.print(table)
 
 
+@edge_pump_app.command(name="init")
+def edge_pump_init(
+    output_dir: Annotated[Path, typer.Option(help="Directory where the Pico pump lab workspace should be written.")] = Path("iints_pico_pump_lab"),
+    algorithm: Annotated[Optional[Path], typer.Option(help="Optional existing SDK algorithm to copy into the lab workspace.")] = None,
+) -> None:
+    console = Console()
+    try:
+        outputs = create_pico_pump_lab(output_dir, algorithm_path=algorithm)
+    except Exception as exc:
+        console.print(f"[bold red]Pico pump lab setup failed:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    table = Table(title="IINTS Pico Pump Lab")
+    table.add_column("Artifact", style="cyan")
+    table.add_column("Path", overflow="fold")
+    for key in ("output_dir", "algorithm", "safety_contract", "firmware_dir", "readme", "package_script"):
+        table.add_row(key, outputs[key])
+    console.print(table)
+    console.print("[yellow]Bench-only scope:[/yellow] no real insulin delivery, no animal/human use, no motor actuation.")
+
+
+@edge_pump_app.command(name="firmware")
+def edge_pump_firmware(
+    output_dir: Annotated[Path, typer.Option(help="Directory where locked Pico bench firmware should be written.")] = Path("pico_pump_firmware"),
+) -> None:
+    console = Console()
+    try:
+        outputs = export_pico_pump_firmware(output_dir)
+    except Exception as exc:
+        console.print(f"[bold red]Pico pump firmware export failed:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    table = Table(title="IINTS Pico Pump Bench Firmware")
+    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)
+
+
+@edge_pump_app.command(name="package")
+def edge_pump_package(
+    algorithm: Annotated[Path, typer.Option(help="SDK algorithm Python file to package for bench-only Pico testing.")],
+    output_dir: Annotated[Path, typer.Option(help="Output bundle directory.")] = Path("pico_pump_bundle"),
+    safety_contract: Annotated[Optional[Path], typer.Option(help="Optional zero-delivery safety contract JSON.")] = None,
+    label: Annotated[str, typer.Option(help="Human-readable bundle label written into the manifest.")] = "pico_pump_bench",
+) -> None:
+    console = Console()
+    try:
+        outputs = build_pico_pump_bundle(
+            algorithm,
+            output_dir,
+            safety_contract_path=safety_contract,
+            label=label,
+        )
+    except Exception as exc:
+        console.print(f"[bold red]Pico pump bundle failed:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    table = Table(title="IINTS Pico Pump Bench Bundle")
+    table.add_column("Artifact", style="cyan")
+    table.add_column("Value", overflow="fold")
+    table.add_row("output_dir", outputs["output_dir"])
+    table.add_row("algorithm", outputs["algorithm"])
+    table.add_row("algorithm_sha256", outputs["algorithm_sha256"])
+    table.add_row("safety_contract", outputs["safety_contract"])
+    table.add_row("manifest", outputs["manifest"])
+    console.print(table)
+    console.print("[green]Bundle ready for bench-only upload.[/green]")
+
+
+@edge_pump_app.command(name="upload")
+def edge_pump_upload(
+    bundle_dir: Annotated[Path, typer.Option(help="Bundle directory from `iints edge pump package`.")],
+    mount_dir: Annotated[Path, typer.Option(help="Mounted writable Pico/CircuitPython-style drive or a test folder.")],
+    bench_only_confirm: Annotated[str, typer.Option(help=f"Must be exactly: {PICO_PUMP_CONFIRMATION}")] = "",
+    write: Annotated[bool, typer.Option("--write", help="Actually copy files. Without this flag, only prints the copy plan.")] = False,
+) -> None:
+    console = Console()
+    try:
+        payload = upload_pico_pump_bundle(
+            bundle_dir,
+            mount_dir,
+            bench_only_confirmation=bench_only_confirm,
+            write=write,
+        )
+    except Exception as exc:
+        console.print(f"[bold red]Pico pump upload refused:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    table = Table(title="IINTS Pico Pump Upload Plan" if not write else "IINTS Pico Pump Upload")
+    table.add_column("Field", style="cyan")
+    table.add_column("Value", overflow="fold")
+    table.add_row("bundle_dir", payload["bundle_dir"])
+    table.add_row("mount_dir", payload["mount_dir"])
+    table.add_row("write", str(payload["write"]))
+    table.add_row("scope", str(payload["manifest"].get("scope", "-")))
+    for destination in payload["copied"] if write else payload["planned"]:
+        table.add_row("copied" if write else "planned", destination)
+    console.print(table)
+    if not write:
+        console.print("[yellow]Dry run only.[/yellow] Add --write after checking the mount path.")
+
+
+@edge_pump_app.command(name="serial-test")
+def edge_pump_serial_test(
+    port: Annotated[str, typer.Option(help="Serial port for the Pico bench firmware, for example /dev/ttyACM0 or /dev/tty.usbmodem*.")],
+    baudrate: Annotated[int, typer.Option(help="Serial baud rate used by the Pico bench firmware.")] = PICO_PUMP_BAUDRATE,
+    timeout_seconds: Annotated[float, typer.Option(help="Read timeout per command in seconds.")] = 1.5,
+) -> None:
+    console = Console()
+    try:
+        results = run_pico_pump_serial_self_test(port, baudrate=baudrate, timeout_seconds=timeout_seconds)
+    except Exception as exc:
+        console.print(f"[bold red]Pico pump serial test failed:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    table = Table(title="IINTS Pico Pump Serial Test")
+    table.add_column("Command", style="cyan")
+    table.add_column("Response", overflow="fold")
+    for result in results:
+        table.add_row(str(result["command"]), str(result["response"] or "-"))
+    console.print(table)
+
+
 @edge_app.command(name="bridge-test")
 def edge_bridge_test(
     port: Annotated[Optional[str], typer.Option(help="Serial port for the UNO Q STM32 side. Use `auto` or omit it if exactly one port is connected.")] = None,

iints/core/patient/models.py

@@ -14,7 +14,7 @@ class CustomPatientModel:
     This model is intended for educational and stress-testing purposes, not for clinical accuracy.
     """
     def __init__(self, basal_insulin_rate: float = 0.8, insulin_sensitivity: float = 50.0,
-                 carb_factor: float = 10.0, glucose_decay_rate: float = 0.05,
+                 carb_factor: float = 10.0, glucose_decay_rate: float = 0.001,
                  initial_glucose: float = 120.0, glucose_absorption_rate: float = 0.03,
                  basal_glucose_target: Optional[float] = None,
                  insulin_action_duration: float = 300.0, # minutes, e.g., 5 hours

iints/core/patient/profile.py

@@ -18,7 +18,7 @@ class PatientProfile:
     dawn_end_hour: float = 8.0
 
     # Advanced knobs (optional)
-    glucose_decay_rate: float = 0.05
+    glucose_decay_rate: float = 0.001
     glucose_absorption_rate: float = 0.03
     insulin_action_duration: float = 300.0
     insulin_peak_time: float = 75.0

iints/core/simulator.py

@@ -9,6 +9,11 @@ from iints.core.patient.models import PatientModel
 from iints.api.base_algorithm import InsulinAlgorithm, AlgorithmInput
 from iints.core.supervisor import IndependentSupervisor, SafetyLevel
 from iints.core.safety import InputValidator, SafetyConfig
+from iints.core.safety.config import (
+    SIMULATION_GLUCOSE_CEILING_MGDL,
+    SIMULATION_GLUCOSE_FLOOR_MGDL,
+    SENSOR_MAX_GLUCOSE_RATE_PER_MIN_MGDL,
+)
 from iints.core.devices.models import SensorModel, PumpModel
 from iints.core.physiology_variation import EmpiricalResidualModel
 import numpy as np
@@ -119,9 +124,9 @@ class Simulator:
         self.seed = seed
         self.safety_config = safety_config or SafetyConfig()
         self.supervisor = IndependentSupervisor(safety_config=self.safety_config)
-        # Raw physiology and CGM-facing values each need their own temporal
-        # history. Sharing one stateful validator made raw glucose compare
-        # against the previous noisy sensor sample.
+        # Keep the raw validator for older snapshots/audits, but do not apply
+        # CGM rate limits to hidden patient truth; only algorithm-facing sensor
+        # inputs are plausibility-filtered.
         self.raw_input_validator = InputValidator(safety_config=self.safety_config)
         self.input_validator = InputValidator(safety_config=self.safety_config)
         self.sensor_model = sensor_model or SensorModel(seed=seed)
@@ -161,6 +166,7 @@ class Simulator:
         self._ratio_overrides: List[Dict[str, Any]] = []
         self._base_ratio_state: Optional[Dict[str, float]] = None
         self._previous_glucose_for_trend: Optional[float] = None
+        self._glucose_trend_history: List[Tuple[float, float]] = []
         self._profiling_samples: Dict[str, List[float]] = {
             "algorithm_latency_ms": [],
             "supervisor_latency_ms": [],
@@ -361,10 +367,20 @@ class Simulator:
             self._input_validator_last_error = str(exc)
             self._input_validator_last_step_fail_soft = True
             fallback = active_validator.last_valid_glucose
+            incoming_value = float(glucose_value)
+            if not np.isfinite(incoming_value):
+                incoming_value = float(fallback) if fallback is not None else active_validator.min_glucose
+            if fallback is not None and active_validator.last_validation_time is not None:
+                time_delta = max(float(current_time) - float(active_validator.last_validation_time), 0.0)
+                if time_delta > 0.0:
+                    allowed_delta = active_validator.max_glucose_delta_per_5_min * (time_delta / 5.0)
+                    requested_delta = incoming_value - float(fallback)
+                    fallback = float(fallback) + float(
+                        max(-allowed_delta, min(requested_delta, allowed_delta))
+                    )
             if fallback is None:
-                fallback = float(
-                    max(active_validator.min_glucose, min(glucose_value, active_validator.max_glucose))
-                )
+                fallback = incoming_value
+            fallback = float(max(active_validator.min_glucose, min(fallback, active_validator.max_glucose)))
             self._write_audit_log(
                 {
                     "timestamp": current_time,
@@ -378,6 +394,81 @@ class Simulator:
             active_validator.last_valid_glucose = fallback
             active_validator.last_validation_time = current_time
             return fallback
+
+    def _bound_simulation_glucose(self, glucose_value: float, current_time: float) -> float:
+        """
+        Keep the hidden physiological state numerically bounded without applying
+        CGM input rate limits to the patient truth trace.
+
+        The input validator is intentionally strict for sensor values that reach
+        an algorithm. The simulated patient state can move faster during stress
+        tests, so rate-limiting it would hide the very physiology we need to
+        evaluate.
+        """
+        if not np.isfinite(glucose_value):
+            fallback = float(self.patient_model.get_current_glucose())
+            self._write_audit_log(
+                {
+                    "timestamp": current_time,
+                    "event": "simulation_glucose_non_finite",
+                    "input_value": glucose_value,
+                    "fallback_value": fallback,
+                }
+            )
+            return fallback
+        clipped = float(
+            np.clip(
+                glucose_value,
+                SIMULATION_GLUCOSE_FLOOR_MGDL,
+                SIMULATION_GLUCOSE_CEILING_MGDL,
+            )
+        )
+        if clipped != float(glucose_value):
+            self._write_audit_log(
+                {
+                    "timestamp": current_time,
+                    "event": "simulation_glucose_clipped",
+                    "input_value": glucose_value,
+                    "clipped_value": clipped,
+                }
+            )
+        return clipped
+
+    def _update_glucose_trend(self, current_time: float, glucose_value: float) -> float:
+        """
+        Estimate CGM trend with a short rolling slope instead of one noisy delta.
+
+        A single noisy 5-minute CGM drop can otherwise look like an impossible
+        30-minute hypoglycemia trajectory. A rolling 20-minute regression keeps
+        the signal responsive while avoiding startup/noise spikes.
+        """
+        self._glucose_trend_history.append((float(current_time), float(glucose_value)))
+        window_minutes = max(20.0, float(self.time_step) * 3.0)
+        cutoff = float(current_time) - window_minutes
+        self._glucose_trend_history = [
+            (t, g) for (t, g) in self._glucose_trend_history if t >= cutoff
+        ]
+        self._previous_glucose_for_trend = float(glucose_value)
+
+        if len(self._glucose_trend_history) < 3:
+            return 0.0
+
+        times = np.array([t for t, _ in self._glucose_trend_history], dtype=float)
+        values = np.array([g for _, g in self._glucose_trend_history], dtype=float)
+        if float(times[-1] - times[0]) < max(float(self.time_step) * 2.0, 10.0):
+            return 0.0
+
+        centered_time = times - float(times.mean())
+        denom = float(np.dot(centered_time, centered_time))
+        if denom <= 0.0:
+            return 0.0
+
+        slope = float(np.dot(centered_time, values - float(values.mean())) / denom)
+        max_rate = min(
+            float(getattr(self.safety_config, "glucose_rate_alarm", SENSOR_MAX_GLUCOSE_RATE_PER_MIN_MGDL)),
+            SENSOR_MAX_GLUCOSE_RATE_PER_MIN_MGDL,
+        )
+        return float(np.clip(slope, -max_rate, max_rate))
     def _apply_ratio_overrides(self, current_time: float) -> Dict[str, float]:
         if self._base_ratio_state is None:
             self._base_ratio_state = self.patient_model.get_ratio_state()
@@ -572,6 +663,7 @@ class Simulator:
             self._ratio_overrides = []
             self._base_ratio_state = self.patient_model.get_ratio_state()
             self._previous_glucose_for_trend = None
+            self._glucose_trend_history = []
             self._input_validator_fail_soft_count = 0
             self._input_validator_negative_insulin_clamp_count = 0
             self._input_validator_last_error = None
@@ -600,12 +692,9 @@ class Simulator:
             if self.physiology_variation_model is not None:
                 physiology_residual = self.physiology_variation_model.offset_at(float(current_time))
             actual_glucose_reading = mechanistic_glucose_reading + physiology_residual
-            # Validate the raw sensor reading
-            actual_glucose_reading = self._validate_glucose_fail_soft(
+            actual_glucose_reading = self._bound_simulation_glucose(
                 actual_glucose_reading,
                 float(current_time),
-                "sensor_raw",
-                validator=self.raw_input_validator,
             )
             sensor_reading = self.sensor_model.read(actual_glucose_reading, float(current_time))
             glucose_to_algorithm = sensor_reading.value
@@ -682,11 +771,8 @@ class Simulator:
             effective_dia = float(ratio_state.get("dia_minutes", self.patient_model.insulin_action_duration))
             effective_basal = float(ratio_state.get("basal_rate_u_per_hr", self.patient_model.basal_insulin_rate))
 
-            # Glucose trend (mg/dL per minute) based on sensor value
-            glucose_trend = 0.0
-            if self._previous_glucose_for_trend is not None:
-                glucose_trend = (glucose_to_algorithm - self._previous_glucose_for_trend) / float(self.time_step)
-            self._previous_glucose_for_trend = glucose_to_algorithm
+            # Glucose trend (mg/dL per minute) based on a short smoothed CGM window.
+            glucose_trend = self._update_glucose_trend(float(current_time), glucose_to_algorithm)
 
             predicted_glucose_heuristic = self._predict_glucose(
                 current_glucose=glucose_to_algorithm,
@@ -909,6 +995,13 @@ class Simulator:
                 current_time=float(current_time),
             )
 
+            bolus_insulin_reported = insulin_output.get("bolus_insulin")
+            if bolus_insulin_reported is None:
+                bolus_insulin_reported = (
+                    float(insulin_output.get("meal_bolus", 0.0))
+                    + float(insulin_output.get("correction_bolus", 0.0))
+                )
+
             # --- Record Data ---
             record = {
                 "time_minutes": current_time,
@@ -933,7 +1026,8 @@ class Simulator:
                 "pump_status": pump_delivery.status,
                 "pump_reason": pump_delivery.reason,
                 "basal_insulin_units": insulin_output.get("basal_insulin", 0.0),
-                "bolus_insulin_units": insulin_output.get("bolus_insulin", 0.0) + insulin_output.get("meal_bolus", 0.0), # Combine for simplicity
+                "bolus_insulin_units": bolus_insulin_reported,
+                "meal_bolus_units": insulin_output.get("meal_bolus", 0.0),
                 "correction_bolus_units": insulin_output.get("correction_bolus", 0.0),
                 "carb_intake_grams": patient_carb_intake_this_step,
                 "patient_iob_units": self.patient_model.insulin_on_board,
@@ -1003,6 +1097,7 @@ class Simulator:
             "meal_queue": self.meal_queue,
             "stress_events": [event.__dict__ for event in self.stress_events],
             "critical_low_minutes": self._critical_low_minutes,
+            "glucose_trend_history": self._glucose_trend_history,
         }
 
     def load_state(self, state: Dict[str, Any]) -> None:
@@ -1020,6 +1115,11 @@ class Simulator:
         self.meal_queue = state.get("meal_queue", [])
         self.stress_events = [StressEvent(**payload) for payload in state.get("stress_events", [])]
         self._critical_low_minutes = state.get("critical_low_minutes", 0)
+        self._glucose_trend_history = [
+            (float(item[0]), float(item[1]))
+            for item in state.get("glucose_trend_history", [])
+            if isinstance(item, (list, tuple)) and len(item) == 2
+        ]
         self._resume_state = True
 
     def _build_performance_report(self) -> Dict[str, Any]:

iints/data/virtual_patients/clinic_safe_baseline.yaml

@@ -1,7 +1,7 @@
 basal_insulin_rate: 0.5
 insulin_sensitivity: 50.0
 carb_factor: 10.0
-glucose_decay_rate: 0.03
+glucose_decay_rate: 0.003
 initial_glucose: 140.0
 glucose_absorption_rate: 0.03
 insulin_action_duration: 300.0

iints/data/virtual_patients/clinic_safe_hyper_challenge.yaml

@@ -1,7 +1,7 @@
 basal_insulin_rate: 0.55
 insulin_sensitivity: 45.0
 carb_factor: 9.0
-glucose_decay_rate: 0.03
+glucose_decay_rate: 0.003
 initial_glucose: 150.0
 glucose_absorption_rate: 0.03
 insulin_action_duration: 300.0

iints/data/virtual_patients/clinic_safe_hypo_prone.yaml

@@ -1,7 +1,7 @@
 basal_insulin_rate: 0.35
 insulin_sensitivity: 55.0
 carb_factor: 12.0
-glucose_decay_rate: 0.03
+glucose_decay_rate: 0.003
 initial_glucose: 130.0
 glucose_absorption_rate: 0.03
 insulin_action_duration: 300.0

iints/data/virtual_patients/clinic_safe_midnight.yaml

@@ -1,7 +1,7 @@
 basal_insulin_rate: 0.45
 insulin_sensitivity: 65.0
 carb_factor: 11.0
-glucose_decay_rate: 0.03
+glucose_decay_rate: 0.003
 initial_glucose: 125.0
 glucose_absorption_rate: 0.03
 insulin_action_duration: 300.0

iints/data/virtual_patients/clinic_safe_pizza.yaml

@@ -1,7 +1,7 @@
 basal_insulin_rate: 0.5
 insulin_sensitivity: 50.0
 carb_factor: 10.0
-glucose_decay_rate: 0.03
+glucose_decay_rate: 0.003
 initial_glucose: 135.0
 glucose_absorption_rate: 0.03
 insulin_action_duration: 300.0

iints/data/virtual_patients/clinic_safe_stress_meal.yaml

@@ -1,7 +1,7 @@
 basal_insulin_rate: 0.4
 insulin_sensitivity: 55.0
 carb_factor: 11.0
-glucose_decay_rate: 0.03
+glucose_decay_rate: 0.003
 initial_glucose: 120.0
 glucose_absorption_rate: 0.03
 insulin_action_duration: 300.0

iints/data/virtual_patients/default_patient.yaml

@@ -4,7 +4,7 @@
 basal_insulin_rate: 0.8        # U/hr
 insulin_sensitivity: 50.0      # mg/dL per Unit
 carb_factor: 10.0              # g/Unit
-glucose_decay_rate: 0.05       # Rate at which glucose naturally decreases
+glucose_decay_rate: 0.001       # Rate at which glucose naturally decreases
 initial_glucose: 120.0         # mg/dL
 glucose_absorption_rate: 0.03  # Rate at which carbs are absorbed into glucose
 insulin_action_duration: 300.0 # minutes, e.g., 5 hours