enhancements, added view for scehduled cases as tickets

app.py

@@ -136,6 +136,31 @@ if not eda_ready:
         st.code("uv run court-scheduler eda", language="bash")
 else:
     st.success("System ready - all data processed")
+    # Allow user to override and re-run EDA even if it's already completed
+    st.markdown("\n")
+    if st.button("Re-run EDA Pipeline (override)", use_container_width=False):
+        from eda.load_clean import run_load_and_clean
+        from eda.exploration import run_exploration
+        from eda.parameters import run_parameter_export
+
+        with st.spinner("Re-running EDA pipeline... This may take a few minutes."):
+            try:
+                # Step 1: Load & clean data
+                run_load_and_clean()
+
+                # Step 2: Generate visualizations
+                run_exploration()
+
+                # Step 3: Extract parameters
+                run_parameter_export()
+
+                st.success("EDA pipeline re-run completed")
+                st.rerun()
+
+            except Exception as e:
+                st.error("Pipeline failed while re-running inside the dashboard.")
+                with st.expander("Show error details"):
+                    st.exception(e)
 
 st.markdown("---")
 
@@ -164,8 +189,8 @@ with col2:
     #### 4. Cause Lists & Overrides
     View generated cause lists, make judge overrides, and track modification history.
 
-    #### 5. RL Training
-    Train reinforcement learning models for optimized scheduling policies.
+    #### 5. Scheduled Cases Explorer
+    Browse individual case, view status timelines, and understand scheduling decisions.
 
     #### 6. Analytics & Reports
     Compare simulation runs, analyze performance metrics, and export comprehensive reports.
@@ -210,3 +235,4 @@ with st.expander("Typical Usage Workflow"):
 # Footer
 st.markdown("---")
 st.caption("Court Scheduling System - Code4Change Hackathon - Karnataka High Court")
+st.caption("Developed by Aalekh Roy")

eda/exploration.py

@@ -21,6 +21,7 @@ from datetime import timedelta
 
 import plotly.express as px
 import plotly.graph_objects as go
