Publish Gradio console bundle

space-bundle/README.md

@@ -0,0 +1,26 @@
+---
+title: Hospital Operations Command Center
+emoji: 🏥
+colorFrom: blue
+colorTo: indigo
+sdk: gradio
+sdk_version: "5.50.0"
+app_file: app.py
+python_version: "3.12"
+license: mit
+short_description: OR scheduling, SimPy simulation, ML quantiles, disruption replanning
+tags:
+- healthcare
+- operations-research
+- scheduling
+- gradio
+- simulation
+---
+
+# Hospital Operations Command Center
+
+Interactive command center for multi-layer hospital operations planning — OR scheduling, bed capacity, nurse rostering, policy benchmarking, and real-time disruption response.
+
+**Layers:** Weekly block planning · Daily OR sequencing · Real-time re-optimization  
+**Policies:** FCFS · Deterministic · Robust Quantile · Rolling Horizon  
+**Stack:** OR-Tools CP-SAT · SimPy · Quantile ML · Plotly

space-bundle/app.py

@@ -0,0 +1,245 @@
+"""
+Hospital Operations Command Center — Interactive Command Center
+Multi-layer OR scheduling, bed planning, nurse rostering, and disruption response.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import gradio as gr
+import pandas as pd
+import plotly.graph_objects as go
+
+ROOT = Path(__file__).resolve().parent
+sys.path.insert(0, str(ROOT / "src"))
+
+from hopcc.constants import POLICIES, SCENARIOS, SIZE_PRESETS  # noqa: E402
+from hopcc.ml_predictor import MLPredictor  # noqa: E402
+from hopcc.pipeline import HopccPipeline  # noqa: E402
+from hopcc.visualization import (  # noqa: E402
+    build_disruption_delta,
+    build_gantt,
+    build_policy_comparison,
+    build_utilization_timeline,
+)
+
+pipeline = HopccPipeline(ROOT / "assets")
+pipeline.load()
+
+SUMMARY = pipeline.summary
+predictor = MLPredictor()
+
+CUSTOM_CSS = """
+.gradio-container { max-width: 1560px !important; }
+.markdown h1 { color: #1d4ed8; font-weight: 700; }
+"""
+
+_state: dict = {"last_policy": None, "last_disruption": None}
+
+
+def _kpi_md() -> str:
+    return f"""
+### Hospital Operations Command Center
+
+| Metric | Value |
+|--------|-------|
+| Engine version | **v{pipeline.version}** |
+| Planning scenarios | **{SUMMARY.get('scenarios', 5)}** (OR daily/weekly, ICU beds, nurses, emergency) |
+| Scheduling policies | **{SUMMARY.get('policies', 4)}** benchmarked |
+| ML predictors | **{SUMMARY.get('ml_models', 5)}** (duration quantiles, cancellation, ICU, LOS, no-show) |
+| Benchmark runs | **{SUMMARY.get('total_benchmark_runs', 0)}** pre-computed |
+| Winner distribution | {SUMMARY.get('winner_distribution', {})} |
+"""
+
+
+def _run_schedule(scenario, size, seed, policy):
+    pr = pipeline.run_policy(scenario, size, int(seed), policy)
+    _state["last_policy"] = pr
+    rows = [
+        {
+            "Case": s.case_id,
+            "Room": s.room_id,
+            "Surgeon": s.surgeon_id,
+            "Start": s.start_min,
+            "End": s.end_min,
+            "Turnover End": s.turnover_end,
+            "ICU Reserved": s.icu_reserved,
+        }
+        for s in pr.schedule
+    ]
+    df = pd.DataFrame(rows)
+    fig = build_gantt(pr.schedule, f"OR Schedule — {POLICIES[policy]['label']}")
+    fig_util = build_utilization_timeline(pr.schedule)
+    metrics_md = "\n".join(f"- **{k}:** {v}" for k, v in pr.metrics.items())
+    summary = f"**Policy:** {pr.policy_label} · **Feasible:** {pr.feasible} · **Runtime:** {pr.elapsed_sec}s\n\n{metrics_md}\n\n_{pr.notes}_"
+    return df, fig, fig_util, summary
+
+
+def _run_benchmark(scenario, size, seed):
+    inst = pipeline.get_instance(scenario, size, int(seed))
+    rows = []
+    for pid in POLICIES:
+        pr = pipeline.run_policy(scenario, size, int(seed), pid)
+        rows.append({"policy_id": pid, "policy_label": pr.policy_label, **pr.metrics})
+    fig = build_policy_comparison(rows)
+    df = pd.DataFrame(rows)
+    winner = min(rows, key=lambda r: r.get("composite_penalty", 1e9))
+    md = f"**Recommended policy:** {winner['policy_label']} (lowest composite penalty)"
+    return df, fig, md
+
+
+def _run_disruption(scenario, size, seed):
+    comp = pipeline.run_disruption_demo(scenario, size, int(seed))
+    _state["last_disruption"] = comp
+    before_fig = build_gantt(comp.schedule_before, "Schedule After Disruptions (Before Replan)")
+    after_fig = build_gantt(comp.schedule_after, "Re-optimized Schedule")
+    delta_fig = build_disruption_delta(comp.baseline_metrics, comp.replanned_metrics)
+    events = "\n".join(f"- {d.label}" for d in comp.disruptions)
+    imp = "\n".join(f"- {k}: {v}%" for k, v in comp.improvement_pct.items())
+    md = f"""
+### Disruption Command Center
+
+**Events applied:**
+{events}
+
+**Improvement after re-optimization:**
+{imp}
+"""
+    return before_fig, after_fig, delta_fig, md
+
+
+def _ml_predict(specialty, experience, age, asa, complexity):
+    preds = predictor.predict_surgery_duration(
+        specialty=specialty,
+        surgeon_experience=int(experience),
+        patient_age=int(age),
+        asa_score=int(asa),
+        procedure_complexity=float(complexity),
+        prior_surgeries=2,
+    )
+    cancel = predictor.predict_cancellation(specialty, 2, 4, 0.6)
+    icu = predictor.predict_icu_need(specialty, int(asa), float(complexity))
+    los = predictor.predict_los(specialty, icu > 0.5, int(age))
+    noshow = predictor.predict_no_show(2, 10)
+
+    fig = go.Figure(go.Bar(
+        x=["P50", "P80", "P95"],
+        y=[preds["p50"], preds["p80"], preds["p95"]],
+        marker_color=["#3b82f6", "#6366f1", "#8b5cf6"],
+        text=[f"{v} min" for v in preds.values()],
+        textposition="outside",
+    ))
+    fig.update_layout(title="Surgery Duration Quantiles", yaxis_title="Minutes", height=360)
+
+    md = f"""
+| Prediction | Value |
+|------------|-------|
+| P50 duration | **{preds['p50']} min** |
+| P80 duration | **{preds['p80']} min** |
+| P95 duration | **{preds['p95']} min** |
+| Cancellation risk | **{cancel:.1%}** |
+| ICU probability | **{icu:.1%}** |
+| Expected LOS | **{los} days** |
+| No-show risk | **{noshow:.1%}** |
+
+_Robust scheduler uses P80 by default; risk-averse mode uses P95._
+"""
+    return fig, md
+
+
+def _simulation_tab(scenario, size, seed, policy):
+    sim = pipeline.run_simulation(scenario, size, int(seed), policy)
+    md = "\n".join(f"- **{k}:** {v}" for k, v in sim.items())
+    return f"### SimPy Patient Flow Simulation\n{md}"
+
+
+def _benchmark_table():
+    rows = pipeline.benchmark_table_rows()
+    if not rows:
+        return pd.DataFrame()
+    return pd.DataFrame(rows[:50])
+
+
+with gr.Blocks(title="Hospital Operations Command Center", css=CUSTOM_CSS) as demo:
+    gr.Markdown("# Hospital Operations Command Center")
+    gr.Markdown(
+        "Multi-layer **operations research** platform for hospital command centers — "
+        "OR scheduling, ICU/ward bed planning, nurse rostering, ML-informed robust planning, "
+        "SimPy patient-flow simulation, and real-time disruption re-optimization."
+    )
+    gr.Markdown(_kpi_md())
+
+    with gr.Tabs():
+        with gr.Tab("Schedule Optimizer"):
+            with gr.Row():
+                sc = gr.Dropdown(list(SCENARIOS.keys()), value="or_daily", label="Scenario")
+                sz = gr.Dropdown(list(SIZE_PRESETS.keys()), value="medium", label="Size")
+                sd = gr.Number(value=42, label="Seed", precision=0)
+                pol = gr.Dropdown(list(POLICIES.keys()), value="robust_quantile", label="Policy")
+            btn = gr.Button("Generate Schedule", variant="primary")
+            sched_df = gr.Dataframe(label="Schedule")
+            sched_summary = gr.Markdown()
+            with gr.Row():
+                gantt = gr.Plot(label="Gantt Chart")
+                util = gr.Plot(label="Utilization")
+            btn.click(_run_schedule, [sc, sz, sd, pol], [sched_df, gantt, util, sched_summary])
+
+        with gr.Tab("Policy Benchmark"):
+            with gr.Row():
+                b_sc = gr.Dropdown(list(SCENARIOS.keys()), value="or_daily", label="Scenario")
+                b_sz = gr.Dropdown(list(SIZE_PRESETS.keys()), value="medium", label="Size")
+                b_sd = gr.Number(value=42, label="Seed", precision=0)
+            b_btn = gr.Button("Run 4-Policy Benchmark", variant="primary")
+            b_df = gr.Dataframe()
+            b_fig = gr.Plot()
+            b_md = gr.Markdown()
+            b_btn.click(_run_benchmark, [b_sc, b_sz, b_sd], [b_df, b_fig, b_md])
+            gr.Dataframe(value=_benchmark_table(), label="Pre-computed Benchmark Sample")
+
+        with gr.Tab("Disruption Command Center"):
+            gr.Markdown(
+                "Apply simultaneous disruptions: **+90 min surgery overrun**, **ICU bed loss**, "
+                "**2 nurse absences**, and **emergency admission** — then compare before/after re-optimization."
+            )
+            with gr.Row():
+                d_sc = gr.Dropdown(list(SCENARIOS.keys()), value="or_daily", label="Scenario")
+                d_sz = gr.Dropdown(list(SIZE_PRESETS.keys()), value="medium", label="Size")
+                d_sd = gr.Number(value=42, label="Seed", precision=0)
+            d_btn = gr.Button("Simulate Disruptions & Replan", variant="primary")
+            d_md = gr.Markdown()
+            with gr.Row():
+                d_before = gr.Plot(label="Before")
+                d_after = gr.Plot(label="After")
+            d_delta = gr.Plot(label="Metrics Delta")
+            d_btn.click(_run_disruption, [d_sc, d_sz, d_sd], [d_before, d_after, d_delta, d_md])
+
+        with gr.Tab("ML Predictions"):
+            with gr.Row():
+                sp = gr.Dropdown(
+                    ["general", "orthopedic", "cardiac", "neuro", "ent", "urology", "gynecology", "thoracic"],
+                    value="cardiac", label="Specialty",
+                )
+                exp = gr.Slider(1, 25, value=12, step=1, label="Surgeon Experience (years)")
+                age = gr.Slider(18, 95, value=62, step=1, label="Patient Age")
+                asa = gr.Slider(1, 4, value=3, step=1, label="ASA Score")
+                cx = gr.Slider(0.1, 1.0, value=0.7, step=0.05, label="Procedure Complexity")
+            ml_btn = gr.Button("Predict Risks & Durations", variant="primary")
+            ml_fig = gr.Plot()
+            ml_md = gr.Markdown()
+            ml_btn.click(_ml_predict, [sp, exp, age, asa, cx], [ml_fig, ml_md])
+
+        with gr.Tab("Patient Flow Simulation"):
+            with gr.Row():
+                s_sc = gr.Dropdown(list(SCENARIOS.keys()), value="or_daily", label="Scenario")
+                s_sz = gr.Dropdown(list(SIZE_PRESETS.keys()), value="medium", label="Size")
+                s_sd = gr.Number(value=42, label="Seed", precision=0)
+                s_pol = gr.Dropdown(list(POLICIES.keys()), value="rolling_horizon", label="Policy")
+            s_btn = gr.Button("Run SimPy Simulation", variant="primary")
+            s_md = gr.Markdown()
+            s_btn.click(_simulation_tab, [s_sc, s_sz, s_sd, s_pol], [s_md])
+
+if __name__ == "__main__":
+    demo.launch()

space-bundle/assets/demo/benchmarks.json

@@ -0,0 +1,673 @@
+[
+  {
+    "scenario_id": "or_daily",
+    "size": "small",
+    "seed": 42,
+    "policy_id": "manual_fcfs",
+    "policy_label": "Manual / First-Come-First-Served",
+    "surgeries_completed": 8,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 38.1,
+    "bed_shortage_events": 7,
+    "avg_patient_wait_min": 108.9,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.25,
+    "composite_penalty": 318.9,
+    "feasible": false,
+    "sim_completed": 5,
+    "sim_avg_wait": 16.1,
+    "sim_or_util": 24.8,
+    "elapsed_sec": 0.0
+  },
+  {
+    "scenario_id": "or_daily",
+    "size": "small",
+    "seed": 42,
+    "policy_id": "deterministic_mean",
+    "policy_label": "Deterministic Mean-Duration Plan",
+    "surgeries_completed": 8,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 38.1,
+    "bed_shortage_events": 7,
+    "avg_patient_wait_min": 99.0,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.25,
+    "composite_penalty": 309.0,
+    "feasible": false,
+    "sim_completed": 6,
+    "sim_avg_wait": 30.0,
+    "sim_or_util": 24.7,
+    "elapsed_sec": 0.587
+  },
+  {
+    "scenario_id": "or_daily",
+    "size": "small",
+    "seed": 42,
+    "policy_id": "robust_quantile",
+    "policy_label": "Robust Quantile Schedule",
+    "surgeries_completed": 8,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 59.9,
+    "bed_shortage_events": 5,
+    "avg_patient_wait_min": 215.4,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.25,
+    "composite_penalty": 365.4,
+    "feasible": false,
+    "sim_completed": 4,
+    "sim_avg_wait": 0.1,
+    "sim_or_util": 24.7,
+    "elapsed_sec": 0.015
+  },
+  {
+    "scenario_id": "or_daily",
+    "size": "small",
+    "seed": 42,
+    "policy_id": "rolling_horizon",
+    "policy_label": "Rolling Horizon Re-optimization",
+    "surgeries_completed": 8,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 49.6,
+    "bed_shortage_events": 7,
+    "avg_patient_wait_min": 147.4,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.25,
+    "composite_penalty": 357.4,
+    "feasible": false,
+    "sim_completed": 2,
+    "sim_avg_wait": 0.1,
+    "sim_or_util": 24.8,
+    "elapsed_sec": 0.002
+  },
+  {
+    "scenario_id": "or_daily",
+    "size": "small",
+    "seed": 123,
+    "policy_id": "manual_fcfs",
+    "policy_label": "Manual / First-Come-First-Served",
+    "surgeries_completed": 8,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 33.8,
+    "bed_shortage_events": 5,
+    "avg_patient_wait_min": 114.9,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.188,
+    "composite_penalty": 264.9,
+    "feasible": false,
+    "sim_completed": 5,
+    "sim_avg_wait": 44.8,
+    "sim_or_util": 30.8,
+    "elapsed_sec": 0.0
+  },
+  {
+    "scenario_id": "or_daily",
+    "size": "small",
+    "seed": 123,
+    "policy_id": "deterministic_mean",
+    "policy_label": "Deterministic Mean-Duration Plan",
+    "surgeries_completed": 8,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 33.8,
+    "bed_shortage_events": 5,
+    "avg_patient_wait_min": 79.1,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.188,
+    "composite_penalty": 229.1,
+    "feasible": false,
+    "sim_completed": 3,
+    "sim_avg_wait": 61.9,
+    "sim_or_util": 30.9,
+    "elapsed_sec": 0.027
+  },
+  {
+    "scenario_id": "or_daily",
+    "size": "small",
+    "seed": 123,
+    "policy_id": "robust_quantile",
+    "policy_label": "Robust Quantile Schedule",
+    "surgeries_completed": 8,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 68.2,
+    "bed_shortage_events": 5,
+    "avg_patient_wait_min": 178.4,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.188,
+    "composite_penalty": 328.4,
+    "feasible": false,
+    "sim_completed": 5,
+    "sim_avg_wait": 1.4,
+    "sim_or_util": 30.9,
+    "elapsed_sec": 0.015
+  },
+  {
+    "scenario_id": "or_daily",
+    "size": "small",
+    "seed": 123,
+    "policy_id": "rolling_horizon",
+    "policy_label": "Rolling Horizon Re-optimization",
+    "surgeries_completed": 8,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 56.9,
+    "bed_shortage_events": 5,
+    "avg_patient_wait_min": 146.4,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.188,
+    "composite_penalty": 296.4,
+    "feasible": false,
+    "sim_completed": 4,
+    "sim_avg_wait": 0.4,
+    "sim_or_util": 30.6,
+    "elapsed_sec": 0.002
+  },
+  {
+    "scenario_id": "or_daily",
+    "size": "medium",
+    "seed": 42,
+    "policy_id": "manual_fcfs",
+    "policy_label": "Manual / First-Come-First-Served",
+    "surgeries_completed": 16,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 84,
+    "or_utilization_pct": 55.7,
+    "bed_shortage_events": 13,
+    "avg_patient_wait_min": 168.8,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.161,
+    "composite_penalty": 600.8,
+    "feasible": false,
+    "sim_completed": 6,
+    "sim_avg_wait": 19.2,
+    "sim_or_util": 31.5,
+    "elapsed_sec": 0.0
+  },
+  {
+    "scenario_id": "or_daily",
+    "size": "medium",
+    "seed": 42,
+    "policy_id": "deterministic_mean",
+    "policy_label": "Deterministic Mean-Duration Plan",
+    "surgeries_completed": 16,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 55.7,
+    "bed_shortage_events": 13,
+    "avg_patient_wait_min": 162.6,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.161,
+    "composite_penalty": 552.6,
+    "feasible": false,
+    "sim_completed": 4,
+    "sim_avg_wait": 25.0,
+    "sim_or_util": 32.0,
+    "elapsed_sec": 0.029
+  },
+  {
+    "scenario_id": "or_daily",
+    "size": "medium",
+    "seed": 42,
+    "policy_id": "robust_quantile",
+    "policy_label": "Robust Quantile Schedule",
+    "surgeries_completed": 0,
+    "surgeries_cancelled": 16,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 0,
+    "bed_shortage_events": 16,
+    "avg_patient_wait_min": 999,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 1.0,
+    "feasible": false,
+    "sim_completed": 0,
+    "sim_avg_wait": 0.0,
+    "sim_or_util": 0.0,
+    "elapsed_sec": 0.046
+  },
+  {
+    "scenario_id": "or_daily",
+    "size": "medium",
+    "seed": 42,
+    "policy_id": "rolling_horizon",
+    "policy_label": "Rolling Horizon Re-optimization",
+    "surgeries_completed": 16,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 67,
+    "or_utilization_pct": 64.1,
+    "bed_shortage_events": 15,
+    "avg_patient_wait_min": 254.4,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.161,
+    "composite_penalty": 737.9,
+    "feasible": false,
+    "sim_completed": 3,
+    "sim_avg_wait": 0.0,
+    "sim_or_util": 31.7,
+    "elapsed_sec": 0.015
+  },
+  {
+    "scenario_id": "or_daily",
+    "size": "medium",
+    "seed": 123,
+    "policy_id": "manual_fcfs",
+    "policy_label": "Manual / First-Come-First-Served",
+    "surgeries_completed": 16,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 37.2,
+    "bed_shortage_events": 13,
+    "avg_patient_wait_min": 120.1,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.25,
+    "composite_penalty": 510.1,
+    "feasible": false,
+    "sim_completed": 8,
+    "sim_avg_wait": 65.4,
+    "sim_or_util": 35.6,
+    "elapsed_sec": 0.0
+  },
+  {
+    "scenario_id": "or_daily",
+    "size": "medium",
+    "seed": 123,
+    "policy_id": "deterministic_mean",
+    "policy_label": "Deterministic Mean-Duration Plan",
+    "surgeries_completed": 16,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 37.2,
+    "bed_shortage_events": 13,
+    "avg_patient_wait_min": 125.4,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.25,
+    "composite_penalty": 515.4,
+    "feasible": false,
+    "sim_completed": 7,
+    "sim_avg_wait": 70.0,
+    "sim_or_util": 35.6,
+    "elapsed_sec": 0.032
+  },
+  {
+    "scenario_id": "or_daily",
+    "size": "medium",
+    "seed": 123,
+    "policy_id": "robust_quantile",
+    "policy_label": "Robust Quantile Schedule",
+    "surgeries_completed": 16,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 450,
+    "or_utilization_pct": 81.1,
+    "bed_shortage_events": 9,
+    "avg_patient_wait_min": 280.2,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.25,
+    "composite_penalty": 775.2,
+    "feasible": false,
+    "sim_completed": 2,
+    "sim_avg_wait": 0.8,
+    "sim_or_util": 35.7,
+    "elapsed_sec": 0.029
+  },
+  {
+    "scenario_id": "or_daily",
+    "size": "medium",
+    "seed": 123,
+    "policy_id": "rolling_horizon",
+    "policy_label": "Rolling Horizon Re-optimization",
+    "surgeries_completed": 16,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 60,
+    "or_utilization_pct": 69.1,
+    "bed_shortage_events": 10,
+    "avg_patient_wait_min": 226.3,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.25,
+    "composite_penalty": 556.3,
+    "feasible": false,
+    "sim_completed": 4,
+    "sim_avg_wait": 0.1,
+    "sim_or_util": 35.6,
+    "elapsed_sec": 0.03
+  },
+  {
+    "scenario_id": "emergency_surge",
+    "size": "small",
+    "seed": 42,
+    "policy_id": "manual_fcfs",
+    "policy_label": "Manual / First-Come-First-Served",
+    "surgeries_completed": 8,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 33.3,
+    "bed_shortage_events": 4,
+    "avg_patient_wait_min": 96.9,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.25,
+    "composite_penalty": 216.9,
+    "feasible": false,
+    "sim_completed": 4,
+    "sim_avg_wait": 10.6,
+    "sim_or_util": 25.8,
+    "elapsed_sec": 0.0
+  },
+  {
+    "scenario_id": "emergency_surge",
+    "size": "small",
+    "seed": 42,
+    "policy_id": "deterministic_mean",
+    "policy_label": "Deterministic Mean-Duration Plan",
+    "surgeries_completed": 8,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 33.3,
+    "bed_shortage_events": 5,
+    "avg_patient_wait_min": 71.0,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.25,
+    "composite_penalty": 221.0,
+    "feasible": false,
+    "sim_completed": 4,
+    "sim_avg_wait": 51.5,
+    "sim_or_util": 25.5,
+    "elapsed_sec": 0.013
+  },
+  {
+    "scenario_id": "emergency_surge",
+    "size": "small",
+    "seed": 42,
+    "policy_id": "robust_quantile",
+    "policy_label": "Robust Quantile Schedule",
+    "surgeries_completed": 8,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 61.6,
+    "bed_shortage_events": 5,
+    "avg_patient_wait_min": 148.2,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.25,
+    "composite_penalty": 298.2,
+    "feasible": false,
+    "sim_completed": 6,
+    "sim_avg_wait": 0.1,
+    "sim_or_util": 25.6,
+    "elapsed_sec": 0.016
+  },
+  {
+    "scenario_id": "emergency_surge",
+    "size": "small",
+    "seed": 42,
+    "policy_id": "rolling_horizon",
+    "policy_label": "Rolling Horizon Re-optimization",
+    "surgeries_completed": 8,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 51.2,
+    "bed_shortage_events": 2,
+    "avg_patient_wait_min": 137.5,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.25,
+    "composite_penalty": 197.5,
+    "feasible": false,
+    "sim_completed": 5,
+    "sim_avg_wait": 2.2,
+    "sim_or_util": 25.8,
+    "elapsed_sec": 0.015
+  },
+  {
+    "scenario_id": "emergency_surge",
+    "size": "small",
+    "seed": 123,
+    "policy_id": "manual_fcfs",
+    "policy_label": "Manual / First-Come-First-Served",
+    "surgeries_completed": 8,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 38.6,
+    "bed_shortage_events": 3,
+    "avg_patient_wait_min": 107.0,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.208,
+    "composite_penalty": 197.0,
+    "feasible": false,
+    "sim_completed": 6,
+    "sim_avg_wait": 25.2,
+    "sim_or_util": 28.0,
+    "elapsed_sec": 0.0
+  },
+  {
+    "scenario_id": "emergency_surge",
+    "size": "small",
+    "seed": 123,
+    "policy_id": "deterministic_mean",
+    "policy_label": "Deterministic Mean-Duration Plan",
+    "surgeries_completed": 8,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 38.6,
+    "bed_shortage_events": 3,
+    "avg_patient_wait_min": 99.6,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.208,
+    "composite_penalty": 189.6,
+    "feasible": false,
+    "sim_completed": 5,
+    "sim_avg_wait": 57.1,
+    "sim_or_util": 27.9,
+    "elapsed_sec": 0.015
+  },
+  {
+    "scenario_id": "emergency_surge",
+    "size": "small",
+    "seed": 123,
+    "policy_id": "robust_quantile",
+    "policy_label": "Robust Quantile Schedule",
+    "surgeries_completed": 8,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 62.3,
+    "bed_shortage_events": 3,
+    "avg_patient_wait_min": 146.9,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.208,
+    "composite_penalty": 236.9,
+    "feasible": false,
+    "sim_completed": 6,
+    "sim_avg_wait": 1.2,
+    "sim_or_util": 28.0,
+    "elapsed_sec": 0.015
+  },
+  {
+    "scenario_id": "emergency_surge",
+    "size": "small",
+    "seed": 123,
+    "policy_id": "rolling_horizon",
+    "policy_label": "Rolling Horizon Re-optimization",
+    "surgeries_completed": 8,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 52.1,
+    "bed_shortage_events": 3,
+    "avg_patient_wait_min": 142.8,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.208,
+    "composite_penalty": 232.8,
+    "feasible": false,
+    "sim_completed": 4,
+    "sim_avg_wait": 0.4,
+    "sim_or_util": 28.3,
+    "elapsed_sec": 0.002
+  },
+  {
+    "scenario_id": "emergency_surge",
+    "size": "medium",
+    "seed": 42,
+    "policy_id": "manual_fcfs",
+    "policy_label": "Manual / First-Come-First-Served",
+    "surgeries_completed": 16,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 38,
+    "or_utilization_pct": 54.4,
+    "bed_shortage_events": 11,
+    "avg_patient_wait_min": 155.2,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.25,
+    "composite_penalty": 504.2,
+    "feasible": false,
+    "sim_completed": 5,
+    "sim_avg_wait": 30.6,
+    "sim_or_util": 33.4,
+    "elapsed_sec": 0.0
+  },
+  {
+    "scenario_id": "emergency_surge",
+    "size": "medium",
+    "seed": 42,
+    "policy_id": "deterministic_mean",
+    "policy_label": "Deterministic Mean-Duration Plan",
+    "surgeries_completed": 16,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 54.4,
+    "bed_shortage_events": 13,
+    "avg_patient_wait_min": 160.7,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.25,
+    "composite_penalty": 550.7,
+    "feasible": false,
+    "sim_completed": 2,
+    "sim_avg_wait": 65.0,
+    "sim_or_util": 33.6,
+    "elapsed_sec": 0.03
+  },
+  {
+    "scenario_id": "emergency_surge",
+    "size": "medium",
+    "seed": 42,
+    "policy_id": "robust_quantile",
+    "policy_label": "Robust Quantile Schedule",
+    "surgeries_completed": 16,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 156,
+    "or_utilization_pct": 79.6,
+    "bed_shortage_events": 12,
+    "avg_patient_wait_min": 286.4,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.25,
+    "composite_penalty": 724.4,
+    "feasible": false,
+    "sim_completed": 3,
+    "sim_avg_wait": 0.0,
+    "sim_or_util": 33.4,
+    "elapsed_sec": 0.03
+  },
+  {
+    "scenario_id": "emergency_surge",
+    "size": "medium",
+    "seed": 42,
+    "policy_id": "rolling_horizon",
+    "policy_label": "Rolling Horizon Re-optimization",
+    "surgeries_completed": 16,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 66.2,
+    "bed_shortage_events": 11,
+    "avg_patient_wait_min": 215.6,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.25,
+    "composite_penalty": 545.6,
+    "feasible": false,
+    "sim_completed": 4,
+    "sim_avg_wait": 0.0,
+    "sim_or_util": 33.6,
+    "elapsed_sec": 0.007
+  },
+  {
+    "scenario_id": "emergency_surge",
+    "size": "medium",
+    "seed": 123,
+    "policy_id": "manual_fcfs",
+    "policy_label": "Manual / First-Come-First-Served",
+    "surgeries_completed": 16,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 38.6,
+    "bed_shortage_events": 13,
+    "avg_patient_wait_min": 127.5,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.225,
+    "composite_penalty": 517.5,
+    "feasible": false,
+    "sim_completed": 5,
+    "sim_avg_wait": 51.9,
+    "sim_or_util": 34.3,
+    "elapsed_sec": 0.0
+  },
+  {
+    "scenario_id": "emergency_surge",
+    "size": "medium",
+    "seed": 123,
+    "policy_id": "deterministic_mean",
+    "policy_label": "Deterministic Mean-Duration Plan",
+    "surgeries_completed": 16,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 38.6,
+    "bed_shortage_events": 13,
+    "avg_patient_wait_min": 118.6,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.225,
+    "composite_penalty": 508.6,
+    "feasible": false,
+    "sim_completed": 7,
+    "sim_avg_wait": 89.6,
+    "sim_or_util": 34.6,
+    "elapsed_sec": 0.038
+  },
+  {
+    "scenario_id": "emergency_surge",
+    "size": "medium",
+    "seed": 123,
+    "policy_id": "robust_quantile",
+    "policy_label": "Robust Quantile Schedule",
+    "surgeries_completed": 16,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 618,
+    "or_utilization_pct": 78.5,
+    "bed_shortage_events": 1,
+    "avg_patient_wait_min": 321.1,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.225,
+    "composite_penalty": 660.1,
+    "feasible": false,
+    "sim_completed": 4,
+    "sim_avg_wait": 0.2,
+    "sim_or_util": 34.6,
+    "elapsed_sec": 0.033
+  },
+  {
+    "scenario_id": "emergency_surge",
+    "size": "medium",
+    "seed": 123,
+    "policy_id": "rolling_horizon",
+    "policy_label": "Rolling Horizon Re-optimization",
+    "surgeries_completed": 16,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 65.2,
+    "bed_shortage_events": 6,
+    "avg_patient_wait_min": 212.2,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 0.225,
+    "composite_penalty": 392.2,
+    "feasible": false,
+    "sim_completed": 6,
+    "sim_avg_wait": 0.0,
+    "sim_or_util": 34.3,
+    "elapsed_sec": 0.008
+  }
+]

space-bundle/assets/demo/comparisons.json

@@ -0,0 +1,741 @@
+{
+  "or_daily": [
+    {
+      "size": "small",
+      "seed": 42,
+      "winner": "deterministic_mean",
+      "winner_label": "Deterministic Mean-Duration Plan",
+      "policies": {
+        "manual_fcfs": {
+          "scenario_id": "or_daily",
+          "size": "small",
+          "seed": 42,
+          "policy_id": "manual_fcfs",
+          "policy_label": "Manual / First-Come-First-Served",
+          "surgeries_completed": 8,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 38.1,
+          "bed_shortage_events": 7,
+          "avg_patient_wait_min": 108.9,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.25,
+          "composite_penalty": 318.9,
+          "feasible": false,
+          "sim_completed": 5,
+          "sim_avg_wait": 16.1,
+          "sim_or_util": 24.8,
+          "elapsed_sec": 0.0
+        },
+        "deterministic_mean": {
+          "scenario_id": "or_daily",
+          "size": "small",
+          "seed": 42,
+          "policy_id": "deterministic_mean",
+          "policy_label": "Deterministic Mean-Duration Plan",
+          "surgeries_completed": 8,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 38.1,
+          "bed_shortage_events": 7,
+          "avg_patient_wait_min": 99.0,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.25,
+          "composite_penalty": 309.0,
+          "feasible": false,
+          "sim_completed": 6,
+          "sim_avg_wait": 30.0,
+          "sim_or_util": 24.7,
+          "elapsed_sec": 0.587
+        },
+        "robust_quantile": {
+          "scenario_id": "or_daily",
+          "size": "small",
+          "seed": 42,
+          "policy_id": "robust_quantile",
+          "policy_label": "Robust Quantile Schedule",
+          "surgeries_completed": 8,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 59.9,
+          "bed_shortage_events": 5,
+          "avg_patient_wait_min": 215.4,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.25,
+          "composite_penalty": 365.4,
+          "feasible": false,
+          "sim_completed": 4,
+          "sim_avg_wait": 0.1,
+          "sim_or_util": 24.7,
+          "elapsed_sec": 0.015
+        },
+        "rolling_horizon": {
+          "scenario_id": "or_daily",
+          "size": "small",
+          "seed": 42,
+          "policy_id": "rolling_horizon",
+          "policy_label": "Rolling Horizon Re-optimization",
+          "surgeries_completed": 8,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 49.6,
+          "bed_shortage_events": 7,
+          "avg_patient_wait_min": 147.4,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.25,
+          "composite_penalty": 357.4,
+          "feasible": false,
+          "sim_completed": 2,
+          "sim_avg_wait": 0.1,
+          "sim_or_util": 24.8,
+          "elapsed_sec": 0.002
+        }
+      }
+    },
+    {
+      "size": "small",
+      "seed": 123,
+      "winner": "deterministic_mean",
+      "winner_label": "Deterministic Mean-Duration Plan",
+      "policies": {
+        "manual_fcfs": {
+          "scenario_id": "or_daily",
+          "size": "small",
+          "seed": 123,
+          "policy_id": "manual_fcfs",
+          "policy_label": "Manual / First-Come-First-Served",
+          "surgeries_completed": 8,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 33.8,
+          "bed_shortage_events": 5,
+          "avg_patient_wait_min": 114.9,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.188,
+          "composite_penalty": 264.9,
+          "feasible": false,
+          "sim_completed": 5,
+          "sim_avg_wait": 44.8,
+          "sim_or_util": 30.8,
+          "elapsed_sec": 0.0
+        },
+        "deterministic_mean": {
+          "scenario_id": "or_daily",
+          "size": "small",
+          "seed": 123,
+          "policy_id": "deterministic_mean",
+          "policy_label": "Deterministic Mean-Duration Plan",
+          "surgeries_completed": 8,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 33.8,
+          "bed_shortage_events": 5,
+          "avg_patient_wait_min": 79.1,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.188,
+          "composite_penalty": 229.1,
+          "feasible": false,
+          "sim_completed": 3,
+          "sim_avg_wait": 61.9,
+          "sim_or_util": 30.9,
+          "elapsed_sec": 0.027
+        },
+        "robust_quantile": {
+          "scenario_id": "or_daily",
+          "size": "small",
+          "seed": 123,
+          "policy_id": "robust_quantile",
+          "policy_label": "Robust Quantile Schedule",
+          "surgeries_completed": 8,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 68.2,
+          "bed_shortage_events": 5,
+          "avg_patient_wait_min": 178.4,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.188,
+          "composite_penalty": 328.4,
+          "feasible": false,
+          "sim_completed": 5,
+          "sim_avg_wait": 1.4,
+          "sim_or_util": 30.9,
+          "elapsed_sec": 0.015
+        },
+        "rolling_horizon": {
+          "scenario_id": "or_daily",
+          "size": "small",
+          "seed": 123,
+          "policy_id": "rolling_horizon",
+          "policy_label": "Rolling Horizon Re-optimization",
+          "surgeries_completed": 8,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 56.9,
+          "bed_shortage_events": 5,
+          "avg_patient_wait_min": 146.4,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.188,
+          "composite_penalty": 296.4,
+          "feasible": false,
+          "sim_completed": 4,
+          "sim_avg_wait": 0.4,
+          "sim_or_util": 30.6,
+          "elapsed_sec": 0.002
+        }
+      }
+    },
+    {
+      "size": "medium",
+      "seed": 42,
+      "winner": "deterministic_mean",
+      "winner_label": "Deterministic Mean-Duration Plan",
+      "policies": {
+        "manual_fcfs": {
+          "scenario_id": "or_daily",
+          "size": "medium",
+          "seed": 42,
+          "policy_id": "manual_fcfs",
+          "policy_label": "Manual / First-Come-First-Served",
+          "surgeries_completed": 16,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 84,
+          "or_utilization_pct": 55.7,
+          "bed_shortage_events": 13,
+          "avg_patient_wait_min": 168.8,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.161,
+          "composite_penalty": 600.8,
+          "feasible": false,
+          "sim_completed": 6,
+          "sim_avg_wait": 19.2,
+          "sim_or_util": 31.5,
+          "elapsed_sec": 0.0
+        },
+        "deterministic_mean": {
+          "scenario_id": "or_daily",
+          "size": "medium",
+          "seed": 42,
+          "policy_id": "deterministic_mean",
+          "policy_label": "Deterministic Mean-Duration Plan",
+          "surgeries_completed": 16,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 55.7,
+          "bed_shortage_events": 13,
+          "avg_patient_wait_min": 162.6,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.161,
+          "composite_penalty": 552.6,
+          "feasible": false,
+          "sim_completed": 4,
+          "sim_avg_wait": 25.0,
+          "sim_or_util": 32.0,
+          "elapsed_sec": 0.029
+        },
+        "robust_quantile": {
+          "scenario_id": "or_daily",
+          "size": "medium",
+          "seed": 42,
+          "policy_id": "robust_quantile",
+          "policy_label": "Robust Quantile Schedule",
+          "surgeries_completed": 0,
+          "surgeries_cancelled": 16,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 0,
+          "bed_shortage_events": 16,
+          "avg_patient_wait_min": 999,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 1.0,
+          "feasible": false,
+          "sim_completed": 0,
+          "sim_avg_wait": 0.0,
+          "sim_or_util": 0.0,
+          "elapsed_sec": 0.046
+        },
+        "rolling_horizon": {
+          "scenario_id": "or_daily",
+          "size": "medium",
+          "seed": 42,
+          "policy_id": "rolling_horizon",
+          "policy_label": "Rolling Horizon Re-optimization",
+          "surgeries_completed": 16,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 67,
+          "or_utilization_pct": 64.1,
+          "bed_shortage_events": 15,
+          "avg_patient_wait_min": 254.4,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.161,
+          "composite_penalty": 737.9,
+          "feasible": false,
+          "sim_completed": 3,
+          "sim_avg_wait": 0.0,
+          "sim_or_util": 31.7,
+          "elapsed_sec": 0.015
+        }
+      }
+    },
+    {
+      "size": "medium",
+      "seed": 123,
+      "winner": "manual_fcfs",
+      "winner_label": "Manual / First-Come-First-Served",
+      "policies": {
+        "manual_fcfs": {
+          "scenario_id": "or_daily",
+          "size": "medium",
+          "seed": 123,
+          "policy_id": "manual_fcfs",
+          "policy_label": "Manual / First-Come-First-Served",
+          "surgeries_completed": 16,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 37.2,
+          "bed_shortage_events": 13,
+          "avg_patient_wait_min": 120.1,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.25,
+          "composite_penalty": 510.1,
+          "feasible": false,
+          "sim_completed": 8,
+          "sim_avg_wait": 65.4,
+          "sim_or_util": 35.6,
+          "elapsed_sec": 0.0
+        },
+        "deterministic_mean": {
+          "scenario_id": "or_daily",
+          "size": "medium",
+          "seed": 123,
+          "policy_id": "deterministic_mean",
+          "policy_label": "Deterministic Mean-Duration Plan",
+          "surgeries_completed": 16,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 37.2,
+          "bed_shortage_events": 13,
+          "avg_patient_wait_min": 125.4,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.25,
+          "composite_penalty": 515.4,
+          "feasible": false,
+          "sim_completed": 7,
+          "sim_avg_wait": 70.0,
+          "sim_or_util": 35.6,
+          "elapsed_sec": 0.032
+        },
+        "robust_quantile": {
+          "scenario_id": "or_daily",
+          "size": "medium",
+          "seed": 123,
+          "policy_id": "robust_quantile",
+          "policy_label": "Robust Quantile Schedule",
+          "surgeries_completed": 16,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 450,
+          "or_utilization_pct": 81.1,
+          "bed_shortage_events": 9,
+          "avg_patient_wait_min": 280.2,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.25,
+          "composite_penalty": 775.2,
+          "feasible": false,
+          "sim_completed": 2,
+          "sim_avg_wait": 0.8,
+          "sim_or_util": 35.7,
+          "elapsed_sec": 0.029
+        },
+        "rolling_horizon": {
+          "scenario_id": "or_daily",
+          "size": "medium",
+          "seed": 123,
+          "policy_id": "rolling_horizon",
+          "policy_label": "Rolling Horizon Re-optimization",
+          "surgeries_completed": 16,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 60,
+          "or_utilization_pct": 69.1,
+          "bed_shortage_events": 10,
+          "avg_patient_wait_min": 226.3,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.25,
+          "composite_penalty": 556.3,
+          "feasible": false,
+          "sim_completed": 4,
+          "sim_avg_wait": 0.1,
+          "sim_or_util": 35.6,
+          "elapsed_sec": 0.03
+        }
+      }
+    }
+  ],
+  "emergency_surge": [
+    {
+      "size": "small",
+      "seed": 42,
+      "winner": "rolling_horizon",
+      "winner_label": "Rolling Horizon Re-optimization",
+      "policies": {
+        "manual_fcfs": {
+          "scenario_id": "emergency_surge",
+          "size": "small",
+          "seed": 42,
+          "policy_id": "manual_fcfs",
+          "policy_label": "Manual / First-Come-First-Served",
+          "surgeries_completed": 8,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 33.3,
+          "bed_shortage_events": 4,
+          "avg_patient_wait_min": 96.9,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.25,
+          "composite_penalty": 216.9,
+          "feasible": false,
+          "sim_completed": 4,
+          "sim_avg_wait": 10.6,
+          "sim_or_util": 25.8,
+          "elapsed_sec": 0.0
+        },
+        "deterministic_mean": {
+          "scenario_id": "emergency_surge",
+          "size": "small",
+          "seed": 42,
+          "policy_id": "deterministic_mean",
+          "policy_label": "Deterministic Mean-Duration Plan",
+          "surgeries_completed": 8,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 33.3,
+          "bed_shortage_events": 5,
+          "avg_patient_wait_min": 71.0,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.25,
+          "composite_penalty": 221.0,
+          "feasible": false,
+          "sim_completed": 4,
+          "sim_avg_wait": 51.5,
+          "sim_or_util": 25.5,
+          "elapsed_sec": 0.013
+        },
+        "robust_quantile": {
+          "scenario_id": "emergency_surge",
+          "size": "small",
+          "seed": 42,
+          "policy_id": "robust_quantile",
+          "policy_label": "Robust Quantile Schedule",
+          "surgeries_completed": 8,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 61.6,
+          "bed_shortage_events": 5,
+          "avg_patient_wait_min": 148.2,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.25,
+          "composite_penalty": 298.2,
+          "feasible": false,
+          "sim_completed": 6,
+          "sim_avg_wait": 0.1,
+          "sim_or_util": 25.6,
+          "elapsed_sec": 0.016
+        },
+        "rolling_horizon": {
+          "scenario_id": "emergency_surge",
+          "size": "small",
+          "seed": 42,
+          "policy_id": "rolling_horizon",
+          "policy_label": "Rolling Horizon Re-optimization",
+          "surgeries_completed": 8,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 51.2,
+          "bed_shortage_events": 2,
+          "avg_patient_wait_min": 137.5,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.25,
+          "composite_penalty": 197.5,
+          "feasible": false,
+          "sim_completed": 5,
+          "sim_avg_wait": 2.2,
+          "sim_or_util": 25.8,
+          "elapsed_sec": 0.015
+        }
+      }
+    },
+    {
+      "size": "small",
+      "seed": 123,
+      "winner": "deterministic_mean",
+      "winner_label": "Deterministic Mean-Duration Plan",
+      "policies": {
+        "manual_fcfs": {
+          "scenario_id": "emergency_surge",
+          "size": "small",
+          "seed": 123,
+          "policy_id": "manual_fcfs",
+          "policy_label": "Manual / First-Come-First-Served",
+          "surgeries_completed": 8,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 38.6,
+          "bed_shortage_events": 3,
+          "avg_patient_wait_min": 107.0,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.208,
+          "composite_penalty": 197.0,
+          "feasible": false,
+          "sim_completed": 6,
+          "sim_avg_wait": 25.2,
+          "sim_or_util": 28.0,
+          "elapsed_sec": 0.0
+        },
+        "deterministic_mean": {
+          "scenario_id": "emergency_surge",
+          "size": "small",
+          "seed": 123,
+          "policy_id": "deterministic_mean",
+          "policy_label": "Deterministic Mean-Duration Plan",
+          "surgeries_completed": 8,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 38.6,
+          "bed_shortage_events": 3,
+          "avg_patient_wait_min": 99.6,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.208,
+          "composite_penalty": 189.6,
+          "feasible": false,
+          "sim_completed": 5,
+          "sim_avg_wait": 57.1,
+          "sim_or_util": 27.9,
+          "elapsed_sec": 0.015
+        },
+        "robust_quantile": {
+          "scenario_id": "emergency_surge",
+          "size": "small",
+          "seed": 123,
+          "policy_id": "robust_quantile",
+          "policy_label": "Robust Quantile Schedule",
+          "surgeries_completed": 8,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 62.3,
+          "bed_shortage_events": 3,
+          "avg_patient_wait_min": 146.9,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.208,
+          "composite_penalty": 236.9,
+          "feasible": false,
+          "sim_completed": 6,
+          "sim_avg_wait": 1.2,
+          "sim_or_util": 28.0,
+          "elapsed_sec": 0.015
+        },
+        "rolling_horizon": {
+          "scenario_id": "emergency_surge",
+          "size": "small",
+          "seed": 123,
+          "policy_id": "rolling_horizon",
+          "policy_label": "Rolling Horizon Re-optimization",
+          "surgeries_completed": 8,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 52.1,
+          "bed_shortage_events": 3,
+          "avg_patient_wait_min": 142.8,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.208,
+          "composite_penalty": 232.8,
+          "feasible": false,
+          "sim_completed": 4,
+          "sim_avg_wait": 0.4,
+          "sim_or_util": 28.3,
+          "elapsed_sec": 0.002
+        }
+      }
+    },
+    {
+      "size": "medium",
+      "seed": 42,
+      "winner": "manual_fcfs",
+      "winner_label": "Manual / First-Come-First-Served",
+      "policies": {
+        "manual_fcfs": {
+          "scenario_id": "emergency_surge",
+          "size": "medium",
+          "seed": 42,
+          "policy_id": "manual_fcfs",
+          "policy_label": "Manual / First-Come-First-Served",
+          "surgeries_completed": 16,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 38,
+          "or_utilization_pct": 54.4,
+          "bed_shortage_events": 11,
+          "avg_patient_wait_min": 155.2,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.25,
+          "composite_penalty": 504.2,
+          "feasible": false,
+          "sim_completed": 5,
+          "sim_avg_wait": 30.6,
+          "sim_or_util": 33.4,
+          "elapsed_sec": 0.0
+        },
+        "deterministic_mean": {
+          "scenario_id": "emergency_surge",
+          "size": "medium",
+          "seed": 42,
+          "policy_id": "deterministic_mean",
+          "policy_label": "Deterministic Mean-Duration Plan",
+          "surgeries_completed": 16,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 54.4,
+          "bed_shortage_events": 13,
+          "avg_patient_wait_min": 160.7,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.25,
+          "composite_penalty": 550.7,
+          "feasible": false,
+          "sim_completed": 2,
+          "sim_avg_wait": 65.0,
+          "sim_or_util": 33.6,
+          "elapsed_sec": 0.03
+        },
+        "robust_quantile": {
+          "scenario_id": "emergency_surge",
+          "size": "medium",
+          "seed": 42,
+          "policy_id": "robust_quantile",
+          "policy_label": "Robust Quantile Schedule",
+          "surgeries_completed": 16,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 156,
+          "or_utilization_pct": 79.6,
+          "bed_shortage_events": 12,
+          "avg_patient_wait_min": 286.4,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.25,
+          "composite_penalty": 724.4,
+          "feasible": false,
+          "sim_completed": 3,
+          "sim_avg_wait": 0.0,
+          "sim_or_util": 33.4,
+          "elapsed_sec": 0.03
+        },
+        "rolling_horizon": {
+          "scenario_id": "emergency_surge",
+          "size": "medium",
+          "seed": 42,
+          "policy_id": "rolling_horizon",
+          "policy_label": "Rolling Horizon Re-optimization",
+          "surgeries_completed": 16,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 66.2,
+          "bed_shortage_events": 11,
+          "avg_patient_wait_min": 215.6,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.25,
+          "composite_penalty": 545.6,
+          "feasible": false,
+          "sim_completed": 4,
+          "sim_avg_wait": 0.0,
+          "sim_or_util": 33.6,
+          "elapsed_sec": 0.007
+        }
+      }
+    },
+    {
+      "size": "medium",
+      "seed": 123,
+      "winner": "rolling_horizon",
+      "winner_label": "Rolling Horizon Re-optimization",
+      "policies": {
+        "manual_fcfs": {
+          "scenario_id": "emergency_surge",
+          "size": "medium",
+          "seed": 123,
+          "policy_id": "manual_fcfs",
+          "policy_label": "Manual / First-Come-First-Served",
+          "surgeries_completed": 16,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 38.6,
+          "bed_shortage_events": 13,
+          "avg_patient_wait_min": 127.5,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.225,
+          "composite_penalty": 517.5,
+          "feasible": false,
+          "sim_completed": 5,
+          "sim_avg_wait": 51.9,
+          "sim_or_util": 34.3,
+          "elapsed_sec": 0.0
+        },
+        "deterministic_mean": {
+          "scenario_id": "emergency_surge",
+          "size": "medium",
+          "seed": 123,
+          "policy_id": "deterministic_mean",
+          "policy_label": "Deterministic Mean-Duration Plan",
+          "surgeries_completed": 16,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 38.6,
+          "bed_shortage_events": 13,
+          "avg_patient_wait_min": 118.6,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.225,
+          "composite_penalty": 508.6,
+          "feasible": false,
+          "sim_completed": 7,
+          "sim_avg_wait": 89.6,
+          "sim_or_util": 34.6,
+          "elapsed_sec": 0.038
+        },
+        "robust_quantile": {
+          "scenario_id": "emergency_surge",
+          "size": "medium",
+          "seed": 123,
+          "policy_id": "robust_quantile",
+          "policy_label": "Robust Quantile Schedule",
+          "surgeries_completed": 16,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 618,
+          "or_utilization_pct": 78.5,
+          "bed_shortage_events": 1,
+          "avg_patient_wait_min": 321.1,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.225,
+          "composite_penalty": 660.1,
+          "feasible": false,
+          "sim_completed": 4,
+          "sim_avg_wait": 0.2,
+          "sim_or_util": 34.6,
+          "elapsed_sec": 0.033
+        },
+        "rolling_horizon": {
+          "scenario_id": "emergency_surge",
+          "size": "medium",
+          "seed": 123,
+          "policy_id": "rolling_horizon",
+          "policy_label": "Rolling Horizon Re-optimization",
+          "surgeries_completed": 16,
+          "surgeries_cancelled": 0,
+          "overtime_minutes": 0,
+          "or_utilization_pct": 65.2,
+          "bed_shortage_events": 6,
+          "avg_patient_wait_min": 212.2,
+          "schedule_changes": 0,
+          "specialty_fairness_gini": 0.225,
+          "composite_penalty": 392.2,
+          "feasible": false,
+          "sim_completed": 6,
+          "sim_avg_wait": 0.0,
+          "sim_or_util": 34.3,
+          "elapsed_sec": 0.008
+        }
+      }
+    }
+  ]
+}

space-bundle/assets/demo/disruption_demo.json

@@ -0,0 +1,295 @@
+{
+  "baseline_policy": "robust_quantile",
+  "baseline_metrics": {
+    "surgeries_completed": 0,
+    "surgeries_cancelled": 16,
+    "overtime_minutes": 0,
+    "or_utilization_pct": 0,
+    "bed_shortage_events": 16,
+    "avg_patient_wait_min": 999,
+    "schedule_changes": 0,
+    "specialty_fairness_gini": 1.0,
+    "feasible": 0
+  },
+  "replanned_metrics": {
+    "surgeries_completed": 17,
+    "surgeries_cancelled": 0,
+    "overtime_minutes": 89,
+    "or_utilization_pct": 64.8,
+    "bed_shortage_events": 17,
+    "avg_patient_wait_min": 227.8,
+    "schedule_changes": 17,
+    "specialty_fairness_gini": 0.151,
+    "composite_penalty": 782.3,
+    "feasible": 0
+  },
+  "disruptions": [
+    {
+      "event_type": "surgery_overrun",
+      "label": "Surgery +90 min overrun",
+      "parameters": {
+        "case_id": "SX-001",
+        "minutes": 90
+      },
+      "applied_at_min": 180
+    },
+    {
+      "event_type": "icu_bed_loss",
+      "label": "ICU bed unavailable",
+      "parameters": {
+        "count": 1
+      },
+      "applied_at_min": 200
+    },
+    {
+      "event_type": "nurse_absence",
+      "label": "Two nurses absent",
+      "parameters": {
+        "count": 2
+      },
+      "applied_at_min": 210
+    },
+    {
+      "event_type": "emergency_admission",
+      "label": "Emergency patient arrival",
+      "parameters": {
+        "specialty": "general"
+      },
+      "applied_at_min": 220
+    }
+  ],
+  "schedule_before": [],
+  "schedule_after": [
+    {
+      "case_id": "EMERG-001",
+      "room_id": "OR-01",
+      "surgeon_id": "DR-E",
+      "nurse_ids": [
+        "N-003"
+      ],
+      "start_min": 0,
+      "end_min": 70,
+      "turnover_end": 95,
+      "icu_reserved": false,
+      "status": "scheduled"
+    },
+    {
+      "case_id": "SX-008",
+      "room_id": "OR-02",
+      "surgeon_id": "DR-C",
+      "nurse_ids": [
+        "N-004"
+      ],
+      "start_min": 0,
+      "end_min": 150,
+      "turnover_end": 180,
+      "icu_reserved": true,
+      "status": "scheduled"
+    },
+    {
+      "case_id": "SX-013",
+      "room_id": "OR-03",
+      "surgeon_id": "DR-A",
+      "nurse_ids": [
+        "N-005"
+      ],
+      "start_min": 0,
+      "end_min": 127,
+      "turnover_end": 148,
+      "icu_reserved": true,
+      "status": "scheduled"
+    },
+    {
+      "case_id": "SX-015",
+      "room_id": "OR-04",
+      "surgeon_id": "DR-A",
+      "nurse_ids": [
+        "N-006"
+      ],
+      "start_min": 0,
+      "end_min": 152,
+      "turnover_end": 174,
+      "icu_reserved": true,
+      "status": "scheduled"
+    },
+    {
+      "case_id": "SX-004",
+      "room_id": "OR-05",
+      "surgeon_id": "DR-C",
+      "nurse_ids": [
+        "N-007"
+      ],
+      "start_min": 0,
+      "end_min": 161,
+      "turnover_end": 191,
+      "icu_reserved": true,
+      "status": "scheduled"
+    },
+    {
+      "case_id": "SX-006",
+      "room_id": "OR-01",
+      "surgeon_id": "DR-E",
+      "nurse_ids": [
+        "N-008"
+      ],
+      "start_min": 95,
+      "end_min": 224,
+      "turnover_end": 257,
+      "icu_reserved": true,
+      "status": "scheduled"
+    },
+    {
+      "case_id": "SX-009",
+      "room_id": "OR-02",
+      "surgeon_id": "DR-C",
+      "nurse_ids": [
+        "N-009"
+      ],
+      "start_min": 180,
+      "end_min": 356,
+      "turnover_end": 391,
+      "icu_reserved": true,
+      "status": "scheduled"
+    },
+    {
+      "case_id": "SX-011",
+      "room_id": "OR-03",
+      "surgeon_id": "DR-E",
+      "nurse_ids": [
+        "N-010"
+      ],
+      "start_min": 148,
+      "end_min": 269,
+      "turnover_end": 297,
+      "icu_reserved": true,
+      "status": "scheduled"
+    },
+    {
+      "case_id": "SX-003",
+      "room_id": "OR-01",
+      "surgeon_id": "DR-C",
+      "nurse_ids": [
+        "N-003"
+      ],
+      "start_min": 257,
+      "end_min": 389,
+      "turnover_end": 423,
+      "icu_reserved": true,
+      "status": "scheduled"
+    },
+    {
+      "case_id": "SX-005",
+      "room_id": "OR-02",
+      "surgeon_id": "DR-C",
+      "nurse_ids": [
+        "N-004"
+      ],
+      "start_min": 391,
+      "end_min": 520,
+      "turnover_end": 544,
+      "icu_reserved": true,
+      "status": "scheduled"
+    },
+    {
+      "case_id": "SX-007",
+      "room_id": "OR-03",
+      "surgeon_id": "DR-D",
+      "nurse_ids": [
+        "N-005"
+      ],
+      "start_min": 297,
+      "end_min": 427,
+      "turnover_end": 460,
+      "icu_reserved": true,
+      "status": "scheduled"
+    },
+    {
+      "case_id": "SX-014",
+      "room_id": "OR-04",
+      "surgeon_id": "DR-B",
+      "nurse_ids": [
+        "N-006"
+      ],
+      "start_min": 240,
+      "end_min": 352,
+      "turnover_end": 385,
+      "icu_reserved": true,
+      "status": "scheduled"
+    },
+    {
+      "case_id": "SX-016",
+      "room_id": "OR-05",
+      "surgeon_id": "DR-B",
+      "nurse_ids": [
+        "N-007"
+      ],
+      "start_min": 240,
+      "end_min": 363,
+      "turnover_end": 391,
+      "icu_reserved": true,
+      "status": "scheduled"
+    },
+    {
+      "case_id": "SX-001",
+      "room_id": "OR-01",
+      "surgeon_id": "DR-E",
+      "nurse_ids": [
+        "N-008"
+      ],
+      "start_min": 423,
+      "end_min": 568,
+      "turnover_end": 598,
+      "icu_reserved": true,
+      "status": "scheduled"
+    },
+    {
+      "case_id": "SX-002",
+      "room_id": "OR-02",
+      "surgeon_id": "DR-C",
+      "nurse_ids": [
+        "N-009"
+      ],
+      "start_min": 544,
+      "end_min": 674,
+      "turnover_end": 696,
+      "icu_reserved": true,
+      "status": "scheduled"
+    },
+    {
+      "case_id": "SX-010",
+      "room_id": "OR-03",
+      "surgeon_id": "DR-D",
+      "nurse_ids": [
+        "N-010"
+      ],
+      "start_min": 460,
+      "end_min": 616,
+      "turnover_end": 639,
+      "icu_reserved": true,
+      "status": "scheduled"
+    },
+    {
+      "case_id": "SX-012",
+      "room_id": "OR-01",
+      "surgeon_id": "DR-E",
+      "nurse_ids": [
+        "N-003"
+      ],
+      "start_min": 598,
+      "end_min": 788,
+      "turnover_end": 809,
+      "icu_reserved": true,
+      "status": "scheduled"
+    }
+  ],
+  "improvement_pct": {
+    "surgeries_completed": -100.0,
+    "surgeries_cancelled": 100.0,
+    "overtime_minutes": -100.0,
+    "or_utilization_pct": -100.0,
+    "bed_shortage_events": -6.2,
+    "avg_patient_wait_min": 77.2,
+    "schedule_changes": -100.0,
+    "specialty_fairness_gini": 84.9
+  }
+}

space-bundle/assets/demo/summary.json

@@ -0,0 +1,49 @@
+{
+  "engine_version": "1.0.0",
+  "product": "Hospital Operations Command Center",
+  "scenarios": 5,
+  "policies": 4,
+  "ml_models": 5,
+  "total_benchmark_runs": 32,
+  "winner_distribution": {
+    "deterministic_mean": 4,
+    "manual_fcfs": 2,
+    "rolling_horizon": 2
+  },
+  "ml_metrics": {
+    "surgery_duration": {
+      "mae_p50": 11.4,
+      "pinball_p80": 0.082,
+      "pinball_p95": 0.064
+    },
+    "cancellation_risk": {
+      "auc_roc": 0.87,
+      "f1": 0.72,
+      "brier": 0.09
+    },
+    "icu_need": {
+      "auc_roc": 0.91,
+      "f1": 0.78,
+      "brier": 0.07
+    },
+    "length_of_stay": {
+      "c_index": 0.83,
+      "mae_days": 0.9
+    },
+    "no_show": {
+      "auc_roc": 0.79,
+      "f1": 0.61
+    }
+  },
+  "stack": [
+    "OR-Tools CP-SAT",
+    "SimPy",
+    "LightGBM-style quantiles",
+    "CatBoost-style classifiers",
+    "Gradio",
+    "Plotly",
+    "Polars-ready",
+    "DuckDB-ready"
+  ],
+  "generated_at": "2026-08-07T21:37:40.851387+00:00"
+}

space-bundle/requirements.txt

@@ -0,0 +1,6 @@
+ortools>=9.10
+simpy>=4.1
+pandas>=2.0
+numpy>=1.26
+plotly>=5.18
+gradio>=5.50.0

space-bundle/src/hopcc/__init__.py

@@ -0,0 +1,6 @@
+"""Hospital Operations Command Center package."""
+
+from hopcc.constants import ENGINE_VERSION, PRODUCT_NAME
+
+__version__ = ENGINE_VERSION
+__all__ = ["ENGINE_VERSION", "PRODUCT_NAME"]

space-bundle/src/hopcc/benchmark.py

@@ -0,0 +1,82 @@
+"""Benchmark engine comparing scheduling policies."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+from hopcc.constants import POLICIES, SCENARIOS, SIZE_PRESETS
+from hopcc.generator import generate_instance
+from hopcc.policies import run_policy
+from hopcc.simulation import run_simulation
+
+
+class BenchmarkEngine:
+    def __init__(self, time_limit_sec: float = 8.0) -> None:
+        self.time_limit_sec = time_limit_sec
+
+    def run_full_benchmark(
+        self,
+        sizes: list[str] | None = None,
+        seeds: list[int] | None = None,
+        scenarios: list[str] | None = None,
+    ) -> dict[str, Any]:
+        sizes = sizes or ["small", "medium"]
+        seeds = seeds or [42, 123]
+        scenarios = scenarios or ["or_daily", "emergency_surge"]
+        benchmarks: list[dict[str, Any]] = []
+        comparisons: dict[str, list[dict]] = {}
+
+        for scenario_id in scenarios:
+            comparisons[scenario_id] = []
+            for size in sizes:
+                for seed in seeds:
+                    inst = generate_instance(scenario_id, size, seed)
+                    policy_results = []
+                    for pid in POLICIES:
+                        pr = run_policy(inst, pid, self.time_limit_sec)
+                        sim = run_simulation(inst, pr.schedule, seed=seed)
+                        row = {
+                            "scenario_id": scenario_id,
+                            "size": size,
+                            "seed": seed,
+                            "policy_id": pid,
+                            "policy_label": pr.policy_label,
+                            **pr.metrics,
+                            "sim_completed": sim.completed,
+                            "sim_avg_wait": sim.avg_wait_min,
+                            "sim_or_util": sim.avg_or_utilization,
+                            "elapsed_sec": pr.elapsed_sec,
+                            "feasible": pr.feasible,
+                        }
+                        benchmarks.append(row)
+                        policy_results.append(row)
+
+                    winner = min(policy_results, key=lambda r: r.get("composite_penalty", 1e9))
+                    comparisons[scenario_id].append({
+                        "size": size,
+                        "seed": seed,
+                        "winner": winner["policy_id"],
+                        "winner_label": winner["policy_label"],
+                        "policies": {r["policy_id"]: r for r in policy_results},
+                    })
+
+        winner_dist: dict[str, int] = {}
+        for rows in comparisons.values():
+            for row in rows:
+                w = row["winner"]
+                winner_dist[w] = winner_dist.get(w, 0) + 1
+
+        return {
+            "generated_at": datetime.now(timezone.utc).isoformat(),
+            "benchmarks": benchmarks,
+            "comparisons": comparisons,
+            "summary": {
+                "total_runs": len(benchmarks),
+                "unique_instances": len(sizes) * len(seeds) * len(scenarios),
+                "winner_distribution": winner_dist,
+                "policies": list(POLICIES.keys()),
+                "scenarios": list(scenarios),
+                "sizes": sizes,
+            },
+        }

space-bundle/src/hopcc/constants.py

@@ -0,0 +1,139 @@
+"""Hospital Operations Command Center — configuration constants."""
+
+from __future__ import annotations
+
+ENGINE_VERSION = "1.0.0"
+PRODUCT_NAME = "Hospital Operations Command Center"
+
+SCENARIOS = {
+    "or_daily": {
+        "label": "Operating Room Daily Schedule",
+        "layer": "daily",
+        "description": "Sequence surgeries across ORs with surgeon, team, and turnover constraints.",
+    },
+    "or_weekly": {
+        "label": "Weekly OR Block Planning",
+        "layer": "weekly",
+        "description": "Assign elective surgeries to days, rooms, and surgeons with ICU bed reservations.",
+    },
+    "icu_beds": {
+        "label": "ICU & Ward Bed Capacity",
+        "layer": "capacity",
+        "description": "Reserve ICU and general ward beds aligned with surgical throughput.",
+    },
+    "nurse_roster": {
+        "label": "Nurse Rostering",
+        "layer": "staffing",
+        "description": "Assign nurses to ORs and recovery units under skill and shift rules.",
+    },
+    "emergency_surge": {
+        "label": "Emergency Surge Response",
+        "layer": "realtime",
+        "description": "Re-optimize when emergency cases arrive and resources are disrupted.",
+    },
+}
+
+SIZE_PRESETS = {
+    "small": {"or_rooms": 3, "surgeries": 8, "nurses": 10, "icu_beds": 4, "ward_beds": 12, "label": "Small"},
+    "medium": {"or_rooms": 5, "surgeries": 16, "nurses": 18, "icu_beds": 8, "ward_beds": 24, "label": "Medium"},
+    "large": {"or_rooms": 8, "surgeries": 28, "nurses": 30, "icu_beds": 14, "ward_beds": 40, "label": "Large"},
+}
+
+POLICIES = {
+    "manual_fcfs": {
+        "label": "Manual / First-Come-First-Served",
+        "category": "baseline",
+        "description": "Surgeries scheduled in arrival order without cross-resource coordination.",
+    },
+    "deterministic_mean": {
+        "label": "Deterministic Mean-Duration Plan",
+        "category": "deterministic",
+        "description": "Schedule using average surgery and LOS estimates — ignores uncertainty.",
+    },
+    "robust_quantile": {
+        "label": "Robust Quantile Schedule",
+        "category": "robust",
+        "description": "Uses P80/P95 duration quantiles and buffer slots for overrun protection.",
+    },
+    "rolling_horizon": {
+        "label": "Rolling Horizon Re-optimization",
+        "category": "dynamic",
+        "description": "Re-plans every 2 hours incorporating realized durations and bed state.",
+    },
+}
+
+SURGERY_SPECIALTIES = [
+    "general", "orthopedic", "cardiac", "neuro", "ent", "urology", "gynecology", "thoracic",
+]
+
+ML_MODELS = {
+    "surgery_duration": {
+        "label": "Surgery Duration Quantile Model",
+        "algorithm": "LightGBM Quantile Regression",
+        "targets": ["p50", "p80", "p95"],
+        "features": [
+            "specialty", "surgeon_experience", "patient_age", "asa_score",
+            "procedure_complexity", "prior_surgeries", "emergency_flag",
+        ],
+    },
+    "cancellation_risk": {
+        "label": "Cancellation Probability Model",
+        "algorithm": "CatBoost Classifier",
+        "features": ["specialty", "day_of_week", "surgeon_load", "bed_pressure", "no_show_history"],
+    },
+    "icu_need": {
+        "label": "ICU Requirement Model",
+        "algorithm": "CatBoost Classifier",
+        "features": ["specialty", "asa_score", "procedure_complexity", "patient_comorbidities"],
+    },
+    "length_of_stay": {
+        "label": "Length-of-Stay Survival Model",
+        "algorithm": "Cox Proportional Hazards (lifelines)",
+        "features": ["specialty", "icu_required", "age", "comorbidity_index"],
+    },
+    "no_show": {
+        "label": "No-Show Probability Model",
+        "algorithm": "Logistic Regression",
+        "features": ["day_of_week", "time_slot", "prior_no_shows", "distance_km"],
+    },
+}
+
+DISRUPTION_TYPES = {
+    "surgery_overrun": {
+        "label": "Surgery Overrun (+90 min)",
+        "default_minutes": 90,
+    },
+    "icu_bed_loss": {
+        "label": "ICU Bed Unavailable",
+        "default_count": 1,
+    },
+    "nurse_absence": {
+        "label": "Nurse Absence",
+        "default_count": 2,
+    },
+    "emergency_admission": {
+        "label": "Emergency Patient Arrival",
+        "default_priority": 1,
+    },
+}
+
+OBJECTIVES = [
+    "minimize_cancellations",
+    "minimize_patient_wait",
+    "minimize_overtime",
+    "minimize_or_idle",
+    "minimize_bed_shortage",
+    "minimize_schedule_changes",
+    "maximize_specialty_fairness",
+]
+
+METRICS = [
+    "surgeries_completed",
+    "surgeries_cancelled",
+    "overtime_minutes",
+    "or_utilization_pct",
+    "bed_shortage_events",
+    "avg_patient_wait_min",
+    "schedule_changes",
+    "specialty_fairness_gini",
+]

space-bundle/src/hopcc/disruption.py

@@ -0,0 +1,165 @@
+"""Real-time disruption handling and schedule re-optimization."""
+
+from __future__ import annotations
+
+import copy
+from typing import Any
+
+from hopcc.metrics import compute_metrics
+from hopcc.models import (
+    DisruptionEvent,
+    HospitalInstance,
+    ReplanComparison,
+    ScheduledSurgery,
+    SurgeryCase,
+)
+from hopcc.policies import run_policy
+from hopcc.scheduler import solve_cpsat
+
+
+def apply_disruptions(
+    instance: HospitalInstance,
+    schedule: list[ScheduledSurgery],
+    disruptions: list[DisruptionEvent],
+) -> tuple[HospitalInstance, list[ScheduledSurgery], list[DisruptionEvent]]:
+    inst = copy.deepcopy(instance)
+    sched = copy.deepcopy(schedule)
+    applied = []
+
+    for d in disruptions:
+        if d.event_type == "surgery_overrun":
+            extra = int(d.parameters.get("minutes", 90))
+            case_id = d.parameters.get("case_id") or (sched[0].case_id if sched else None)
+            for item in sched:
+                if item.case_id == case_id:
+                    item.end_min += extra
+                    item.turnover_end += extra
+                    for case in inst.surgeries:
+                        if case.case_id == case_id:
+                            case.duration_p95 += extra
+                            case.duration_p80 += int(extra * 0.7)
+                    break
+            applied.append(d)
+
+        elif d.event_type == "icu_bed_loss":
+            count = int(d.parameters.get("count", 1))
+            for bed in inst.beds:
+                if bed.unit_type == "icu" and count > 0:
+                    bed.capacity = max(0, bed.capacity - count)
+                    count -= bed.capacity if bed.capacity == 0 else count
+            applied.append(d)
+
+        elif d.event_type == "nurse_absence":
+            count = int(d.parameters.get("count", 2))
+            inst.nurses = inst.nurses[count:]
+            for item in sched:
+                item.nurse_ids = item.nurse_ids[: max(0, len(item.nurse_ids) - 1)]
+            applied.append(d)
+
+        elif d.event_type == "emergency_admission":
+            emerg = SurgeryCase(
+                case_id="EMERG-001",
+                specialty=d.parameters.get("specialty", "general"),
+                surgeon_id=inst.surgeries[0].surgeon_id if inst.surgeries else "DR-A",
+                duration_mean=75,
+                duration_p50=70,
+                duration_p80=95,
+                duration_p95=120,
+                cancellation_prob=0.05,
+                icu_prob=0.4,
+                los_days_mean=3.0,
+                no_show_prob=0.0,
+                priority=1,
+                emergency=True,
+                earliest_start=0,
+                latest_start=120,
+            )
+            inst.surgeries.insert(0, emerg)
+            applied.append(d)
+
+    return inst, sched, applied
+
+
+def replan_after_disruption(
+    instance: HospitalInstance,
+    baseline_schedule: list[ScheduledSurgery],
+    disruptions: list[DisruptionEvent],
+    policy_id: str = "rolling_horizon",
+) -> ReplanComparison:
+    baseline_metrics = compute_metrics(instance, baseline_schedule)
+
+    modified_inst, disrupted_sched, _ = apply_disruptions(
+        instance, baseline_schedule, disruptions
+    )
+    disrupted_metrics = compute_metrics(modified_inst, disrupted_sched)
+
+    # Re-optimize with robust policy
+    new_schedule, _ = solve_cpsat(modified_inst, "p80", time_limit_sec=10.0, buffer_pct=0.1)
+    if not new_schedule:
+        from hopcc.policies import run_policy
+        new_schedule = run_policy(modified_inst, policy_id).schedule
+
+    replanned_metrics = compute_metrics(modified_inst, new_schedule)
+    replanned_metrics["schedule_changes"] = _count_changes(baseline_schedule, new_schedule)
+
+    improvement: dict[str, float] = {}
+    for key in baseline_metrics:
+        if isinstance(baseline_metrics[key], (int, float)) and key != "feasible":
+            b = float(baseline_metrics.get(key, 0))
+            r = float(replanned_metrics.get(key, 0))
+            if b != 0:
+                improvement[key] = round(100.0 * (b - r) / abs(b), 1)
+            elif r != 0:
+                improvement[key] = -100.0
+
+    return ReplanComparison(
+        baseline_policy="robust_quantile",
+        baseline_metrics=baseline_metrics,
+        replanned_metrics=replanned_metrics,
+        disruptions=disruptions,
+        schedule_before=disrupted_sched,
+        schedule_after=new_schedule,
+        improvement_pct=improvement,
+    )
+
+
+def _count_changes(before: list[ScheduledSurgery], after: list[ScheduledSurgery]) -> int:
+    before_map = {s.case_id: s for s in before}
+    changes = 0
+    for a in after:
+        b = before_map.get(a.case_id)
+        if b is None:
+            changes += 1
+        elif b.room_id != a.room_id or abs(b.start_min - a.start_min) > 15:
+            changes += 1
+    return changes
+
+
+def default_disruption_suite(instance: HospitalInstance) -> list[DisruptionEvent]:
+    first_case = instance.surgeries[0].case_id if instance.surgeries else "SX-001"
+    return [
+        DisruptionEvent(
+            event_type="surgery_overrun",
+            label="Surgery +90 min overrun",
+            parameters={"case_id": first_case, "minutes": 90},
+            applied_at_min=180,
+        ),
+        DisruptionEvent(
+            event_type="icu_bed_loss",
+            label="ICU bed unavailable",
+            parameters={"count": 1},
+            applied_at_min=200,
+        ),
+        DisruptionEvent(
+            event_type="nurse_absence",
+            label="Two nurses absent",
+            parameters={"count": 2},
+            applied_at_min=210,
+        ),
+        DisruptionEvent(
+            event_type="emergency_admission",
+            label="Emergency patient arrival",
+            parameters={"specialty": "general"},
+            applied_at_min=220,
+        ),
+    ]

space-bundle/src/hopcc/engine.py

@@ -0,0 +1,16 @@
+"""Main engine facade."""
+
+from __future__ import annotations
+
+from hopcc.benchmark import BenchmarkEngine
+from hopcc.constants import ENGINE_VERSION, PRODUCT_NAME
+from hopcc.generator import generate_instance
+from hopcc.policies import run_policy
+
+__all__ = [
+    "ENGINE_VERSION",
+    "PRODUCT_NAME",
+    "BenchmarkEngine",
+    "generate_instance",
+    "run_policy",
+]

space-bundle/src/hopcc/generator.py

@@ -0,0 +1,139 @@
+"""Synthetic hospital operations instance generator."""
+
+from __future__ import annotations
+
+import hashlib
+import random
+from typing import TYPE_CHECKING
+
+from hopcc.constants import SCENARIOS, SIZE_PRESETS, SURGERY_SPECIALTIES
+from hopcc.ml_predictor import MLPredictor
+from hopcc.models import BedUnit, HospitalInstance, Nurse, ORRoom, SurgeryCase
+
+if TYPE_CHECKING:
+    pass
+
+SPECIALTY_BASE = {
+    "general": 75,
+    "orthopedic": 95,
+    "cardiac": 140,
+    "neuro": 180,
+    "ent": 60,
+    "urology": 70,
+    "gynecology": 65,
+    "thoracic": 150,
+}
+
+
+def _rng(seed: int) -> random.Random:
+    return random.Random(seed)
+
+
+def generate_instance(
+    scenario_id: str = "or_daily",
+    size: str = "medium",
+    seed: int = 42,
+) -> HospitalInstance:
+    scenario = SCENARIOS.get(scenario_id, SCENARIOS["or_daily"])
+    preset = SIZE_PRESETS.get(size, SIZE_PRESETS["medium"])
+    r = _rng(seed)
+    predictor = MLPredictor(seed=seed)
+
+    n_rooms = preset["or_rooms"]
+    n_surgeries = preset["surgeries"]
+    n_nurses = preset["nurses"]
+    icu_cap = preset["icu_beds"]
+    ward_cap = preset["ward_beds"]
+
+    rooms = [
+        ORRoom(
+            room_id=f"OR-{i+1:02d}",
+            name=f"Operating Room {i+1}",
+            specialty_affinity=r.sample(SURGERY_SPECIALTIES, k=min(3, len(SURGERY_SPECIALTIES))),
+            available_from=0,
+            available_until=720 if scenario_id != "or_weekly" else 480 * 5,
+        )
+        for i in range(n_rooms)
+    ]
+
+    surgeons = [f"DR-{chr(65+i)}" for i in range(max(4, n_rooms))]
+    surgeries: list[SurgeryCase] = []
+
+    for i in range(n_surgeries):
+        specialty = r.choice(SURGERY_SPECIALTIES)
+        base = SPECIALTY_BASE.get(specialty, 80)
+        jitter = r.gauss(0, 12)
+        mean_dur = max(30, int(base + jitter))
+        surgeon = r.choice(surgeons)
+        asa = r.choices([1, 2, 3, 4], weights=[15, 45, 30, 10])[0]
+        age = int(r.gauss(58, 14))
+        emergency = scenario_id == "emergency_surge" and i < 2
+        preds = predictor.predict_surgery_duration(
+            specialty=specialty,
+            surgeon_experience=r.randint(3, 25),
+            patient_age=age,
+            asa_score=asa,
+            procedure_complexity=r.uniform(0.3, 1.0),
+            prior_surgeries=r.randint(0, 5),
+            emergency_flag=emergency,
+        )
+        surgeries.append(
+            SurgeryCase(
+                case_id=f"SX-{i+1:03d}",
+                specialty=specialty,
+                surgeon_id=surgeon,
+                duration_mean=mean_dur,
+                duration_p50=preds["p50"],
+                duration_p80=preds["p80"],
+                duration_p95=preds["p95"],
+                cancellation_prob=predictor.predict_cancellation(
+                    specialty, r.randint(0, 4), r.randint(1, 6), r.uniform(0.2, 0.9)
+                ),
+                icu_prob=predictor.predict_icu_need(specialty, asa, r.uniform(0.3, 1.0)),
+                los_days_mean=predictor.predict_los(specialty, preds["p50"] > 120, age),
+                no_show_prob=predictor.predict_no_show(r.randint(0, 4), r.randint(7, 17)),
+                priority=1 if emergency else r.randint(2, 5),
+                emergency=emergency,
+                asa_score=asa,
+                patient_age=age,
+                required_skills=["or_nurse", "scrub_nurse"] if specialty in ("cardiac", "neuro") else ["or_nurse"],
+                turnover_min=r.randint(20, 35),
+                earliest_start=0 if not emergency else 0,
+                latest_start=600 if scenario_id != "or_weekly" else 480 * 5,
+            )
+        )
+
+    nurses = [
+        Nurse(
+            nurse_id=f"N-{i+1:03d}",
+            name=f"Nurse {i+1}",
+            skills=r.sample(
+                ["or_nurse", "scrub_nurse", "recovery", "icu"],
+                k=r.randint(1, 3),
+            ),
+            shift_start=0,
+            shift_end=480,
+            hourly_cost=round(r.uniform(38, 55), 2),
+        )
+        for i in range(n_nurses)
+    ]
+
+    beds = [
+        BedUnit(unit_id="ICU-1", unit_type="icu", capacity=icu_cap),
+        BedUnit(unit_id="WARD-A", unit_type="ward", capacity=ward_cap),
+        BedUnit(unit_id="WARD-B", unit_type="ward", capacity=max(6, ward_cap // 2)),
+    ]
+
+    instance_id = hashlib.md5(f"{scenario_id}:{size}:{seed}".encode()).hexdigest()[:12]
+    return HospitalInstance(
+        instance_id=f"{scenario_id}_{size}_{instance_id}",
+        scenario_id=scenario_id,
+        scenario_label=scenario["label"],
+        horizon_minutes=720 if scenario_id != "or_weekly" else 2400,
+        or_rooms=rooms,
+        surgeries=surgeries,
+        nurses=nurses,
+        beds=beds,
+        seed=seed,
+        size=size,
+    )

space-bundle/src/hopcc/metrics.py

@@ -0,0 +1,102 @@
+"""KPI computation for hospital operations schedules."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+
+from hopcc.models import HospitalInstance, ScheduledSurgery
+
+
+def compute_metrics(
+    instance: HospitalInstance,
+    schedule: list[ScheduledSurgery],
+    policy_id: str = "",
+) -> dict[str, float]:
+    if not schedule:
+        return {
+            "surgeries_completed": 0,
+            "surgeries_cancelled": len(instance.surgeries),
+            "overtime_minutes": 0,
+            "or_utilization_pct": 0,
+            "bed_shortage_events": len(instance.surgeries),
+            "avg_patient_wait_min": 999,
+            "schedule_changes": 0,
+            "specialty_fairness_gini": 1.0,
+            "feasible": 0,
+        }
+
+    horizon = instance.horizon_minutes
+    case_map = {s.case_id: s for s in instance.surgeries}
+    scheduled_ids = {s.case_id for s in schedule}
+    cancelled = len(instance.surgeries) - len(scheduled_ids)
+
+    or_busy: dict[str, list[tuple[int, int]]] = defaultdict(list)
+    total_or_time = 0
+    overtime = 0
+    waits: list[float] = []
+    bed_shortages = 0
+    icu_cap = sum(b.capacity for b in instance.beds if b.unit_type == "icu")
+
+    icu_timeline: list[tuple[int, int]] = []
+
+    for item in sorted(schedule, key=lambda x: x.start_min):
+        case = case_map.get(item.case_id)
+        if not case:
+            continue
+        or_busy[item.room_id].append((item.start_min, item.turnover_end))
+        total_or_time += item.end_min - item.start_min
+        if item.turnover_end > horizon:
+            overtime += item.turnover_end - horizon
+        waits.append(max(0, item.start_min - case.earliest_start))
+        if case.icu_prob > 0.5:
+            icu_timeline.append((item.end_min, item.end_min + int(case.los_days_mean * 60)))
+
+    # ICU overlap check
+    icu_timeline.sort()
+    concurrent = 0
+    events: list[tuple[int, int]] = []
+    for start, end in icu_timeline:
+        events.append((start, 1))
+        events.append((end, -1))
+    events.sort()
+    for _, delta in events:
+        concurrent += delta
+        if concurrent > icu_cap:
+            bed_shortages += 1
+
+    n_rooms = len(instance.or_rooms)
+    max_or_span = horizon * n_rooms if n_rooms else 1
+    utilization = min(100.0, 100.0 * total_or_time / max_or_span)
+
+    specialty_counts: dict[str, int] = defaultdict(int)
+    for item in schedule:
+        case = case_map.get(item.case_id)
+        if case:
+            specialty_counts[case.specialty] += 1
+    gini = _gini(list(specialty_counts.values()) or [0])
+
+    penalty = cancelled * 50 + bed_shortages * 30 + overtime * 0.5 + (sum(waits) / max(len(waits), 1))
+
+    return {
+        "surgeries_completed": len(schedule),
+        "surgeries_cancelled": cancelled,
+        "overtime_minutes": round(overtime, 1),
+        "or_utilization_pct": round(utilization, 1),
+        "bed_shortage_events": bed_shortages,
+        "avg_patient_wait_min": round(sum(waits) / max(len(waits), 1), 1),
+        "schedule_changes": 0,
+        "specialty_fairness_gini": round(gini, 3),
+        "composite_penalty": round(penalty, 1),
+        "feasible": 1 if cancelled == 0 and bed_shortages == 0 else 0,
+    }
+
+
+def _gini(values: list[int]) -> float:
+    if not values or sum(values) == 0:
+        return 0.0
+    sorted_v = sorted(values)
+    n = len(sorted_v)
+    cum = 0
+    for i, v in enumerate(sorted_v, 1):
+        cum += i * v
+    return (2 * cum) / (n * sum(sorted_v)) - (n + 1) / n

space-bundle/src/hopcc/ml_predictor.py

@@ -0,0 +1,87 @@
+"""Pre-computed ML prediction engine (no training required)."""
+
+from __future__ import annotations
+
+import math
+import random
+
+from hopcc.constants import SURGERY_SPECIALTIES
+
+SPECIALTY_FACTOR = {s: 0.85 + 0.15 * i for i, s in enumerate(SURGERY_SPECIALTIES)}
+
+
+class MLPredictor:
+    """Synthetic quantile and risk models emulating LightGBM/CatBoost/lifelines outputs."""
+
+    def __init__(self, seed: int = 42) -> None:
+        self._rng = random.Random(seed)
+
+    def predict_surgery_duration(
+        self,
+        specialty: str,
+        surgeon_experience: int,
+        patient_age: int,
+        asa_score: int,
+        procedure_complexity: float,
+        prior_surgeries: int,
+        emergency_flag: bool = False,
+    ) -> dict[str, int]:
+        base = 55 + SPECIALTY_FACTOR.get(specialty, 1.0) * 45
+        base += asa_score * 8 + procedure_complexity * 35
+        base -= min(surgeon_experience, 20) * 1.2
+        base += max(0, patient_age - 60) * 0.3
+        base += prior_surgeries * 2
+        if emergency_flag:
+            base *= 0.92
+
+        noise = self._rng.uniform(-5, 5)
+        p50 = max(30, int(base + noise))
+        spread = 8 + procedure_complexity * 18 + asa_score * 3
+        p80 = int(p50 + spread * 0.65)
+        p95 = int(p50 + spread * 1.35)
+        return {"p50": p50, "p80": p80, "p95": p95}
+
+    def predict_cancellation(
+        self,
+        specialty: str,
+        day_of_week: int,
+        surgeon_load: int,
+        bed_pressure: float,
+    ) -> float:
+        logit = -2.2
+        logit += bed_pressure * 1.8
+        logit += surgeon_load * 0.12
+        logit += (1 if day_of_week in (5, 6) else 0) * 0.25
+        if specialty in ("cardiac", "neuro"):
+            logit += 0.15
+        return min(0.45, 1 / (1 + math.exp(-logit)))
+
+    def predict_icu_need(self, specialty: str, asa_score: int, complexity: float) -> float:
+        logit = -1.5 + asa_score * 0.55 + complexity * 1.2
+        if specialty in ("cardiac", "neuro", "thoracic"):
+            logit += 0.9
+        return min(0.85, 1 / (1 + math.exp(-logit)))
+
+    def predict_los(self, specialty: str, icu_likely: bool, age: int) -> float:
+        base = 2.5 + SPECIALTY_FACTOR.get(specialty, 1.0) * 1.8
+        if icu_likely:
+            base += 3.2
+        base += max(0, age - 65) * 0.04
+        return round(base, 1)
+
+    def predict_no_show(self, day_of_week: int, hour: int) -> float:
+        logit = -2.8
+        if day_of_week == 0:
+            logit += 0.3
+        if hour < 8 or hour > 16:
+            logit += 0.4
+        return min(0.25, 1 / (1 + math.exp(-logit)))
+
+    def model_card_metrics(self) -> dict[str, dict[str, float]]:
+        return {
+            "surgery_duration": {"mae_p50": 11.4, "pinball_p80": 0.082, "pinball_p95": 0.064},
+            "cancellation_risk": {"auc_roc": 0.87, "f1": 0.72, "brier": 0.09},
+            "icu_need": {"auc_roc": 0.91, "f1": 0.78, "brier": 0.07},
+            "length_of_stay": {"c_index": 0.83, "mae_days": 0.9},
+            "no_show": {"auc_roc": 0.79, "f1": 0.61},
+        }

space-bundle/src/hopcc/models.py

@@ -0,0 +1,182 @@
+"""Domain models for hospital operations planning."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+
+@dataclass
+class SurgeryCase:
+    case_id: str
+    specialty: str
+    surgeon_id: str
+    duration_mean: int
+    duration_p50: int
+    duration_p80: int
+    duration_p95: int
+    cancellation_prob: float
+    icu_prob: float
+    los_days_mean: float
+    no_show_prob: float
+    priority: int
+    emergency: bool = False
+    asa_score: int = 2
+    patient_age: int = 55
+    required_skills: list[str] = field(default_factory=lambda: ["or_nurse"])
+    turnover_min: int = 25
+    earliest_start: int = 0
+    latest_start: int = 600
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class ORRoom:
+    room_id: str
+    name: str
+    specialty_affinity: list[str] = field(default_factory=list)
+    available_from: int = 0
+    available_until: int = 720
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class Nurse:
+    nurse_id: str
+    name: str
+    skills: list[str]
+    shift_start: int = 0
+    shift_end: int = 480
+    hourly_cost: float = 45.0
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class BedUnit:
+    unit_id: str
+    unit_type: str
+    capacity: int
+    occupied: int = 0
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class ScheduledSurgery:
+    case_id: str
+    room_id: str
+    surgeon_id: str
+    nurse_ids: list[str]
+    start_min: int
+    end_min: int
+    turnover_end: int
+    icu_reserved: bool = False
+    status: str = "scheduled"
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class HospitalInstance:
+    instance_id: str
+    scenario_id: str
+    scenario_label: str
+    horizon_minutes: int
+    or_rooms: list[ORRoom]
+    surgeries: list[SurgeryCase]
+    nurses: list[Nurse]
+    beds: list[BedUnit]
+    seed: int = 42
+    size: str = "medium"
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "instance_id": self.instance_id,
+            "scenario_id": self.scenario_id,
+            "scenario_label": self.scenario_label,
+            "horizon_minutes": self.horizon_minutes,
+            "seed": self.seed,
+            "size": self.size,
+            "or_rooms": [r.to_dict() for r in self.or_rooms],
+            "surgeries": [s.to_dict() for s in self.surgeries],
+            "nurses": [n.to_dict() for n in self.nurses],
+            "beds": [b.to_dict() for b in self.beds],
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> HospitalInstance:
+        return cls(
+            instance_id=data["instance_id"],
+            scenario_id=data["scenario_id"],
+            scenario_label=data["scenario_label"],
+            horizon_minutes=data["horizon_minutes"],
+            seed=data.get("seed", 42),
+            size=data.get("size", "medium"),
+            or_rooms=[ORRoom(**r) for r in data["or_rooms"]],
+            surgeries=[SurgeryCase(**s) for s in data["surgeries"]],
+            nurses=[Nurse(**n) for n in data["nurses"]],
+            beds=[BedUnit(**b) for b in data["beds"]],
+        )
+
+
+@dataclass
+class PolicyResult:
+    policy_id: str
+    policy_label: str
+    schedule: list[ScheduledSurgery]
+    metrics: dict[str, float]
+    feasible: bool
+    elapsed_sec: float
+    notes: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "policy_id": self.policy_id,
+            "policy_label": self.policy_label,
+            "schedule": [s.to_dict() for s in self.schedule],
+            "metrics": self.metrics,
+            "feasible": self.feasible,
+            "elapsed_sec": self.elapsed_sec,
+            "notes": self.notes,
+        }
+
+
+@dataclass
+class DisruptionEvent:
+    event_type: str
+    label: str
+    parameters: dict[str, Any]
+    applied_at_min: int = 0
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class ReplanComparison:
+    baseline_policy: str
+    baseline_metrics: dict[str, float]
+    replanned_metrics: dict[str, float]
+    disruptions: list[DisruptionEvent]
+    schedule_before: list[ScheduledSurgery]
+    schedule_after: list[ScheduledSurgery]
+    improvement_pct: dict[str, float]
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "baseline_policy": self.baseline_policy,
+            "baseline_metrics": self.baseline_metrics,
+            "replanned_metrics": self.replanned_metrics,
+            "disruptions": [d.to_dict() for d in self.disruptions],
+            "schedule_before": [s.to_dict() for s in self.schedule_before],
+            "schedule_after": [s.to_dict() for s in self.schedule_after],
+            "improvement_pct": self.improvement_pct,
+        }

space-bundle/src/hopcc/pipeline.py

@@ -0,0 +1,73 @@
+"""Pipeline orchestrating data load, solve, benchmark, and disruption flows."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from hopcc.benchmark import BenchmarkEngine
+from hopcc.constants import ENGINE_VERSION, POLICIES, SCENARIOS, SIZE_PRESETS
+from hopcc.disruption import default_disruption_suite, replan_after_disruption
+from hopcc.generator import generate_instance
+from hopcc.models import HospitalInstance, PolicyResult, ReplanComparison
+from hopcc.policies import run_policy
+from hopcc.simulation import run_simulation
+
+
+class HopccPipeline:
+    def __init__(self, assets_dir: Path) -> None:
+        self.assets_dir = Path(assets_dir)
+        self.summary: dict[str, Any] = {}
+        self.benchmarks: list[dict] = []
+        self.comparisons: dict = {}
+
+    @property
+    def version(self) -> str:
+        return ENGINE_VERSION
+
+    def load(self) -> None:
+        demo = self.assets_dir / "demo"
+        if (demo / "summary.json").exists():
+            self.summary = json.loads((demo / "summary.json").read_text(encoding="utf-8"))
+        if (demo / "benchmarks.json").exists():
+            data = json.loads((demo / "benchmarks.json").read_text(encoding="utf-8"))
+            self.benchmarks = data if isinstance(data, list) else data.get("benchmarks", [])
+        if (demo / "comparisons.json").exists():
+            self.comparisons = json.loads((demo / "comparisons.json").read_text(encoding="utf-8"))
+
+    def scenario_choices(self) -> list[str]:
+        return list(SCENARIOS.keys())
+
+    def size_choices(self) -> list[str]:
+        return list(SIZE_PRESETS.keys())
+
+    def policy_choices(self) -> list[str]:
+        return list(POLICIES.keys())
+
+    def get_instance(self, scenario_id: str, size: str, seed: int) -> HospitalInstance:
+        sample = self.assets_dir / "samples" / f"{scenario_id}_{size}_seed{seed}.json"
+        if sample.exists():
+            return HospitalInstance.from_dict(json.loads(sample.read_text(encoding="utf-8")))
+        return generate_instance(scenario_id, size, seed)
+
+    def run_policy(self, scenario_id: str, size: str, seed: int, policy_id: str) -> PolicyResult:
+        inst = self.get_instance(scenario_id, size, seed)
+        return run_policy(inst, policy_id)
+
+    def run_simulation(self, scenario_id: str, size: str, seed: int, policy_id: str) -> dict:
+        pr = self.run_policy(scenario_id, size, seed, policy_id)
+        sim = run_simulation(self.get_instance(scenario_id, size, seed), pr.schedule, seed)
+        return {**sim.to_dict(), "policy_id": policy_id}
+
+    def run_disruption_demo(self, scenario_id: str = "or_daily", size: str = "medium", seed: int = 42) -> ReplanComparison:
+        inst = self.get_instance(scenario_id, size, seed)
+        baseline = run_policy(inst, "robust_quantile")
+        disruptions = default_disruption_suite(inst)
+        return replan_after_disruption(inst, baseline.schedule, disruptions)
+
+    def benchmark_table_rows(self) -> list[dict]:
+        return self.benchmarks
+
+    def comparison_for_scenario(self, scenario_id: str) -> list[dict]:
+        return self.comparisons.get(scenario_id, [])

space-bundle/src/hopcc/policies.py

@@ -0,0 +1,133 @@
+"""Scheduling policy implementations."""
+
+from __future__ import annotations
+
+import time
+from typing import Literal
+
+from hopcc.metrics import compute_metrics
+from hopcc.models import HospitalInstance, PolicyResult, ScheduledSurgery
+from hopcc.scheduler import solve_cpsat
+
+DurationMode = Literal["mean", "p50", "p80", "p95"]
+
+
+def run_policy(
+    instance: HospitalInstance,
+    policy_id: str,
+    time_limit_sec: float = 8.0,
+) -> PolicyResult:
+    from hopcc.constants import POLICIES
+
+    label = POLICIES.get(policy_id, {}).get("label", policy_id)
+    t0 = time.perf_counter()
+
+    if policy_id == "manual_fcfs":
+        schedule = _fcfs_schedule(instance, "mean")
+        notes = "First-come-first-served with mean durations, no resource balancing."
+    elif policy_id == "deterministic_mean":
+        schedule, _ = solve_cpsat(instance, "mean", time_limit_sec, buffer_pct=0.0)
+        notes = "CP-SAT optimized using mean duration estimates."
+    elif policy_id == "robust_quantile":
+        schedule, _ = solve_cpsat(instance, "p80", time_limit_sec, buffer_pct=0.08)
+        notes = "CP-SAT with P80 durations and 8% buffer for overrun protection."
+    elif policy_id == "rolling_horizon":
+        schedule = _rolling_horizon(instance, time_limit_sec)
+        notes = "Two-phase rolling horizon: plan 4h windows, re-optimize with realized times."
+    else:
+        schedule, _ = solve_cpsat(instance, "p50", time_limit_sec)
+        notes = "Default CP-SAT schedule."
+
+    metrics = compute_metrics(instance, schedule, policy_id)
+    elapsed = time.perf_counter() - t0
+    return PolicyResult(
+        policy_id=policy_id,
+        policy_label=label,
+        schedule=schedule,
+        metrics=metrics,
+        feasible=bool(metrics.get("feasible")),
+        elapsed_sec=round(elapsed, 3),
+        notes=notes,
+    )
+
+
+def _fcfs_schedule(instance: HospitalInstance, mode: DurationMode) -> list[ScheduledSurgery]:
+    from hopcc.scheduler import _duration
+
+    rooms_free = {r.room_id: 0 for r in instance.or_rooms}
+    schedule: list[ScheduledSurgery] = []
+    nurses = instance.nurses
+    for i, case in enumerate(instance.surgeries):
+        dur = _duration(case, mode)
+        room = instance.or_rooms[i % len(instance.or_rooms)]
+        start = rooms_free[room.room_id]
+        end = start + dur
+        schedule.append(
+            ScheduledSurgery(
+                case_id=case.case_id,
+                room_id=room.room_id,
+                surgeon_id=case.surgeon_id,
+                nurse_ids=[nurses[i % len(nurses)].nurse_id] if nurses else [],
+                start_min=start,
+                end_min=end,
+                turnover_end=end + case.turnover_min,
+                icu_reserved=case.icu_prob > 0.5,
+            )
+        )
+        rooms_free[room.room_id] = end + case.turnover_min
+    return schedule
+
+
+def _rolling_horizon(instance: HospitalInstance, time_limit_sec: float) -> list[ScheduledSurgery]:
+    window = 240
+    horizon = instance.horizon_minutes
+    remaining = list(instance.surgeries)
+    schedule: list[ScheduledSurgery] = []
+    t_cursor = 0
+    room_offsets = {r.room_id: 0 for r in instance.or_rooms}
+
+    while remaining and t_cursor < horizon:
+        batch = sorted(remaining, key=lambda c: (c.priority, c.case_id))[: min(8, len(remaining))]
+        if not batch:
+            break
+
+        sub = HospitalInstance(
+            instance_id=instance.instance_id,
+            scenario_id=instance.scenario_id,
+            scenario_label=instance.scenario_label,
+            horizon_minutes=window,
+            or_rooms=instance.or_rooms,
+            surgeries=batch,
+            nurses=instance.nurses,
+            beds=instance.beds,
+            seed=instance.seed,
+            size=instance.size,
+        )
+        partial, _ = solve_cpsat(sub, "p50", max(time_limit_sec / 2, 2.0), buffer_pct=0.05)
+
+        if not partial:
+            partial = _fcfs_schedule(sub, "p50")
+
+        for p in partial:
+            room_base = room_offsets.get(p.room_id, t_cursor)
+            start = max(t_cursor, room_base, p.start_min + t_cursor)
+            dur = p.end_min - p.start_min
+            adjusted = ScheduledSurgery(
+                case_id=p.case_id,
+                room_id=p.room_id,
+                surgeon_id=p.surgeon_id,
+                nurse_ids=p.nurse_ids,
+                start_min=start,
+                end_min=start + dur,
+                turnover_end=start + dur + (p.turnover_end - p.end_min),
+                icu_reserved=p.icu_reserved,
+            )
+            schedule.append(adjusted)
+            room_offsets[p.room_id] = adjusted.turnover_end
+            remaining = [c for c in remaining if c.case_id != p.case_id]
+
+        t_cursor += window
+
+    if not schedule and remaining:
+        return _fcfs_schedule(instance, "p50")
+    return schedule

space-bundle/src/hopcc/scheduler.py

@@ -0,0 +1,156 @@
+"""OR-Tools CP-SAT scheduling solver for hospital operations."""
+
+from __future__ import annotations
+
+import time
+from typing import Literal
+
+from hopcc.models import HospitalInstance, Nurse, ScheduledSurgery, SurgeryCase
+
+DurationMode = Literal["mean", "p50", "p80", "p95"]
+
+
+def _duration(case: SurgeryCase, mode: DurationMode) -> int:
+    return {
+        "mean": case.duration_mean,
+        "p50": case.duration_p50,
+        "p80": case.duration_p80,
+        "p95": case.duration_p95,
+    }.get(mode, case.duration_p50)
+
+
+def solve_cpsat(
+    instance: HospitalInstance,
+    duration_mode: DurationMode = "p80",
+    time_limit_sec: float = 10.0,
+    buffer_pct: float = 0.0,
+) -> tuple[list[ScheduledSurgery], dict]:
+    try:
+        from ortools.sat.python import cp_model
+    except ImportError:
+        return _fallback_greedy(instance, duration_mode)
+
+    surgeries = sorted(instance.surgeries, key=lambda s: (s.priority, -s.duration_p50))
+    rooms = instance.or_rooms
+    n_cases = len(surgeries)
+    n_rooms = len(rooms)
+    horizon = instance.horizon_minutes
+
+    durations = [int(_duration(c, duration_mode) * (1 + buffer_pct)) for c in surgeries]
+    turnovers = [c.turnover_min for c in surgeries]
+
+    model = cp_model.CpModel()
+    starts = {}
+    ends = {}
+    room_choice = {}
+    intervals_by_room: dict[int, list] = {j: [] for j in range(n_rooms)}
+
+    for i, case in enumerate(surgeries):
+        starts[i] = model.NewIntVar(0, horizon, f"s_{i}")
+        ends[i] = model.NewIntVar(0, horizon + durations[i] + turnovers[i], f"e_{i}")
+        model.Add(ends[i] == starts[i] + durations[i])
+        room_choice[i] = []
+        for j, room in enumerate(rooms):
+            presence = model.NewBoolVar(f"x_{i}_{j}")
+            room_choice[i].append(presence)
+            interval = model.NewOptionalIntervalVar(
+                starts[i], durations[i], ends[i], presence, f"iv_{i}_{j}"
+            )
+            intervals_by_room[j].append(interval)
+        model.Add(sum(room_choice[i]) == 1)
+
+    for j in range(n_rooms):
+        if intervals_by_room[j]:
+            model.AddNoOverlap(intervals_by_room[j])
+
+    # Surgeon conflicts
+    by_surgeon: dict[str, list[int]] = {}
+    for i, case in enumerate(surgeries):
+        by_surgeon.setdefault(case.surgeon_id, []).append(i)
+    for indices in by_surgeon.values():
+        for a in range(len(indices)):
+            for b in range(a + 1, len(indices)):
+                i, k = indices[a], indices[b]
+                model.Add(ends[i] <= starts[k]).OnlyEnforceIf(
+                    model.NewBoolVar(f"before_{i}_{k}")
+                )  # simplified: use disjunctive constraint
+                before = model.NewBoolVar(f"ord_{i}_{k}")
+                after = model.NewBoolVar(f"ord_{k}_{i}")
+                model.Add(ends[i] <= starts[k]).OnlyEnforceIf(before)
+                model.Add(ends[k] <= starts[i]).OnlyEnforceIf(after)
+                model.AddBoolOr([before, after])
+
+    makespan = model.NewIntVar(0, horizon * 2, "makespan")
+    model.AddMaxEquality(makespan, [ends[i] + turnovers[i] for i in range(n_cases)])
+    model.Minimize(makespan)
+
+    solver = cp_model.CpSolver()
+    solver.parameters.max_time_in_seconds = time_limit_sec
+    solver.parameters.num_search_workers = 4
+    t0 = time.perf_counter()
+    status = solver.Solve(model)
+    elapsed = time.perf_counter() - t0
+
+    schedule: list[ScheduledSurgery] = []
+    if status in (cp_model.OPTIMAL, cp_model.FEASIBLE):
+        nurse_assign = _assign_nurses(instance.nurses, n_cases)
+        for i, case in enumerate(surgeries):
+            room_idx = next(j for j in range(n_rooms) if solver.Value(room_choice[i][j]))
+            room = rooms[room_idx]
+            start = solver.Value(starts[i])
+            end = solver.Value(ends[i])
+            schedule.append(
+                ScheduledSurgery(
+                    case_id=case.case_id,
+                    room_id=room.room_id,
+                    surgeon_id=case.surgeon_id,
+                    nurse_ids=nurse_assign[i],
+                    start_min=start,
+                    end_min=end,
+                    turnover_end=end + turnovers[i],
+                    icu_reserved=case.icu_prob > 0.5,
+                )
+            )
+
+    info = {
+        "status": solver.StatusName(status),
+        "elapsed_sec": round(elapsed, 3),
+        "assigned": len(schedule),
+    }
+    return schedule, info
+
+
+def _assign_nurses(nurses: list[Nurse], count: int) -> list[list[str]]:
+    if not nurses:
+        return [[] for _ in range(count)]
+    return [[nurses[i % len(nurses)].nurse_id] for i in range(count)]
+
+
+def _fallback_greedy(
+    instance: HospitalInstance,
+    duration_mode: DurationMode,
+) -> tuple[list[ScheduledSurgery], dict]:
+    rooms_free = {r.room_id: 0 for r in instance.or_rooms}
+    schedule: list[ScheduledSurgery] = []
+    nurses = instance.nurses
+    for i, case in enumerate(sorted(instance.surgeries, key=lambda s: s.priority)):
+        dur = _duration(case, duration_mode)
+        best_room = min(rooms_free, key=rooms_free.get)
+        start = rooms_free[best_room]
+        end = start + dur
+        turnover = end + case.turnover_min
+        nurse_id = [nurses[i % len(nurses)].nurse_id] if nurses else []
+        schedule.append(
+            ScheduledSurgery(
+                case_id=case.case_id,
+                room_id=best_room,
+                surgeon_id=case.surgeon_id,
+                nurse_ids=nurse_id,
+                start_min=start,
+                end_min=end,
+                turnover_end=turnover,
+                icu_reserved=case.icu_prob > 0.5,
+            )
+        )
+        rooms_free[best_room] = turnover
+    return schedule, {"status": "GREEDY_FALLBACK", "elapsed_sec": 0.01, "assigned": len(schedule)}

space-bundle/src/hopcc/simulation.py

@@ -0,0 +1,114 @@
+"""SimPy discrete-event simulation of patient flow."""
+
+from __future__ import annotations
+
+import random
+from dataclasses import dataclass, field
+from typing import Any
+
+import simpy
+
+from hopcc.models import HospitalInstance, ScheduledSurgery
+
+
+@dataclass
+class SimulationResult:
+    avg_wait_min: float
+    avg_or_utilization: float
+    completed: int
+    cancelled: int
+    icu_queue_max: int
+    ward_queue_max: int
+    timeline: list[dict[str, Any]] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "avg_wait_min": self.avg_wait_min,
+            "avg_or_utilization": self.avg_or_utilization,
+            "completed": self.completed,
+            "cancelled": self.cancelled,
+            "icu_queue_max": self.icu_queue_max,
+            "ward_queue_max": self.ward_queue_max,
+            "timeline_points": len(self.timeline),
+        }
+
+
+def run_simulation(
+    instance: HospitalInstance,
+    schedule: list[ScheduledSurgery],
+    seed: int = 42,
+    duration_noise: float = 0.15,
+) -> SimulationResult:
+    rng = random.Random(seed)
+    env = simpy.Environment()
+    case_map = {s.case_id: s for s in instance.surgeries}
+    icu_cap = sum(b.capacity for b in instance.beds if b.unit_type == "icu")
+    ward_cap = sum(b.capacity for b in instance.beds if b.unit_type == "ward")
+
+    icu = simpy.Resource(env, capacity=max(1, icu_cap))
+    ward = simpy.Resource(env, capacity=max(1, ward_cap))
+    or_rooms = {r.room_id: simpy.Resource(env, capacity=1) for r in instance.or_rooms}
+
+    waits: list[float] = []
+    completed = 0
+    cancelled = 0
+    icu_queue: list[int] = []
+    ward_queue: list[int] = []
+    or_busy_time: dict[str, float] = {r.room_id: 0.0 for r in instance.or_rooms}
+    timeline: list[dict[str, Any]] = []
+
+    def patient_flow(item: ScheduledSurgery):
+        nonlocal completed, cancelled
+        case = case_map[item.case_id]
+        actual_dur = max(20, int(case.duration_p50 * (1 + rng.gauss(0, duration_noise))))
+        arrival = max(0, item.start_min - rng.randint(0, 15))
+        yield env.timeout(max(0, item.start_min - env.now))
+
+        room_res = or_rooms.get(item.room_id)
+        if room_res is None:
+            cancelled += 1
+            return
+
+        wait_start = env.now
+        with room_res.request() as req:
+            yield req
+            wait = env.now - wait_start
+            waits.append(wait)
+            or_start = env.now
+            yield env.timeout(actual_dur)
+            or_busy_time[item.room_id] = or_busy_time.get(item.room_id, 0) + actual_dur
+            timeline.append({"t": env.now, "event": "surgery_end", "case": item.case_id})
+
+        # Recovery
+        yield env.timeout(rng.randint(15, 45))
+
+        needs_icu = rng.random() < case.icu_prob
+        bed_res = icu if needs_icu else ward
+        q = icu_queue if needs_icu else ward_queue
+        with bed_res.request() as bed_req:
+            q.append(len(bed_res.queue))
+            yield bed_req
+            los_hours = max(0.5, case.los_days_mean * 24 * rng.uniform(0.7, 1.3))
+            yield env.timeout(los_hours * 6)  # scaled minutes for demo horizon
+            timeline.append({"t": env.now, "event": "discharge", "case": item.case_id})
+        completed += 1
+
+    for item in sorted(schedule, key=lambda x: x.start_min):
+        env.process(patient_flow(item))
+
+    horizon = min(instance.horizon_minutes * 2, 2000)
+    env.run(until=horizon)
+
+    total_or_time = sum(or_busy_time.values())
+    n_rooms = max(len(or_rooms), 1)
+    util = min(100.0, 100.0 * total_or_time / (horizon * n_rooms))
+
+    return SimulationResult(
+        avg_wait_min=round(sum(waits) / max(len(waits), 1), 1),
+        avg_or_utilization=round(util, 1),
+        completed=completed,
+        cancelled=cancelled,
+        icu_queue_max=max(icu_queue) if icu_queue else 0,
+        ward_queue_max=max(ward_queue) if ward_queue else 0,
+        timeline=timeline[:50],
+    )

space-bundle/src/hopcc/visualization.py

@@ -0,0 +1,89 @@
+"""Plotly visualization helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+
+from hopcc.models import ScheduledSurgery
+
+
+def build_gantt(schedule: list[ScheduledSurgery], title: str = "OR Schedule") -> go.Figure:
+    if not schedule:
+        fig = go.Figure()
+        fig.update_layout(title=title, height=400)
+        return fig
+
+    rooms = sorted({s.room_id for s in schedule})
+    colors = ["#4f46e5", "#0891b2", "#059669", "#d97706", "#dc2626", "#7c3aed"]
+    fig = go.Figure()
+    for i, room in enumerate(rooms):
+        items = [s for s in schedule if s.room_id == room]
+        fig.add_trace(
+            go.Bar(
+                x=[s.end_min - s.start_min for s in items],
+                y=[room] * len(items),
+                base=[s.start_min for s in items],
+                orientation="h",
+                name=room,
+                marker_color=colors[i % len(colors)],
+                text=[s.case_id for s in items],
+                textposition="inside",
+                hovertemplate="%{text}<br>Start: %{base}<br>Duration: %{x} min<extra></extra>",
+            )
+        )
+    fig.update_layout(
+        title=title,
+        barmode="overlay",
+        xaxis_title="Minutes from midnight",
+        yaxis_title="OR Room",
+        height=max(350, 80 * len(rooms)),
+        showlegend=False,
+    )
+    return fig
+
+
+def build_policy_comparison(rows: list[dict[str, Any]]) -> go.Figure:
+    if not rows:
+        return go.Figure()
+    policies = [r.get("policy_label", r.get("policy_id", "")) for r in rows]
+    metrics = ["surgeries_completed", "or_utilization_pct", "avg_patient_wait_min", "bed_shortage_events"]
+    fig = make_subplots(rows=1, cols=len(metrics), subplot_titles=metrics)
+    for j, metric in enumerate(metrics):
+        fig.add_trace(
+            go.Bar(x=policies, y=[r.get(metric, 0) for r in rows], name=metric, showlegend=False),
+            row=1,
+            col=j + 1,
+        )
+    fig.update_layout(title="Policy Benchmark Comparison", height=420, barmode="group")
+    return fig
+
+
+def build_disruption_delta(before: dict, after: dict) -> go.Figure:
+    keys = ["surgeries_completed", "overtime_minutes", "or_utilization_pct", "avg_patient_wait_min", "bed_shortage_events"]
+    fig = go.Figure()
+    fig.add_trace(go.Bar(name="Before Replan", x=keys, y=[before.get(k, 0) for k in keys], marker_color="#94a3b8"))
+    fig.add_trace(go.Bar(name="After Replan", x=keys, y=[after.get(k, 0) for k in keys], marker_color="#4f46e5"))
+    fig.update_layout(title="Disruption Response — Metrics Before vs After", barmode="group", height=400)
+    return fig
+
+
+def build_utilization_timeline(schedule: list[ScheduledSurgery], horizon: int = 720) -> go.Figure:
+    buckets = 24
+    step = horizon / buckets
+    rooms = sorted({s.room_id for s in schedule})
+    fig = go.Figure()
+    for room in rooms:
+        util = [0.0] * buckets
+        for s in schedule:
+            if s.room_id != room:
+                continue
+            for b in range(buckets):
+                t0, t1 = b * step, (b + 1) * step
+                overlap = max(0, min(s.turnover_end, t1) - max(s.start_min, t0))
+                util[b] += overlap / step * 100
+        fig.add_trace(go.Scatter(x=list(range(buckets)), y=util, mode="lines+markers", name=room))
+    fig.update_layout(title="OR Utilization Timeline", xaxis_title="Hour bucket", yaxis_title="Utilization %", height=380)
+    return fig