+import plotly.io as pio
 import polars as pl
 
 from eda.config import (
@@ -31,6 +32,11 @@ from eda.config import (
 )
 
 
+px.defaults.template = "plotly_white"
+px.defaults.color_discrete_sequence = px.colors.qualitative.Set2
+pio.templates.default = "plotly_white"
+
+
 def load_cleaned():
     cases = pl.read_parquet(_get_cases_parquet())
     hearings = pl.read_parquet(_get_hearings_parquet())
@@ -41,10 +47,7 @@ def load_cleaned():
 
 def run_exploration() -> None:
     cases, hearings = load_cleaned()
-    # Keep transformations in Polars; convert only small, final results for plotting
-
-    # --------------------------------------------------
-    # 1. Case Type Distribution (aggregated to reduce plot data size)
+    # 1. Case Type Distribution
     # --------------------------------------------------
     try:
         ct_counts = (
@@ -70,18 +73,26 @@ def run_exploration() -> None:
         print("Case type distribution error:", e)
 
     # --------------------------------------------------
-    # 2. Filing Trends by Year
+    # 2. Filing Trends by Year (single line, no slider)
     # --------------------------------------------------
+
     if "YEAR_FILED" in cases.columns:
-        year_counts = cases.group_by("YEAR_FILED").agg(pl.len().alias("Count"))
-        fig2 = px.bar(
-            year_counts.to_pandas(),
+        year_counts = (
+            cases.group_by("YEAR_FILED")
+            .agg(pl.len().alias("Count"))
+            .sort("YEAR_FILED", descending=False)
+        )
+        df_year = year_counts.to_pandas()
+        fig2 = px.line(
+            df_year,
             x="YEAR_FILED",
             y="Count",
+            markers=True,
             title="Cases Filed by Year",
         )
-        fig2.update_traces(line_color="royalblue")
-        fig2.update_layout(xaxis=dict(rangeslider=dict(visible=True)))
+        fig2.update_layout(xaxis_title="Year", yaxis_title="Cases")
+        # Fix y-axis max to 10k (counts are known to be < 10k)
+        fig2.update_yaxes(range=[0, 10000])
         f2 = "2_cases_filed_by_year.html"
         safe_write_figure(fig2, f2)
 

pages/5_Scheduled_Cases_Explorer.py

@@ -0,0 +1,17 @@
+"""Wrapper to expose the cause lists & overrides page to Streamlit's pages system."""
+
+from __future__ import annotations
+
+from pathlib import Path
+import runpy
+
+
+ORIG = (
+    Path(__file__).resolve().parents[1]
+    / "src"
+    / "dashboard"
+    / "pages"
+    / "5_Scheduled_Cases_Explorer.py"
+)
+
+runpy.run_path(str(ORIG), run_name="__main__")

src/config/paths.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+# Centralized paths used across the dashboard and simulation
+# One source of truth for simulation run directories.
+
+
+def get_runs_base() -> Path:
+    """Return the base directory where simulation runs are stored.
+
+    Priority order:
+    1) Env var DASHBOARD_RUNS_BASE
+    2) Default: outputs/simulation_runs
+    """
+    env = os.getenv("DASHBOARD_RUNS_BASE")
+    if env:
+        return Path(env)
+    return Path("outputs") / "simulation_runs"
+
+
+def list_run_dirs(base: Path | None = None) -> list[Path]:
+    """List immediate child directories representing simulation runs."""
+    base = base or get_runs_base()
+    if not base.exists():
+        return []
+    return sorted([p for p in base.iterdir() if p.is_dir()], reverse=True)
+
+
+def make_new_run_dir(run_id: str) -> Path:
+    """Create and return a new run directory at the configured base.
+
+    Does not overwrite existing; ensures parent exists.
+    """
+    base = get_runs_base()
+    path = base / run_id
+    path.mkdir(parents=True, exist_ok=True)
+    return path

src/dashboard/pages/3_Simulation_Workflow.py

@@ -17,6 +17,7 @@ import plotly.express as px
 import streamlit as st
 
 from src.output.cause_list import CauseListGenerator
+from src.config.paths import get_runs_base
 
 CLI_VERSION = "1.0.0"
 # Page configuration
@@ -366,8 +367,8 @@ elif st.session_state.workflow_step == 2:
 
         log_dir = st.text_input(
             "Output directory",
-            value="outputs/simulation_runs",
-            help="Directory to save simulation outputs",
+            value=str(get_runs_base()),
+            help="Directory to save simulation outputs (override with DASHBOARD_RUNS_BASE env var)",
         )
 
     with col2:

src/dashboard/pages/4_Cause_Lists_And_Overrides.py

@@ -45,7 +45,9 @@ if "draft_modifications" not in st.session_state:
     st.session_state.draft_modifications = []
 
 # Main tabs
-tab1, tab2, tab3 = st.tabs(["View Cause Lists", "Judge Override Interface", "Audit Trail"])
+tab1, tab2, tab3 = st.tabs(
+    ["View Cause Lists", "Judge Override Interface", "Audit Trail"]
+)
 
 # TAB 1: View Cause Lists
 with tab1:
@@ -55,18 +57,24 @@ with tab1:
     )
 
     # Check for available cause lists
-    # Look specifically under outputs/simulation_runs where dashboard writes per-run folders
-    outputs_dir = Path("outputs") / "simulation_runs"
+    # Use centralized runs base directory
+    from src.config.paths import get_runs_base
+
+    outputs_dir = get_runs_base()
 
     if not outputs_dir.exists():
-        st.warning("No simulation outputs found. Run a simulation first to generate cause lists.")
+        st.warning(
+            "No simulation outputs found. Run a simulation first to generate cause lists."
+        )
         st.markdown("Go to **Simulation Workflow** to run a simulation.")
     else:
         # Look for simulation runs (each is a subdirectory in outputs/simulation_runs)
         sim_runs = [d for d in outputs_dir.iterdir() if d.is_dir()]
 
         if not sim_runs:
-            st.info("No simulation runs found. Generate cause lists by running a simulation.")
+            st.info(
+                "No simulation runs found. Generate cause lists by running a simulation."
+            )
         else:
             st.markdown(f"**{len(sim_runs)} simulation run(s) found**")
 
@@ -75,7 +83,9 @@ with tab1:
 
             with col1:
                 selected_run = st.selectbox(
-                    "Select simulation run", options=[d.name for d in sim_runs], key="view_sim_run"
+                    "Select simulation run",
+                    options=[d.name for d in sim_runs],
+                    key="view_sim_run",
                 )
 
             with col2:
@@ -138,18 +148,25 @@ with tab1:
                         st.metric("Unique Cases", unique_cases)
 
                     with col2:
-                        st.metric("Dates", df["date"].nunique() if "date" in df.columns else "N/A")
+                        st.metric(
+                            "Dates",
+                            df["date"].nunique() if "date" in df.columns else "N/A",
+                        )
 
                     with col3:
                         st.metric(
                             "Courtrooms",
-                            df["courtroom"].nunique() if "courtroom" in df.columns else "N/A",
+                            df["courtroom"].nunique()
+                            if "courtroom" in df.columns
+                            else "N/A",
                         )
 
                     with col4:
                         st.metric(
                             "Case Types",
-                            df["case_type"].nunique() if "case_type" in df.columns else "N/A",
+                            df["case_type"].nunique()
+                            if "case_type" in df.columns
+                            else "N/A",
                         )
 
                     # Filters
@@ -206,7 +223,9 @@ with tab1:
                                 ]
 
                     st.markdown("---")
-                    st.markdown(f"**Showing {len(filtered_df):,} of {len(df):,} hearings**")
+                    st.markdown(
+                        f"**Showing {len(filtered_df):,} of {len(df):,} hearings**"
+                    )
 
                     # Display table
                     st.dataframe(
@@ -226,7 +245,9 @@ with tab1:
 
                     # Load into override interface
                     if st.button(
-                        "Load into Override Interface", type="primary", use_container_width=True
+                        "Load into Override Interface",
+                        type="primary",
+                        use_container_width=True,
                     ):
                         st.session_state.current_cause_list = {
                             "source": str(cause_list_path),
@@ -235,7 +256,9 @@ with tab1:
                             "loaded_at": datetime.now().isoformat(),
                         }
                         st.success("Cause list loaded into Override Interface")
-                        st.info("Navigate to 'Judge Override Interface' tab to review and modify.")
+                        st.info(
+                            "Navigate to 'Judge Override Interface' tab to review and modify."
+                        )
 
                 except Exception as e:
                     st.error(f"Error loading cause list: {e}")
@@ -248,7 +271,9 @@ with tab2:
     )
 
     if not st.session_state.current_cause_list:
-        st.info("No cause list loaded. Go to 'View Cause Lists' tab and load a cause list first.")
+        st.info(
+            "No cause list loaded. Go to 'View Cause Lists' tab and load a cause list first."
+        )
     else:
         cause_list_info = st.session_state.current_cause_list
 
@@ -295,7 +320,9 @@ with tab2:
 
                         # Remove from draft
                         draft_df = draft_df[draft_df["case_id"] != case_to_remove]
-                        st.session_state.current_cause_list["data"] = draft_df.to_dict("records")
+                        st.session_state.current_cause_list["data"] = draft_df.to_dict(
+                            "records"
+                        )
 
                         st.success(f"Removed case {case_to_remove}")
                         st.rerun()
@@ -312,7 +339,9 @@ with tab2:
                     )
 
                     new_priority = st.selectbox(
-                        "New priority", options=["HIGH", "MEDIUM", "LOW"], key="new_priority"
+                        "New priority",
+                        options=["HIGH", "MEDIUM", "LOW"],
+                        key="new_priority",
                     )
 
                     if case_to_prioritize != "(None)" and st.button("Update Priority"):
@@ -328,11 +357,11 @@ with tab2:
 
                         # Update priority in draft
                         if "priority" in draft_df.columns:
-                            draft_df.loc[draft_df["case_id"] == case_to_prioritize, "priority"] = (
-                                new_priority
-                            )
-                            st.session_state.current_cause_list["data"] = draft_df.to_dict(
-                                "records"
+                            draft_df.loc[
+                                draft_df["case_id"] == case_to_prioritize, "priority"
+                            ] = new_priority
+                            st.session_state.current_cause_list["data"] = (
+                                draft_df.to_dict("records")
                             )
 
                         st.success(f"Updated priority for case {case_to_prioritize}")
@@ -342,7 +371,9 @@ with tab2:
 
             # Display draft with modifications
             st.markdown("### Current Draft")
-            st.caption(f"{len(st.session_state.draft_modifications)} modification(s) made")
+            st.caption(
+                f"{len(st.session_state.draft_modifications)} modification(s) made"
+            )
 
             st.dataframe(
                 draft_df,
@@ -396,14 +427,18 @@ with tab2:
                     st.success(f"Draft saved to {draft_file}")
 
             with approval_col3:
-                if st.button("Approve & Finalize", type="primary", use_container_width=True):
+                if st.button(
+                    "Approve & Finalize", type="primary", use_container_width=True
+                ):
                     # Record approval
                     approval = {
                         "timestamp": datetime.now().isoformat(),
                         "action": "APPROVE",
                         "source": cause_list_info["source"],
                         "final_count": len(draft_df),
-                        "modifications_count": len(st.session_state.draft_modifications),
+                        "modifications_count": len(
+                            st.session_state.draft_modifications
+                        ),
                         "modifications": st.session_state.draft_modifications.copy(),
                     }
                     st.session_state.override_history.append(approval)
@@ -413,7 +448,9 @@ with tab2:
                     approved_path.mkdir(parents=True, exist_ok=True)
 
                     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-                    approved_file = approved_path / f"approved_cause_list_{timestamp}.csv"
+                    approved_file = (
+                        approved_path / f"approved_cause_list_{timestamp}.csv"
+                    )
 
                     draft_df.to_csv(approved_file, index=False)
 
@@ -439,7 +476,9 @@ with tab3:
     if not st.session_state.override_history:
         st.info("No approval history yet. Approve cause lists to build audit trail.")
     else:
-        st.markdown(f"**{len(st.session_state.override_history)} approval(s) recorded**")
+        st.markdown(
+            f"**{len(st.session_state.override_history)} approval(s) recorded**"
+        )
 
         # Summary statistics
         st.markdown("#### Summary Statistics")

src/dashboard/pages/5_Scheduled_Cases_Explorer.py

@@ -0,0 +1,209 @@
+"""Ticket Explorer (Post-Run)
+
+Browse simulation runs as a CMS of tickets (cases). After a run finishes,
+we build compact Parquet artifacts from events.csv and render case timelines.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import streamlit as st
+import polars as pl
+
+import pandas as pd
+import plotly.express as px
+
+from src.dashboard.utils.ticket_views import build_ticket_views, load_ticket_views
+from src.config.paths import get_runs_base, list_run_dirs
+
+
+st.set_page_config(page_title="Ticket Explorer", page_icon="tickets", layout="wide")
+st.title("Scheduled Cases Explorer (Post-Run)")
+st.caption(
+    "Inspect each case as a ticket with a full audit trail after the simulation run."
+)
+
+
+def _list_runs(base: Path) -> list[Path]:
+    if not base.exists():
+        return []
+    # run dirs are expected to be leaf directories under base
+    return sorted([p for p in base.iterdir() if p.is_dir()], reverse=True)
+
+
+runs_base = get_runs_base()
+run_dirs = list_run_dirs(runs_base)
+
+if not run_dirs:
+    st.warning(f"No simulation runs found in {runs_base}. Run a simulation first.")
+    st.stop()
+
+labels = [d.name for d in run_dirs]
+idx = st.selectbox(
+    "Select a run", options=list(range(len(labels))), format_func=lambda i: labels[i]
+)
+run_dir = run_dirs[idx]
+
+st.markdown(f"Run directory: `{run_dir}`")
+
+col_a, col_b, col_c = st.columns([1, 1, 2])
+with col_a:
+    if st.button(
+        "Rebuild ticket views", help="Recompute Parquet artifacts from events.csv"
+    ):
+        build_ticket_views(run_dir)
+        st.success("Ticket views rebuilt")
+        st.rerun()
+with col_b:
+    events_path = run_dir / "events.csv"
+    st.download_button(
+        "Download events.csv",
+        data=events_path.read_bytes() if events_path.exists() else b"",
+        file_name="events.csv",
+        mime="text/csv",
+        disabled=not events_path.exists(),
+    )
+
+# Load views (build if missing)
+journal_df, summary_df, spans_df = load_ticket_views(run_dir)
+
+
+# Normalize to pandas for Streamlit controls
+def _to_pandas(df):
+    if pl is not None and isinstance(df, pl.DataFrame):
+        return df.to_pandas()
+    return df
+
+
+journal_pd: pd.DataFrame = _to_pandas(journal_df)
+summary_pd: pd.DataFrame = _to_pandas(summary_df)
+spans_pd: pd.DataFrame = _to_pandas(spans_df)
+
+with st.sidebar:
+    st.header("Filters")
+    case_q = st.text_input("Search case_id contains")
+    types = sorted([x for x in summary_pd["case_type"].dropna().unique().tolist()])
+    sel_types = st.multiselect("Case types", options=types, default=[])
+    statuses = ["ACTIVE", "DISPOSED"]
+    sel_status = st.multiselect("Final status", options=statuses, default=[])
+
+    hearings_min, hearings_max = st.slider(
+        "Total hearings",
+        min_value=int(summary_pd.get("total_hearings", pd.Series([0])).min() or 0),
+        max_value=int(summary_pd.get("total_hearings", pd.Series([0])).max() or 0),
+        value=(0, int(summary_pd.get("total_hearings", pd.Series([0])).max() or 0)),
+    )
+
+# Apply filters
+filtered = summary_pd.copy()
+if case_q:
+    filtered = filtered[
+        filtered["case_id"].astype(str).str.contains(case_q, case=False, na=False)
+    ]
+if sel_types:
+    filtered = filtered[filtered["case_type"].isin(sel_types)]
+if sel_status:
+    filtered = filtered[filtered["final_status"].isin(sel_status)]
+filtered = filtered[
+    (filtered.get("total_hearings", 0) >= hearings_min)
+    & (filtered.get("total_hearings", 0) <= hearings_max)
+]
+
+st.markdown("### Filtered Cases")
+
+# Pagination
+page_size = st.selectbox("Rows per page", [25, 50, 100], index=0)
+total_rows = len(filtered)
+page = st.number_input(
+    "Page",
+    min_value=1,
+    max_value=max(1, (total_rows - 1) // page_size + 1),
+    value=1,
+    step=1,
+)
+start, end = (page - 1) * page_size, min(page * page_size, total_rows)
+st.caption(f"Showing {start + 1}–{end} of {total_rows}")
+
+cols_to_show = [
+    "case_id",
+    "case_type",
+    "final_status",
+    "current_stage",
+    "total_hearings",
+    "heard_count",
+    "adjourned_count",
+    "last_seen_date",
+]
+cols_to_show = [c for c in cols_to_show if c in filtered.columns]
+st.dataframe(
+    filtered.iloc[start:end][cols_to_show], use_container_width=True, hide_index=True
+)
+
+st.markdown("### Scheduled Case event details")
+sel_case = st.selectbox(
+    "Choose a case_id",
+    options=filtered["case_id"].tolist() if not filtered.empty else [],
+)
+
+if sel_case:
+    row = summary_pd[summary_pd["case_id"] == sel_case].iloc[0]
+    kpi1, kpi2, kpi3, kpi4 = st.columns(4)
+    with kpi1:
+        st.metric("Total hearings", int(row.get("total_hearings", 0)))
+    with kpi2:
+        st.metric("Heard", int(row.get("heard_count", 0)))
+    with kpi3:
+        st.metric("Adjourned", int(row.get("adjourned_count", 0)))
+    with kpi4:
+        st.metric("Status", str(row.get("final_status", "")))
+
+    # Journal slice
+    j = journal_pd[journal_pd["case_id"] == sel_case].copy()
+    j.sort_values(["date", "seq_no"], inplace=True)
+
+    # Export button
+    csv_bytes = j.to_csv(index=False).encode("utf-8")
+    st.download_button(
+        "Download this ticket's journal (CSV)",
+        data=csv_bytes,
+        file_name=f"{sel_case}_journal.csv",
+        mime="text/csv",
+    )
+
+    # Timeline table
+    st.subheader("Event journal")
+    show_cols = [
+        c
+        for c in [
+            "date",
+            "type",
+            "detail",
+            "stage",
+            "courtroom_id",
+            "priority_score",
+            "readiness_score",
+            "ripeness_status",
+            "days_since_hearing",
+        ]
+        if c in j.columns
+    ]
+    st.dataframe(j[show_cols].tail(100), use_container_width=True, hide_index=True)
+
+    # Stage spans chart (if available)
+    s = spans_pd[spans_pd["case_id"] == sel_case].copy()
+    if not s.empty:
+        s["start_date"] = pd.to_datetime(s["start_date"])
+        s["end_date"] = pd.to_datetime(s["end_date"])
+        fig = px.timeline(
+            s,
+            x_start="start_date",
+            x_end="end_date",
+            y="stage",
+            color="stage",
+            title="Stage spans",
+        )
+        fig.update_yaxes(autorange="reversed")
+        st.plotly_chart(fig, use_container_width=True)
+    else:
+        st.info("No stage change spans available for this ticket.")

src/dashboard/pages/6_Analytics_And_Reports.py

@@ -47,9 +47,10 @@ with tab1:
         "Compare multiple simulation runs to evaluate different policies and parameters."
     )
 
-    # Check for available simulation runs
-    outputs_dir = Path("outputs")
-    runs_dir = outputs_dir / "simulation_runs"
+    # Check for available simulation runs (centralized base)
+    from src.config.paths import get_runs_base
+
+    runs_dir = get_runs_base()
 
     if not runs_dir.exists():
         st.warning(
@@ -252,9 +253,10 @@ with tab2:
     st.markdown("### Performance Trends")
     st.markdown("Analyze performance metrics across all simulation runs.")
 
-    # Use simulation_runs directory recursively
-    outputs_dir = Path("outputs")
-    runs_dir = outputs_dir / "simulation_runs"
+    # Use centralized runs directory recursively
+    from src.config.paths import get_runs_base
+
+    runs_dir = get_runs_base()
 
     if not runs_dir.exists():
         st.warning("No simulation outputs found.")
@@ -273,7 +275,11 @@ with tab2:
                 try:
                     df = pd.read_csv(metrics_path)
                     # Use relative label for clarity across nested structures
-                    df["run"] = str(run_dir.relative_to(runs_dir))
+                    try:
+                        df["run"] = str(run_dir.relative_to(runs_dir))
+                    except ValueError:
+                        # Fallback to folder name if not under base (shouldn't happen)
+                        df["run"] = run_dir.name
                     all_metrics.append(df)
                 except Exception:
                     pass  # Skip invalid metrics files
@@ -345,8 +351,9 @@ with tab3:
     - **Case Type Balance**: Ensures no case type is systematically disadvantaged
     """)
 
-    outputs_dir = Path("outputs")
-    runs_dir = outputs_dir / "simulation_runs"
+    from src.config.paths import get_runs_base
+
+    runs_dir = get_runs_base()
 
     if not runs_dir.exists():
         st.warning("No simulation outputs found.")

src/dashboard/utils/ticket_views.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Tuple
+import polars as pl
+
+
+def build_ticket_views(run_dir: Path) -> Tuple[Path, Path, Path]:
+    """Materialize post-run ticket views from events.csv into Parquet files.
+
+    Creates three artifacts in the run directory:
+      - ticket_journal.parquet
+      - ticket_summary.parquet
+      - ticket_state_spans.parquet
+
+    Returns paths to the three files in the order above.
+    """
+    run_dir = Path(run_dir)
+    events_csv = run_dir / "events.csv"
+    if not events_csv.exists():
+        raise FileNotFoundError(f"events.csv not found in run dir: {events_csv}")
+
+    journal_pq = run_dir / "ticket_journal.parquet"
+    summary_pq = run_dir / "ticket_summary.parquet"
+    spans_pq = run_dir / "ticket_state_spans.parquet"
+
+    events = pl.scan_csv(str(events_csv))
+    # Normalize and order
+    journal = (
+        events.with_columns(
+            [
+                pl.col("date").str.to_date().alias("date"),
+            ]
+        )
+        .sort(["case_id", "date"])  # lazy
+        .with_columns(
+            [
+                pl.arange(0, pl.len()).over("case_id").alias("seq_no"),
+            ]
+        )
+        .collect(streaming=True)
+    )
+    journal.write_parquet(str(journal_pq))
+
+    # Outcomes for counts
+    heard = journal.filter(pl.col("type") == "outcome").with_columns(
+        (pl.col("detail") == "heard").alias("is_heard")
+    )
+
+    base_summary = journal.group_by("case_id").agg(
+        [
+            pl.first("case_type").alias("case_type"),
+            pl.first("date").alias("first_seen_date"),
+            pl.last("date").alias("last_seen_date"),
+            pl.col("stage").sort_by("seq_no").last().alias("current_stage"),
+            (pl.col("type") == "stage_change")
+            .cast(pl.Int64)
+            .sum()
+            .alias("stage_changes"),
+            (pl.col("type") == "ripeness_change")
+            .cast(pl.Int64)
+            .sum()
+            .alias("ripeness_transitions"),
+        ]
+    )
+    outcome_summary = (
+        heard.group_by("case_id")
+        .agg(
+            [
+                pl.len().alias("total_hearings"),
+                pl.col("is_heard").cast(pl.Int64).sum().alias("heard_count"),
+            ]
+        )
+        .with_columns(
+            (pl.col("total_hearings") - pl.col("heard_count")).alias("adjourned_count")
+        )
+    )
+    disposed = (
+        journal.filter(pl.col("type") == "disposed")
+        .group_by("case_id")
+        .agg([pl.min("date").alias("disposal_date")])
+    )
+
+    summary = (
+        base_summary.join(outcome_summary, on="case_id", how="left")
+        .with_columns(
+            [
+                pl.col("total_hearings").fill_null(0),
+                pl.col("heard_count").fill_null(0),
+                pl.col("adjourned_count").fill_null(0),
+            ]
+        )
+        .join(disposed, on="case_id", how="left")
+        .with_columns(
+            [
+                # Compute age in full days from first to last seen.
+                # Use total_days() on duration to be compatible across Polars versions.
+                (pl.col("last_seen_date") - pl.col("first_seen_date"))
+                .dt.total_days()
+                .alias("age_days_end"),
+                pl.when(pl.col("disposal_date").is_not_null())
+                .then(pl.lit("DISPOSED"))
+                .otherwise(pl.lit("ACTIVE"))
+                .alias("final_status"),
+            ]
+        )
+    )
+    summary.write_parquet(str(summary_pq))
+
+    # Spans from stage changes
+    sc = (
+        journal.filter(pl.col("type") == "stage_change")
+        .select(["case_id", "date", "stage"])
+        .rename({"date": "start_date"})
+    )
+    spans = sc.with_columns(
+        [
+            pl.col("start_date").shift(-1).over("case_id").alias("end_date"),
+        ]
+    ).with_columns(
+        [
+            pl.when(pl.col("end_date").is_null())
+            .then(pl.col("start_date"))
+            .otherwise(pl.col("end_date"))
+            .alias("end_date")
+        ]
+    )
+    spans.write_parquet(str(spans_pq))
+    return journal_pq, summary_pq, spans_pq
+
+
+def load_ticket_views(run_dir: Path):
+    """Load ticket views; build them if missing. Returns (journal, summary, spans).
+
+    Uses Polars DataFrames if Polars is available; otherwise returns pandas DataFrames.
+    """
+    run_dir = Path(run_dir)
+    journal_pq = run_dir / "ticket_journal.parquet"
+    summary_pq = run_dir / "ticket_summary.parquet"
+    spans_pq = run_dir / "ticket_state_spans.parquet"
+
+    if not (journal_pq.exists() and summary_pq.exists() and spans_pq.exists()):
+        build_ticket_views(run_dir)
+
+    journal = pl.read_parquet(str(journal_pq))
+    summary = pl.read_parquet(str(summary_pq))
+    spans = pl.read_parquet(str(spans_pq))
+    return journal, summary, spans

src/simulation/engine.py

@@ -36,6 +36,7 @@ from src.simulation.allocator import AllocationStrategy, CourtroomAllocator
 from src.simulation.events import EventWriter
 from src.simulation.policies import get_policy
 from src.utils.calendar import CourtCalendar
+from src.config.paths import make_new_run_dir
 
 
 @dataclass
@@ -86,11 +87,11 @@ class CourtSim:
         self._log_dir: Path | None = None
         if self.cfg.log_dir:
             self._log_dir = Path(self.cfg.log_dir)
+            self._log_dir.mkdir(parents=True, exist_ok=True)
         else:
-            # default run folder
+            # default run folder (centralized base path)
             run_id = time.strftime("%Y%m%d_%H%M%S")
-            self._log_dir = Path("data") / "sim_runs" / run_id
-        self._log_dir.mkdir(parents=True, exist_ok=True)
+            self._log_dir = make_new_run_dir(run_id)
         self._metrics_path = self._log_dir / "metrics.csv"
         with self._metrics_path.open("w", newline="", encoding="utf-8") as f:
             w = csv.writer(f)