Submission ready

Data/quick_demo/COMPARISON_REPORT.md

@@ -1,19 +0,0 @@
-# Court Scheduling System - Performance Comparison
-
-Generated: 2025-11-26 05:47:24
-
-## Configuration
-
-- Training Cases: 10,000
-- Simulation Period: 90 days (0.2 years)
-- RL Episodes: 20
-- RL Learning Rate: 0.15
-- RL Epsilon: 0.4
-- Policies Compared: readiness, rl
-
-## Results Summary
-
-| Policy | Disposals | Disposal Rate | Utilization | Avg Hearings/Day |
-|--------|-----------|---------------|-------------|------------------|
-| Readiness | 5,421 | 54.2% | 84.2% | 635.4 |
-| Rl | 5,439 | 54.4% | 83.7% | 631.9 |

Data/quick_demo/EXECUTIVE_SUMMARY.md

@@ -1,47 +0,0 @@
-# Court Scheduling System - Executive Summary
-
-## Hackathon Submission: Karnataka High Court
-
-### System Overview
-This intelligent court scheduling system uses Reinforcement Learning to optimize case allocation and improve judicial efficiency. The system was evaluated using a comprehensive 2-year simulation with 10,000 real cases.
-
-### Key Achievements
-
-**54.4% Case Disposal Rate** - Significantly improved case clearance
-**83.7% Court Utilization** - Optimal resource allocation  
-**56,874 Hearings Scheduled** - Over 90 days
-**AI-Powered Decisions** - Reinforcement learning with 20 training episodes
-
-### Technical Innovation
-
-- **Reinforcement Learning**: Tabular Q-learning with 6D state space
-- **Real-time Adaptation**: Dynamic policy adjustment based on case characteristics
-- **Multi-objective Optimization**: Balances disposal rate, fairness, and utilization
-- **Production Ready**: Generates daily cause lists for immediate deployment
-
-### Impact Metrics
-
-- **Cases Disposed**: 5,439 out of 10,000
-- **Average Hearings per Day**: 631.9
-- **System Scalability**: Handles 50,000+ case simulations efficiently
-- **Judicial Time Saved**: Estimated 75 productive court days
-
-### Deployment Readiness
-
-**Daily Cause Lists**: Automated generation for 90 days  
-**Performance Monitoring**: Comprehensive metrics and analytics  
-**Judicial Override**: Complete control system for judge approval  
-**Multi-courtroom Support**: Load-balanced allocation across courtrooms
-
-### Next Steps
-
-1. **Pilot Deployment**: Begin with select courtrooms for validation
-2. **Judge Training**: Familiarization with AI-assisted scheduling
-3. **Performance Monitoring**: Track real-world improvement metrics
-4. **System Expansion**: Scale to additional court complexes
-
----
-
-**Generated**: 2025-11-26 05:47:24  
-**System Version**: 2.0 (Hackathon Submission)  
-**Contact**: Karnataka High Court Digital Innovation Team

Data/quick_demo/visualizations/performance_charts.md

@@ -1,7 +0,0 @@
-# Performance Visualizations
-
-Generated charts showing:
-- Daily disposal rates
-- Court utilization over time
-- Case type performance
-- Load balancing effectiveness

HACKATHON_SUBMISSION.md

@@ -1,264 +0,0 @@
-# Hackathon Submission Guide
-## Intelligent Court Scheduling System with Reinforcement Learning
-
-### Quick Start - Hackathon Demo
-
-#### Option 1: Full Workflow (Recommended)
-```bash
-# Run complete pipeline: generate cases + simulate
-uv run court-scheduler workflow --cases 50000 --days 730
-```
-
-This executes:
-- EDA parameter extraction (if needed)
-- Case generation with realistic distributions
-- Multi-year simulation with policy comparison
-- Performance analysis and reporting
-
-#### Option 2: Quick Demo
-```bash
-# 90-day quick demo with 10,000 cases
-uv run court-scheduler workflow --cases 10000 --days 90
-```
-
-#### Option 3: Step-by-Step
-```bash
-# 1. Extract parameters from historical data
-uv run court-scheduler eda
-
-# 2. Generate synthetic cases
-uv run court-scheduler generate --cases 50000
-
-# 3. Train RL agent (optional)
-uv run court-scheduler train --episodes 100
-
-# 4. Run simulation
-uv run court-scheduler simulate --cases data/cases.csv --days 730 --policy readiness
-```
-
-### What the Pipeline Does
-
-The comprehensive pipeline executes 7 automated steps:
-
-**Step 1: EDA & Parameter Extraction**
-- Analyzes 739K+ historical hearings
-- Extracts transition probabilities, duration statistics
-- Generates simulation parameters
-
-**Step 2: Data Generation**
-- Creates realistic synthetic case dataset
-- Configurable size (default: 50,000 cases)
-- Diverse case types and complexity levels
-
-**Step 3: RL Training**
-- Trains Tabular Q-learning agent
-- Real-time progress monitoring with reward tracking
-- Configurable episodes and hyperparameters
-
-**Step 4: 2-Year Simulation**
-- Runs 730-day court scheduling simulation
-- Compares RL agent vs baseline algorithms
-- Tracks disposal rates, utilization, fairness metrics
-
-**Step 5: Daily Cause List Generation**
-- Generates production-ready daily cause lists
-- Exports for all simulation days
-- Court-room wise scheduling details
-
-**Step 6: Performance Analysis**
-- Comprehensive comparison reports
-- Performance visualizations
-- Statistical analysis of all metrics
-
-**Step 7: Executive Summary**
-- Hackathon-ready summary document
-- Key achievements and impact metrics
-- Deployment readiness checklist
-
-### Expected Output
-
-After completion, you'll find in your output directory:
-
-```
-data/hackathon_run/
-|-- pipeline_config.json          # Full configuration used
-|-- training_cases.csv            # Generated case dataset
-|-- trained_rl_agent.pkl          # Trained RL model
-|-- EXECUTIVE_SUMMARY.md          # Hackathon submission summary
-|-- COMPARISON_REPORT.md          # Detailed performance comparison
-|-- simulation_rl/                # RL policy results
-    |-- events.csv
-    |-- metrics.csv
-    |-- report.txt
-    |-- cause_lists/
-        |-- daily_cause_list.csv  # 730 days of cause lists
-|-- simulation_readiness/         # Baseline results
-    |-- ...
-|-- visualizations/               # Performance charts
-    |-- performance_charts.md
-```
-
-### Hackathon Winning Features
-
-#### 1. Real-World Impact
-- **52%+ Disposal Rate**: Demonstrable case clearance improvement
-- **730 Days of Cause Lists**: Ready for immediate court deployment
-- **Multi-Courtroom Support**: Load-balanced allocation across 5+ courtrooms
-- **Scalability**: Tested with 50,000+ cases
-
-#### 2. Technical Innovation
-- **Reinforcement Learning**: AI-powered adaptive scheduling
-- **6D State Space**: Comprehensive case characteristic modeling
-- **Hybrid Architecture**: Combines RL intelligence with rule-based constraints
-- **Real-time Learning**: Continuous improvement through experience
-
-#### 3. Production Readiness
-- **Interactive CLI**: User-friendly parameter configuration
-- **Comprehensive Reporting**: Executive summaries and detailed analytics
-- **Quality Assurance**: Validated against baseline algorithms
-- **Professional Output**: Court-ready cause lists and reports
-
-#### 4. Judicial Integration
-- **Ripeness Classification**: Filters unready cases (40%+ efficiency gain)
-- **Fairness Metrics**: Low Gini coefficient for equitable distribution
-- **Transparency**: Explainable decision-making process
-- **Override Capability**: Complete judicial control maintained
-
-### Performance Benchmarks
-
-Based on comprehensive testing:
-
-| Metric | RL Agent | Baseline | Advantage |
-|--------|----------|----------|-----------|
-| Disposal Rate | 52.1% | 51.9% | +0.4% |
-| Court Utilization | 85%+ | 85%+ | Comparable |
-| Load Balance (Gini) | 0.248 | 0.243 | Comparable |
-| Scalability | 50K cases | 50K cases | Yes |
-| Adaptability | High | Fixed | High |
-
-### Customization Options
-
-#### For Hackathon Judges
-```bash
-# Large-scale impressive demo
-uv run court-scheduler workflow --cases 100000 --days 730
-
-# With all policies compared
-uv run court-scheduler simulate --cases data/cases.csv --days 730 --policy readiness
-uv run court-scheduler simulate --cases data/cases.csv --days 730 --policy fifo
-uv run court-scheduler simulate --cases data/cases.csv --days 730 --policy age
-```
-
-#### For Technical Evaluation
-```bash
-# Focus on RL training quality
-uv run court-scheduler train --episodes 200 --lr 0.12 --cases 500 --output models/intensive_agent.pkl
-
-# Then simulate with trained agent
-uv run court-scheduler simulate --cases data/cases.csv --days 730 --policy rl --agent models/intensive_agent.pkl
-```
-
-#### For Quick Demo/Testing
-```bash
-# Fast proof-of-concept
-uv run court-scheduler workflow --cases 10000 --days 90
-
-# Pre-configured:
-# - 10,000 cases
-# - 90 days simulation
-# - ~5-10 minutes runtime
-```
-
-### Tips for Winning Presentation
-
-1. **Start with the Problem**
-   - Show Karnataka High Court case pendency statistics
-   - Explain judicial efficiency challenges
-   - Highlight manual scheduling limitations
-
-2. **Demonstrate the Solution**
-   - Run the interactive pipeline live
-   - Show real-time RL training progress
-   - Display generated cause lists
-
-3. **Present the Results**
-   - Open EXECUTIVE_SUMMARY.md
-   - Highlight key achievements from comparison table
-   - Show actual cause list files (730 days ready)
-
-4. **Emphasize Innovation**
-   - Reinforcement Learning for judicial scheduling (novel)
-   - Production-ready from day 1 (practical)
-   - Scalable to entire court system (impactful)
-
-5. **Address Concerns**
-   - Judicial oversight: Complete override capability
-   - Fairness: Low Gini coefficients, transparent metrics
-   - Reliability: Tested against proven baselines
-   - Deployment: Ready-to-use cause lists generated
-
-### System Requirements
-
-- **Python**: 3.10+ with UV
-- **Memory**: 8GB+ RAM (16GB recommended for 50K cases)
-- **Storage**: 2GB+ for full pipeline outputs
-- **Runtime**: 
-  - Quick demo: 5-10 minutes
-  - Full 2-year sim (50K cases): 30-60 minutes
-  - Large-scale (100K cases): 1-2 hours
-
-### Troubleshooting
-
-**Issue**: Out of memory during simulation
-**Solution**: Reduce n_cases to 10,000-20,000 or increase system RAM
-
-**Issue**: RL training very slow
-**Solution**: Reduce episodes to 50 or cases_per_episode to 500
-
-**Issue**: EDA parameters not found
-**Solution**: Run `uv run court-scheduler eda` first
-
-**Issue**: Import errors
-**Solution**: Ensure UV environment is activated, run `uv sync`
-
-### Advanced Configuration
-
-For fine-tuned control, use configuration files:
-
-```bash
-# Create configs/ directory with TOML files
-# Example: configs/generate_config.toml
-# [generation]
-# n_cases = 50000
-# start_date = "2022-01-01"
-# end_date = "2023-12-31"
-
-# Then run with config
-uv run court-scheduler generate --config configs/generate_config.toml
-uv run court-scheduler simulate --config configs/simulate_config.toml
-```
-
-Or use command-line options:
-```bash
-# Full customization
-uv run court-scheduler workflow \
-  --cases 50000 \
-  --days 730 \
-  --start 2022-01-01 \
-  --end 2023-12-31 \
-  --output data/custom_run \
-  --seed 42
-```
-
-### Contact & Support
-
-For hackathon questions or technical support:
-- Review PIPELINE.md for detailed architecture
-- Check README.md for system overview
-- See rl/README.md for RL-specific documentation
-
----
-
-**Good luck with your hackathon submission!**
-
-This system represents a genuine breakthrough in applying AI to judicial efficiency. The combination of production-ready cause lists, proven performance metrics, and innovative RL architecture positions this as a compelling winning submission.

README.md

@@ -75,9 +75,31 @@ This project delivers a **comprehensive** court scheduling system featuring:
 
 ## Quick Start
 
-### Unified CLI (Recommended)
+### Interactive Dashboard (Primary Interface)
 
-All operations now use a single entry point:
+**For submission/demo, use the dashboard - it's fully self-contained:**
+
+```bash
+# Launch dashboard
+uv run streamlit run scheduler/dashboard/app.py
+
+# Open browser to http://localhost:8501
+```
+
+**The dashboard handles everything:**
+1. Run EDA pipeline (processes raw data, extracts parameters, generates visualizations)
+2. Explore historical data and parameters
+3. Test ripeness classification
+4. Generate cases and run simulations
+5. Review cause lists with judge override capability
+6. Train RL models
+7. Compare performance and generate reports
+
+**No CLI commands required** - everything is accessible through the web interface.
+
+### Alternative: Command Line Interface
+
+For automation or scripting, all operations available via CLI:
 
 ```bash
 # See all available commands
@@ -282,17 +304,10 @@ These fixes ensure that RL training is reproducible, aligned with evaluation con
 
 ## Documentation
 
-### Hackathon & Presentation
-- `HACKATHON_SUBMISSION.md` - Complete hackathon submission guide
-- `court_scheduler_rl.py` - Interactive CLI for full pipeline
-
-### Technical Documentation
-- `COMPREHENSIVE_ANALYSIS.md` - EDA findings and insights
-- `RIPENESS_VALIDATION.md` - Ripeness system validation results
-- `PIPELINE.md` - Complete development and deployment pipeline
-- `rl/README.md` - Reinforcement learning module documentation
+**Primary**: This README (complete user guide)  
+**Additional**: `docs/` folder contains:
+- `DASHBOARD.md` - Dashboard usage and architecture
+- `CONFIGURATION.md` - Configuration system reference
+- `HACKATHON_SUBMISSION.md` - Hackathon-specific submission guide
 
-### Outputs & Configuration
-- `reports/figures/` - Parameter visualizations
-- `data/sim_runs/` - Simulation outputs and metrics
-- `configs/` - RL training configurations and profiles
+**Scripts**: See `scripts/README.md` for analysis utilities

cli/commands/__init__.py

@@ -1 +0,0 @@
-"""CLI command modules."""

cli/config.py

@@ -10,7 +10,6 @@ from typing import Any, Dict, Optional
 
 from pydantic import BaseModel, Field, field_validator
 
-
 # Configuration Models
 
 class GenerateConfig(BaseModel):

cli/main.py

@@ -1,17 +1,15 @@
 """Unified CLI for Court Scheduling System.
 
-This module provides a single entry point for all court scheduling operations:
+This module provides a single entry point for key court scheduling operations:
 - EDA pipeline execution
 - Case generation
-- Simulation runs  
-- RL training
+- Simulation runs
 - Full workflow orchestration
 """
 
 from __future__ import annotations
 
 import sys
-from datetime import date
 from pathlib import Path
 
 import typer
@@ -20,13 +18,20 @@ from rich.progress import Progress, SpinnerColumn, TextColumn
 
 from cli import __version__
 
+try:
+    sys.stdout.reconfigure(encoding="utf-8")
+    sys.stderr.reconfigure(encoding="utf-8")
+except Exception:
+    pass
+
 # Initialize Typer app and console
 app = typer.Typer(
     name="court-scheduler",
     help="Court Scheduling System for Karnataka High Court",
     add_completion=False,
 )
-console = Console()
+# Use force_terminal=False to avoid legacy Windows rendering issues with Unicode
+console = Console(legacy_windows=False)
 
 
 @app.command()
@@ -37,15 +42,14 @@ def eda(
 ) -> None:
     """Run the EDA pipeline (load, explore, extract parameters)."""
     console.print("[bold blue]Running EDA Pipeline[/bold blue]")
-    
+
     try:
         # Import here to avoid loading heavy dependencies if not needed
-        from src.eda_load_clean import run_load_and_clean
-        from src.eda_exploration import run_exploration
-        from src.eda_parameters import run_parameter_export
-        
+        from eda.exploration import run_exploration
+        from eda.load_clean import run_load_and_clean
+        from eda.parameters import run_parameter_export
+
         with Progress(
-            SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
             console=console,
         ) as progress:
@@ -53,23 +57,23 @@ def eda(
                 task = progress.add_task("Step 1/3: Load and clean data...", total=None)
                 run_load_and_clean()
                 progress.update(task, completed=True)
-                console.print("[green]\u2713[/green] Data loaded and cleaned")
-            
+                console.print("Data loaded and cleaned")
+
             if not skip_viz:
                 task = progress.add_task("Step 2/3: Generate visualizations...", total=None)
                 run_exploration()
                 progress.update(task, completed=True)
-                console.print("[green]\u2713[/green] Visualizations generated")
-            
+                console.print("Visualizations generated")
+
             if not skip_params:
                 task = progress.add_task("Step 3/3: Extract parameters...", total=None)
                 run_parameter_export()
                 progress.update(task, completed=True)
-                console.print("[green]\u2713[/green] Parameters extracted")
-        
-        console.print("\n[bold green]\u2713 EDA Pipeline Complete![/bold green]")
+                console.print("Parameters extracted")
+
+        console.print("\n[bold]EDA Pipeline Complete[/bold]")
         console.print("Outputs: reports/figures/")
-        
+
     except Exception as e:
         console.print(f"[bold red]Error:[/bold red] {e}")
         raise typer.Exit(code=1)
@@ -77,21 +81,41 @@ def eda(
 
 @app.command()
 def generate(
-    config: Path = typer.Option(None, "--config", exists=True, dir_okay=False, readable=True, help="Path to config (.toml or .json)"),
-    interactive: bool = typer.Option(False, "--interactive", help="Prompt for parameters interactively"),
+    config: Path = typer.Option(  # noqa: B008
+        None,
+        "--config",
+        exists=True,
+        dir_okay=False,
+        readable=True,
+        help="Path to config (.toml or .json)",
+    ),
+    interactive: bool = typer.Option(
+        False, "--interactive", help="Prompt for parameters interactively"
+    ),
     n_cases: int = typer.Option(10000, "--cases", "-n", help="Number of cases to generate"),
     start_date: str = typer.Option("2022-01-01", "--start", help="Start date (YYYY-MM-DD)"),
     end_date: str = typer.Option("2023-12-31", "--end", help="End date (YYYY-MM-DD)"),
-    output: str = typer.Option("data/generated/cases.csv", "--output", "-o", help="Output CSV file"),
+    output: str = typer.Option(
+        "data/generated/cases.csv", "--output", "-o", help="Output CSV file"
+    ),
     seed: int = typer.Option(42, "--seed", help="Random seed for reproducibility"),
+    case_type_dist: str = typer.Option(
+        None,
+        "--case-type-dist",
+        help=(
+            'Custom case type distribution. Accepts JSON (e.g., \'{"Writ":0.6,"Civil":0.4}\') '
+            "or comma-separated pairs 'Writ:0.6,Civil:0.4'. Defaults to historical distribution."
+        ),
+    ),
 ) -> None:
     """Generate synthetic test cases for simulation."""
     console.print(f"[bold blue]Generating {n_cases:,} test cases[/bold blue]")
-    
+
     try:
         from datetime import date as date_cls
+
+        from cli.config import GenerateConfig, load_generate_config
         from scheduler.data.case_generator import CaseGenerator
-        from cli.config import load_generate_config, GenerateConfig
 
         # Resolve parameters: config -> interactive -> flags
         if config:
@@ -115,23 +139,58 @@ def generate(
         end = cfg.end
         output_path = cfg.output
         output_path.parent.mkdir(parents=True, exist_ok=True)
-        
+
         with Progress(
-            SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
             console=console,
         ) as progress:
             task = progress.add_task("Generating cases...", total=None)
-            
+
+            # Parse optional custom case type distribution
+            def _parse_case_type_dist(s: str | None) -> dict | None:
+                if not s:
+                    return None
+                s = s.strip()
+                try:
+                    import json
+
+                    obj = json.loads(s)
+                    if isinstance(obj, dict):
+                        return obj
+                except Exception:
+                    pass
+                # Try comma-separated pairs format
+                parts = [p.strip() for p in s.split(",") if p.strip()]
+                dist: dict[str, float] = {}
+                for part in parts:
+                    if ":" not in part:
+                        continue
+                    k, v = part.split(":", 1)
+                    k = k.strip()
+                    try:
+                        val = float(v)
+                    except ValueError:
+                        continue
+                    if k:
+                        dist[k] = val
+                return dist or None
+
+            user_dist = _parse_case_type_dist(case_type_dist)
+
             gen = CaseGenerator(start=start, end=end, seed=seed)
-            cases = gen.generate(n_cases, stage_mix_auto=True)
+            cases = gen.generate(n_cases, stage_mix_auto=True, case_type_distribution=user_dist)
+            # Write primary cases file
             CaseGenerator.to_csv(cases, output_path)
-            
+            # Also write detailed hearings history alongside, for the dashboard/classifier
+            hearings_path = output_path.parent / "hearings.csv"
+            CaseGenerator.to_hearings_csv(cases, hearings_path)
+
             progress.update(task, completed=True)
-        
-        console.print(f"[green]\u2713[/green] Generated {len(cases):,} cases")
-        console.print(f"[green]\u2713[/green] Saved to: {output_path}")
-        
+
+        console.print(f"Generated {len(cases):,} cases")
+        console.print(f"Saved to: {output_path}")
+        console.print(f"Hearings history: {hearings_path}")
+
     except Exception as e:
         console.print(f"[bold red]Error:[/bold red] {e}")
         raise typer.Exit(code=1)
@@ -139,43 +198,60 @@ def generate(
 
 @app.command()
 def simulate(
-    config: Path = typer.Option(None, "--config", exists=True, dir_okay=False, readable=True, help="Path to config (.toml or .json)"),
-    interactive: bool = typer.Option(False, "--interactive", help="Prompt for parameters interactively"),
+    config: Path = typer.Option(
+        None,
+        "--config",
+        exists=True,
+        dir_okay=False,
+        readable=True,
+        help="Path to config (.toml or .json)",
+    ),
+    interactive: bool = typer.Option(
+        False, "--interactive", help="Prompt for parameters interactively"
+    ),
     cases_csv: str = typer.Option("data/generated/cases.csv", "--cases", help="Input cases CSV"),
     days: int = typer.Option(384, "--days", "-d", help="Number of working days to simulate"),
     start_date: str = typer.Option(None, "--start", help="Simulation start date (YYYY-MM-DD)"),
-    policy: str = typer.Option("readiness", "--policy", "-p", help="Scheduling policy (fifo/age/readiness)"),
+    policy: str = typer.Option(
+        "readiness", "--policy", "-p", help="Scheduling policy (fifo/age/readiness)"
+    ),
     seed: int = typer.Option(42, "--seed", help="Random seed"),
     log_dir: str = typer.Option(None, "--log-dir", "-o", help="Output directory for logs"),
 ) -> None:
     """Run court scheduling simulation."""
     console.print(f"[bold blue]Running {days}-day simulation[/bold blue]")
-    
+
     try:
         from datetime import date as date_cls
+
+        from cli.config import SimulateConfig, load_simulate_config
         from scheduler.core.case import CaseStatus
         from scheduler.data.case_generator import CaseGenerator
         from scheduler.metrics.basic import gini
         from scheduler.simulation.engine import CourtSim, CourtSimConfig
-        from cli.config import load_simulate_config, SimulateConfig
-        
+
         # Resolve parameters: config -> interactive -> flags
         if config:
             scfg = load_simulate_config(config)
             # CLI flags override config if provided
-            scfg = scfg.model_copy(update={
-                "cases": Path(cases_csv) if cases_csv else scfg.cases,
-                "days": days if days else scfg.days,
-                "start": (date_cls.fromisoformat(start_date) if start_date else scfg.start),
-                "policy": policy if policy else scfg.policy,
-                "seed": seed if seed else scfg.seed,
-                "log_dir": (Path(log_dir) if log_dir else scfg.log_dir),
-            })
+            scfg = scfg.model_copy(
+                update={
+                    "cases": Path(cases_csv) if cases_csv else scfg.cases,
+                    "days": days if days else scfg.days,
+                    "start": (date_cls.fromisoformat(start_date) if start_date else scfg.start),
+                    "policy": policy if policy else scfg.policy,
+                    "seed": seed if seed else scfg.seed,
+                    "log_dir": (Path(log_dir) if log_dir else scfg.log_dir),
+                }
+            )
         else:
             if interactive:
                 cases_csv = typer.prompt("Cases CSV", default=cases_csv)
                 days = typer.prompt("Days to simulate", default=days)
-                start_date = typer.prompt("Start date (YYYY-MM-DD) or blank", default=start_date or "") or None
+                start_date = (
+                    typer.prompt("Start date (YYYY-MM-DD) or blank", default=start_date or "")
+                    or None
+                )
                 policy = typer.prompt("Policy [readiness|fifo|age]", default=policy)
                 seed = typer.prompt("Random seed", default=seed)
                 log_dir = typer.prompt("Log dir (or blank)", default=log_dir or "") or None
@@ -198,7 +274,7 @@ def simulate(
             start = scfg.start or date_cls.today().replace(day=1)
             gen = CaseGenerator(start=start, end=start.replace(day=28), seed=scfg.seed)
             cases = gen.generate(n_cases=5 * 151)
-        
+
         # Run simulation
         cfg = CourtSimConfig(
             start=start,
@@ -208,7 +284,7 @@ def simulate(
             duration_percentile="median",
             log_dir=scfg.log_dir,
         )
-        
+
         with Progress(
             SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
@@ -218,94 +294,46 @@ def simulate(
             sim = CourtSim(cfg, cases)
             res = sim.run()
             progress.update(task, completed=True)
-        
+
         # Display results
         console.print("\n[bold green]Simulation Complete![/bold green]")
-        console.print(f"\nHorizon: {cfg.start} \u2192 {res.end_date} ({days} days)")
-        console.print(f"\n[bold]Hearing Metrics:[/bold]")
+        console.print(f"\nHorizon: {cfg.start} -> {res.end_date} ({days} days)")
+        console.print("\n[bold]Hearing Metrics:[/bold]")
         console.print(f"  Total: {res.hearings_total:,}")
-        console.print(f"  Heard: {res.hearings_heard:,} ({res.hearings_heard/max(1,res.hearings_total):.1%})")
-        console.print(f"  Adjourned: {res.hearings_adjourned:,} ({res.hearings_adjourned/max(1,res.hearings_total):.1%})")
-        
-        disp_times = [(c.disposal_date - c.filed_date).days for c in cases 
-                      if c.disposal_date is not None and c.status == CaseStatus.DISPOSED]
+        console.print(
+            f"  Heard: {res.hearings_heard:,} ({res.hearings_heard / max(1, res.hearings_total):.1%})"
+        )
+        console.print(
+            f"  Adjourned: {res.hearings_adjourned:,} ({res.hearings_adjourned / max(1, res.hearings_total):.1%})"
+        )
+
+        disp_times = [
+            (c.disposal_date - c.filed_date).days
+            for c in cases
+            if c.disposal_date is not None and c.status == CaseStatus.DISPOSED
+        ]
         gini_disp = gini(disp_times) if disp_times else 0.0
-        
-        console.print(f"\n[bold]Disposal Metrics:[/bold]")
-        console.print(f"  Cases disposed: {res.disposals:,} ({res.disposals/len(cases):.1%})")
+
+        console.print("\n[bold]Disposal Metrics:[/bold]")
+        console.print(f"  Cases disposed: {res.disposals:,} ({res.disposals / len(cases):.1%})")
         console.print(f"  Gini coefficient: {gini_disp:.3f}")
-        
-        console.print(f"\n[bold]Efficiency:[/bold]")
+
+        console.print("\n[bold]Efficiency:[/bold]")
         console.print(f"  Utilization: {res.utilization:.1%}")
-        console.print(f"  Avg hearings/day: {res.hearings_total/days:.1f}")
-        
+        console.print(f"  Avg hearings/day: {res.hearings_total / days:.1f}")
+
         if log_dir:
-            console.print(f"\n[bold cyan]Output Files:[/bold cyan]")
+            console.print("\n[bold cyan]Output Files:[/bold cyan]")
             console.print(f"  - {log_dir}/report.txt")
             console.print(f"  - {log_dir}/metrics.csv")
             console.print(f"  - {log_dir}/events.csv")
-            
+
     except Exception as e:
         console.print(f"[bold red]Error:[/bold red] {e}")
         raise typer.Exit(code=1)
 
 
-@app.command()
-def train(
-    episodes: int = typer.Option(20, "--episodes", "-e", help="Number of training episodes"),
-    cases_per_episode: int = typer.Option(200, "--cases", "-n", help="Cases per episode"),
-    learning_rate: float = typer.Option(0.15, "--lr", help="Learning rate"),
-    epsilon: float = typer.Option(0.4, "--epsilon", help="Initial epsilon for exploration"),
-    output: str = typer.Option("models/rl_agent.pkl", "--output", "-o", help="Output model file"),
-    seed: int = typer.Option(42, "--seed", help="Random seed"),
-) -> None:
-    """Train RL agent for case scheduling."""
-    console.print(f"[bold blue]Training RL Agent ({episodes} episodes)[/bold blue]")
-    
-    try:
-        from rl.simple_agent import TabularQAgent
-        from rl.training import train_agent
-        from rl.config import RLTrainingConfig
-        import pickle
-        
-        # Create agent
-        agent = TabularQAgent(learning_rate=learning_rate, epsilon=epsilon, discount=0.95)
-        
-        # Configure training
-        config = RLTrainingConfig(
-            episodes=episodes,
-            cases_per_episode=cases_per_episode,
-            training_seed=seed,
-            initial_epsilon=epsilon,
-            learning_rate=learning_rate,
-        )
-        
-        with Progress(
-            SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
-            console=console,
-        ) as progress:
-            task = progress.add_task(f"Training {episodes} episodes...", total=None)
-            stats = train_agent(agent, rl_config=config, verbose=False)
-            progress.update(task, completed=True)
-        
-        # Save model
-        output_path = Path(output)
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-        with output_path.open("wb") as f:
-            pickle.dump(agent, f)
-        
-        console.print("\n[bold green]\u2713 Training Complete![/bold green]")
-        console.print(f"\nFinal Statistics:")
-        console.print(f"  Episodes: {len(stats['episodes'])}")
-        console.print(f"  Final disposal rate: {stats['disposal_rates'][-1]:.1%}")
-        console.print(f"  States explored: {stats['states_explored'][-1]:,}")
-        console.print(f"  Q-table size: {len(agent.q_table):,}")
-        console.print(f"\nModel saved to: {output_path}")
-        
-    except Exception as e:
-        console.print(f"[bold red]Error:[/bold red] {e}")
-        raise typer.Exit(code=1)
+# RL training command removed
 
 
 @app.command()
@@ -317,33 +345,34 @@ def workflow(
 ) -> None:
     """Run full workflow: EDA -> Generate -> Simulate -> Report."""
     console.print("[bold blue]Running Full Workflow[/bold blue]\n")
-    
+
     output_path = Path(output_dir)
     output_path.mkdir(parents=True, exist_ok=True)
-    
+
     try:
         # Step 1: EDA (skip if already done recently)
         console.print("[bold]Step 1/3:[/bold] EDA Pipeline")
         console.print("  Skipping (use 'court-scheduler eda' to regenerate)\n")
-        
+
         # Step 2: Generate cases
         console.print("[bold]Step 2/3:[/bold] Generate Cases")
         cases_file = output_path / "cases.csv"
         from datetime import date as date_cls
+
         from scheduler.data.case_generator import CaseGenerator
-        
+
         start = date_cls(2022, 1, 1)
         end = date_cls(2023, 12, 31)
-        
+
         gen = CaseGenerator(start=start, end=end, seed=seed)
         cases = gen.generate(n_cases, stage_mix_auto=True)
         CaseGenerator.to_csv(cases, cases_file)
-        console.print(f"  [green]\u2713[/green] Generated {len(cases):,} cases\n")
-        
+        console.print(f"  Generated {len(cases):,} cases\n")
+
         # Step 3: Run simulation
         console.print("[bold]Step 3/3:[/bold] Run Simulation")
         from scheduler.simulation.engine import CourtSim, CourtSimConfig
-        
+
         sim_start = max(c.filed_date for c in cases)
         cfg = CourtSimConfig(
             start=sim_start,
@@ -352,19 +381,19 @@ def workflow(
             policy="readiness",
             log_dir=output_path,
         )
-        
+
         sim = CourtSim(cfg, cases)
-        res = sim.run()
-        console.print(f"  [green]\u2713[/green] Simulation complete\n")
-        
+        sim.run()
+        console.print("  Simulation complete\n")
+
         # Summary
-        console.print("[bold green]\u2713 Workflow Complete![/bold green]")
+        console.print("[bold]Workflow Complete[/bold]")
         console.print(f"\nResults: {output_path}/")
         console.print(f"  - cases.csv ({len(cases):,} cases)")
-        console.print(f"  - report.txt (simulation summary)")
-        console.print(f"  - metrics.csv (daily metrics)")
-        console.print(f"  - events.csv (event log)")
-        
+        console.print("  - report.txt (simulation summary)")
+        console.print("  - metrics.csv (daily metrics)")
+        console.print("  - events.csv (event log)")
+
     except Exception as e:
         console.print(f"[bold red]Error:[/bold red] {e}")
         raise typer.Exit(code=1)
@@ -379,18 +408,18 @@ def dashboard(
     console.print("[bold blue]Launching Interactive Dashboard[/bold blue]")
     console.print(f"Dashboard will be available at: http://{host}:{port}")
     console.print("Press Ctrl+C to stop the dashboard\n")
-    
+
     try:
         import subprocess
         import sys
-        
+
         # Get path to dashboard app
         app_path = Path(__file__).parent.parent / "scheduler" / "dashboard" / "app.py"
-        
+
         if not app_path.exists():
             console.print(f"[bold red]Error:[/bold red] Dashboard app not found at {app_path}")
             raise typer.Exit(code=1)
-        
+
         # Run streamlit
         cmd = [
             sys.executable,
@@ -405,9 +434,9 @@ def dashboard(
             "--browser.gatherUsageStats",
             "false",
         ]
-        
+
         subprocess.run(cmd)
-        
+
     except KeyboardInterrupt:
         console.print("\n[yellow]Dashboard stopped[/yellow]")
     except Exception as e:

docs/DASHBOARD.md

@@ -1,404 +1,41 @@
-# Interactive Dashboard - Living Documentation
+# Interactive Dashboard
 
-**Last Updated**: 2025-11-27
-**Status**: Initial Implementation Complete
-**Version**: 0.1.0
+**Last Updated**: 2025-11-29  
+**Status**: Production Ready  
+**Version**: 1.0.0
 
-## Overview
+## Launch
 
-This document tracks the design decisions, architecture, usage patterns, and evolution of the Interactive Multi-Page Dashboard for the Court Scheduling System.
-
-## Purpose and Goals
-
-The dashboard provides three key functionalities:
-1. **EDA Analysis** - Visualize and explore court case data patterns
-2. **Ripeness Classifier** - Interactive explainability and threshold tuning
-3. **RL Training** - Train and visualize reinforcement learning agents
-
-### Design Philosophy
-- Transparency: Every algorithm decision should be explainable
-- Interactivity: Users can adjust parameters and see immediate impact
-- Efficiency: Data caching to minimize load times
-- Integration: Seamless integration with existing CLI and modules
-
-## Architecture
-
-### Technology Stack
-
-**Framework**: Streamlit 1.28+
-- Chosen for rapid prototyping and native multi-page support
-- Built-in state management via `st.session_state`
-- Excellent integration with Plotly and Pandas/Polars
-
-**Visualization**: Plotly
-- Interactive charts (zoom, pan, hover)
-- Better aesthetics than Matplotlib for dashboards
-- Native Streamlit support
-
-**Data Processing**:
-- Polars for fast CSV loading
-- Pandas for compatibility with existing code
-- Caching with `@st.cache_data` decorator
-
-### Directory Structure
-
-```
-scheduler/
-  dashboard/
-    __init__.py           # Package initialization
-    app.py                # Main entry point (home page)
-    utils/
-      __init__.py
-      data_loader.py      # Cached data loading functions
-    pages/
-      1_EDA_Analysis.py           # EDA visualizations
-      2_Ripeness_Classifier.py    # Ripeness explainability
-      3_RL_Training.py            # RL training interface
-```
-
-### Module Reuse Strategy
-
-The dashboard reuses existing components without duplication:
-- `scheduler.data.param_loader.ParameterLoader` - Load EDA-derived parameters
-- `scheduler.data.case_generator.CaseGenerator` - Load generated cases
-- `scheduler.core.ripeness.RipenessClassifier` - Classification logic
-- `scheduler.core.case.Case` - Case data structure
-- `rl.training.train_agent()` - RL training (future integration)
-
-## Page Implementations
-
-### Page 1: EDA Analysis
-
-**Features**:
-- Key metrics dashboard (total cases, adjournment rates, stages)
-- Interactive filters (case type, stage)
-- Multiple visualizations:
-  - Case distribution by type (bar chart + pie chart)
-  - Stage analysis (bar chart + pie chart)
-  - Adjournment patterns (bar charts by type and stage)
-  - Adjournment probability heatmap (stage × case type)
-- Raw data viewer with download capability
-
-**Data Sources**:
-- `Data/processed/cleaned_cases.csv` - Cleaned case data from EDA pipeline
-- `configs/parameters/` - Pre-computed parameters from ParameterLoader
-
-**Design Decisions**:
-- Use tabs instead of separate sections for better organization
-- Show top 10/15 items in charts to avoid clutter
-- Provide download button for filtered data
-- Cache data with 1-hour TTL to balance freshness and performance
-
-### Page 2: Ripeness Classifier
-
-**Features**:
-- **Tab 1: Configuration**
-  - Display current thresholds
-  - Stage-specific rules table
-  - Decision tree logic explanation
-- **Tab 2: Interactive Testing**
-  - Synthetic case creation
-  - Real-time classification with explanations
-  - Feature importance visualization
-  - Criteria pass/fail breakdown
-- **Tab 3: Batch Classification**
-  - Load generated test cases
-  - Classify all with current thresholds
-  - Show distribution (RIPE/UNRIPE/UNKNOWN)
-
-**State Management**:
-- Thresholds stored in `st.session_state`
-- Sidebar sliders for real-time adjustment
-- Reset button to restore defaults
-- Session-based (not persisted to disk)
-
-**Explainability Approach**:
-- Clear criteria breakdown (service hearings, case age, stage days, keywords)
-- Visual indicators (✓/✗) for pass/fail
-- Feature importance bar chart
-- Before/after comparison capability
-
-**Design Decisions**:
-- Simplified classification logic for demo (uses basic criteria)
-- Future: Integrate actual RipenessClassifier.classify_case()
-- Stage-specific rules hardcoded for now (future: load from config)
-- Color coding: green (RIPE), orange (UNKNOWN), red (UNRIPE)
-
-### Page 3: RL Training
-
-**Features**:
-- **Tab 1: Train Agent**
-  - Configuration form (episodes, learning rate, epsilon, etc.)
-  - Training progress visualization (demo mode)
-  - Multiple live charts (disposal rate, rewards, states, epsilon decay)
-  - Command generation for CLI training
-- **Tab 2: Training History**
-  - Load and display previous training runs
-  - Plot historical performance
-- **Tab 3: Model Comparison**
-  - Load saved models from models/ directory
-  - Compare Q-table sizes and hyperparameters
-  - Visualization of model differences
-
-**Demo Mode**:
-- Current implementation simulates training results
-- Generates synthetic stats for visualization
-- Shows CLI command for actual training
-- Future: Integrate real-time training with rl.training.train_agent()
-
-**Design Decisions**:
-- Demo mode chosen for initial release (no blocking UI during training)
-- Future: Add async training with progress updates
-- Hyperparameter guide in expander for educational value
-- Model persistence via pickle (existing pattern)
-
-## CLI Integration
-
-### Command
 ```bash
-uv run court-scheduler dashboard [--port PORT] [--host HOST]
+uv run streamlit run scheduler/dashboard/app.py
+# Open http://localhost:8501
 ```
 
-**Default**: `http://localhost:8501`
-
-**Implementation**:
-- Added to `cli/main.py` as `@app.command()`
-- Uses subprocess to launch Streamlit
-- Validates dashboard app.py exists before launching
-- Handles KeyboardInterrupt gracefully
-
-**Usage Example**:
-```bash
-# Launch on default port
-uv run court-scheduler dashboard
-
-# Custom port
-uv run court-scheduler dashboard --port 8080
-
-# Bind to all interfaces
-uv run court-scheduler dashboard --host 0.0.0.0 --port 8080
-```
-
-## Data Flow
-
-### Loading Sequence
-1. User launches dashboard via CLI
-2. `app.py` loads, displays home page and system status
-3. User navigates to a page (e.g., EDA Analysis)
-4. Page imports data_loader utilities
-5. `@st.cache_data` checks cache for data
-6. If not cached, load from disk and cache
-7. Data processed and visualized
-8. User interactions trigger re-renders (cached data reused)
+## Pages
 
-### Caching Strategy
-- **TTL**: 3600 seconds (1 hour) for data files
-- **No TTL**: For computed statistics (invalidates on data change)
-- **Session State**: For UI state (thresholds, training configs)
+1. **Data & Insights** - Historical analysis of 739K+ hearings
+2. **Ripeness Classifier** - Case bottleneck detection with explainability
+3. **RL Training** - Train and evaluate RL scheduling agents
+4. **Simulation Workflow** - Run simulations with configurable policies
+5. **Cause Lists & Overrides** - Judge override interface for cause lists
+6. **Analytics & Reports** - Performance comparison and reporting
 
-### Performance Considerations
-- Polars for fast CSV loading
-- Limit DataFrame display to first 100 rows
-- Top N filtering for visualizations (top 10/15)
-- Lazy loading (pages only load data when accessed)
+## Workflows
 
-## Usage Patterns
+**EDA Exploration**: Run EDA → Launch dashboard → Filter and visualize data  
+**Judge Overrides**: Launch dashboard → Simulation Workflow → Review/modify cause lists  
+**RL Training**: Launch dashboard → RL Training page → Configure and train
 
-### Typical Workflow 1: EDA Exploration
-1. Run EDA pipeline: `uv run court-scheduler eda`
-2. Launch dashboard: `uv run court-scheduler dashboard`
-3. Navigate to EDA Analysis page
-4. Apply filters (case type, stage)
-5. Explore visualizations
-6. Download filtered data if needed
+## Data Sources
 
-### Typical Workflow 2: Threshold Tuning
-1. Generate test cases: `uv run court-scheduler generate`
-2. Launch dashboard: `uv run court-scheduler dashboard`
-3. Navigate to Ripeness Classifier page
-4. Adjust thresholds in sidebar
-5. Test with synthetic case (Tab 2)
-6. Run batch classification (Tab 3)
-7. Analyze impact on RIPE/UNRIPE distribution
-
-### Typical Workflow 3: RL Training
-1. Launch dashboard: `uv run court-scheduler dashboard`
-2. Navigate to RL Training page
-3. Configure hyperparameters (Tab 1)
-4. Copy CLI command and run separately (or use demo)
-5. Return to dashboard, view history (Tab 2)
-6. Compare models (Tab 3)
-
-## Future Enhancements
-
-### Planned Features
-- [ ] Real-time RL training integration (non-blocking)
-- [ ] RipenessCalibrator integration (auto-suggest thresholds)
-- [ ] RipenessMetrics tracking (false positive/negative rates)
-- [ ] Actual RipenessClassifier integration (not simplified logic)
-- [ ] EDA plot regeneration option
-- [ ] Export threshold configurations
-- [ ] Simulation runner from dashboard
-- [ ] Authentication (if deployed externally)
-
-### Technical Improvements
-- [ ] Async data loading for large datasets
-- [ ] WebSocket support for real-time training updates
-- [ ] Plotly Dash migration (if more customization needed)
-- [ ] Unit tests for dashboard components
-- [ ] Playwright automated UI tests
-
-### UX Improvements
-- [ ] Dark mode support
-- [ ] Custom color themes
-- [ ] Keyboard shortcuts
-- [ ] Save/load dashboard state
-- [ ] Export visualizations as PNG/PDF
-- [ ] Guided tour for new users
-
-## Testing Strategy
-
-### Manual Testing Checklist
-- [ ] Dashboard launches without errors
-- [ ] All pages load correctly
-- [ ] EDA page: filters work, visualizations render
-- [ ] Ripeness page: sliders adjust thresholds, classification updates
-- [ ] RL page: form submission works, charts render
-- [ ] CLI command generation correct
-- [ ] System status checks work
-
-### Integration Testing
-- [ ] Load actual cleaned data
-- [ ] Load generated test cases
-- [ ] Load parameters from configs/
-- [ ] Verify caching behavior
-- [ ] Test with missing data files
-
-### Performance Testing
-- [ ] Large dataset loading (100K+ rows)
+- Historical data: `reports/figures/v*/cases_clean.parquet` and `hearings_clean.parquet`  
+- Parameters: `reports/figures/v*/params/` (auto-detected latest version)  
+- Falls back to bundled defaults if EDA not run
 - [ ] Batch classification (10K+ cases)
 - [ ] Multiple concurrent users (if deployed)
 
 ## Troubleshooting
 
-### Common Issues
-
-**Issue**: Dashboard won't launch
-- **Check**: Is Streamlit installed? `pip list | grep streamlit`
-- **Solution**: Ensure venv is activated, run `uv sync`
-
-**Issue**: "Data file not found" warnings
-- **Check**: Has EDA pipeline been run?
-- **Solution**: Run `uv run court-scheduler eda`
-
-**Issue**: Empty visualizations
-- **Check**: Is `Data/processed/cleaned_cases.csv` empty?
-- **Solution**: Verify EDA pipeline completed successfully
-
-**Issue**: Ripeness batch classification fails
-- **Check**: Are test cases generated?
-- **Solution**: Run `uv run court-scheduler generate`
-
-**Issue**: Slow page loads
-- **Check**: Is data being cached?
-- **Solution**: Check Streamlit cache, reduce data size
-
-## Design Decisions Log
-
-### Decision 1: Streamlit over Dash/Gradio
-**Date**: 2025-11-27
-**Rationale**: 
-- Already in dependencies (no new install)
-- Simpler multi-page support
-- Better for data science workflows
-- Faster development time
-
-**Alternatives Considered**:
-- Dash: More customizable but more boilerplate
-- Gradio: Better for ML demos, less flexible
-
-### Decision 2: Plotly over Matplotlib
-**Date**: 2025-11-27
-**Rationale**:
-- Interactive by default (zoom, pan, hover)
-- Better aesthetics for dashboards
-- Native Streamlit integration
-- Users expect interactivity in modern dashboards
-
-**Note**: Matplotlib still used for static EDA plots already generated
-
-### Decision 3: Session State for Thresholds
-**Date**: 2025-11-27
-**Rationale**:
-- Ephemeral experimentation (users can reset easily)
-- No need to persist to disk
-- Simpler implementation
-- Users can export configs separately if needed
-
-**Future**: May add "save configuration" feature
-
-### Decision 4: Demo Mode for RL Training
-**Date**: 2025-11-27
-**Rationale**:
-- Avoid blocking UI during long training runs
-- Show visualization capabilities
-- Guide users to use CLI for actual training
-- Simpler initial implementation
-
-**Future**: Add async training with WebSocket updates
-
-### Decision 5: Simplified Ripeness Logic
-**Date**: 2025-11-27
-**Rationale**:
-- Demonstrate explainability concept
-- Avoid tight coupling with RipenessClassifier implementation
-- Easier to understand for users
-- Placeholder for full integration
-
-**Future**: Integrate actual RipenessClassifier.classify_case()
-
-## Maintenance Notes
-
-### Dependencies
-- Streamlit: Keep updated for security fixes
-- Plotly: Monitor for breaking changes
-- Polars: Ensure compatibility with Pandas conversion
-
-### Code Quality
-- Follow project ruff/black style
-- Add docstrings to new functions
-- Keep pages under 350 lines if possible
-- Extract reusable components to utils/
-
-### Performance Monitoring
-- Monitor cache hit rates
-- Track page load times
-- Watch for memory leaks with large datasets
-
-## Educational Value
-
-The dashboard serves an educational purpose:
-- **Transparency**: Shows how algorithms work (ripeness classifier)
-- **Interactivity**: Lets users experiment (threshold tuning)
-- **Visualization**: Makes complex data accessible (EDA plots)
-- **Learning**: Explains RL concepts (hyperparameter guide)
-
-This aligns with the "explainability" goal of the Code4Change project.
-
-## Conclusion
-
-The dashboard successfully provides:
-1. Comprehensive EDA visualization
-2. Full ripeness classifier explainability
-3. RL training interface (demo mode)
-4. CLI integration
-5. Cached data loading
-6. Interactive threshold tuning
-
-Next steps focus on integrating real RL training and enhancing the ripeness classifier with actual implementation.
-
----
-
-**Contributors**: Roy Aalekh (Initial Implementation)
-**Project**: Code4Change Court Scheduling System
-**Target**: Karnataka High Court Scheduling Optimization
+**Dashboard won't launch**: Run `uv sync` to install dependencies  
+**Empty visualizations**: Run `uv run court-scheduler eda` first  
+**Slow loading**: Data auto-cached after first load (1-hour TTL)

docs/ENHANCEMENT_PLAN.md

@@ -1,311 +0,0 @@
-# Court Scheduling System - Bug Fixes & Enhancements
-
-## Completed Enhancements
-
-### 2.3 Add Learning Feedback Loop (COMPLETED)
-**Status**: Implemented (Dec 2024)
-**Solution**:
-- Created `RipenessMetrics` class to track predictions vs outcomes
-- Created `RipenessCalibrator` with 5 calibration rules
-- Added `set_thresholds()` and `get_current_thresholds()` to RipenessClassifier
-- Tracks false positive/negative rates, generates confusion matrix
-- Suggests threshold adjustments with confidence levels
-
-**Files**:
-- scheduler/monitoring/ripeness_metrics.py (254 lines)
-- scheduler/monitoring/ripeness_calibrator.py (279 lines)
-- scheduler/core/ripeness.py (enhanced with threshold management)
-
-### 4.0.4 Fix RL Reward Computation (COMPLETED)
-**Status**: Fixed (Dec 2024)
-**Solution**:
-- Integrated ParameterLoader into RLTrainingEnvironment
-- Replaced hardcoded probabilities (0.7, 0.6, 0.4) with EDA-derived parameters
-- Training now uses param_loader.get_adjournment_prob() and param_loader.get_stage_transitions_fast()
-- Validation: adjournment rates align within 1% of EDA (43.0% vs 42.3%)
-
-**Files**:
-- rl/training.py (enhanced _simulate_hearing_outcome)
-
----
-
-## Priority 1: Fix State Management Bugs (P0 - Critical)
-
-### 1.1 Fix Override State Pollution
-**Problem**: Override flags persist across runs, priority overrides don't clear
-**Impact**: Cases keep boosted priority in subsequent schedules
-
-**Solution**:
-- Add `clear_overrides()` method to Case class
-- Call after each scheduling day or at simulation reset
-- Store overrides in separate tracking dict instead of mutating case objects
-- Alternative: Use immutable override context passed to scheduler
-
-**Files**:
-- scheduler/core/case.py (add clear method)
-- scheduler/control/overrides.py (refactor to non-mutating approach)
-- scheduler/simulation/engine.py (call clear after scheduling)
-
-### 1.2 Preserve Override Auditability
-**Problem**: Invalid overrides removed in-place from input list
-**Impact**: Caller loses original override list, can't audit rejections
-
-**Solution**:
-- Validate into separate collections: `valid_overrides`, `rejected_overrides`
-- Return structured result: `OverrideResult(applied, rejected_with_reasons)`
-- Keep original override list immutable
-- Log all rejections with clear error messages
-
-**Files**:
-- scheduler/control/overrides.py (refactor apply_overrides)
-- scheduler/core/algorithm.py (update override handling)
-
-### 1.3 Track Override Outcomes Explicitly
-**Problem**: Applied overrides in list, rejected as None in unscheduled
-**Impact**: Hard to distinguish "not selected" from "override rejected"
-
-**Solution**:
-- Create `OverrideAudit` dataclass: (override_id, status, reason, timestamp)
-- Return audit log from schedule_day: `result.override_audit`
-- Separate tracking: `cases_not_selected`, `overrides_accepted`, `overrides_rejected`
-
-**Files**:
-- scheduler/core/algorithm.py (add audit tracking)
-- scheduler/control/overrides.py (structured audit log)
-
-## Priority 2: Strengthen Ripeness Detection (P0 - Critical)
-
-### 2.1 Require Positive Evidence for RIPE
-**Problem**: Defaults to RIPE when signals ambiguous
-**Impact**: Schedules cases that may not be ready
-
-**Solution**:
-- Add `UNKNOWN` status to RipenessStatus enum
-- Require explicit RIPE signals: stage progression, document check, age threshold
-- Default to UNKNOWN (not RIPE) when data insufficient
-- Add confidence score: `ripeness_confidence: float` (0.0-1.0)
-
-**Files**:
-- scheduler/core/ripeness.py (add UNKNOWN, confidence scoring)
-- scheduler/simulation/engine.py (filter UNKNOWN cases)
-
-### 2.2 Enrich Ripeness Signals
-**Problem**: Only uses keyword search and basic stage checks
-**Impact**: Misses nuanced bottlenecks
-
-**Solution**:
-- Add signals:
-    - Filing age relative to case type median
-    - Adjournment reason history (recurring "summons pending")
-    - Outstanding task list (if available in data)
-    - Party/lawyer attendance rate
-    - Document submission completeness
-- Multi-signal scoring: weighted combination
-- Configurable thresholds per signal
-
-**Files**:
-- scheduler/core/ripeness.py (add signal extraction)
-- scheduler/data/config.py (ripeness thresholds)
-
-### 2.3 Add Learning Feedback Loop (COMPLETED - See top of document)
-~~Moved to Completed Enhancements section~~
-
-## Priority 3: Re-enable Simulation Inflow (P1 - High)
-
-### 3.1 Parameterize Case Filing
-**Problem**: New filings commented out, no caseload growth
-**Impact**: Unrealistic long-term simulations
-
-**Solution**:
-- Add `enable_inflow: bool` to CourtSimConfig
-- Add `filing_rate_multiplier: float` (default 1.0 for historical rate)
-- Expose inflow controls in pipeline config
-- Surface inflow metrics in simulation results
-
-**Files**:
-- scheduler/simulation/engine.py (uncomment + gate filings)
-- court_scheduler_rl.py (add config parameters)
-
-### 3.2 Make Ripeness Re-evaluation Configurable
-**Problem**: Fixed 7-day re-evaluation may be too infrequent
-**Impact**: Stale classifications drive multiple days
-
-**Solution**:
-- Add `ripeness_eval_frequency_days: int` to config (default 7)
-- Consider adaptive frequency: more frequent when backlog high
-- Log ripeness re-evaluation events
-
-**Files**:
-- scheduler/simulation/engine.py (configurable frequency)
-- scheduler/data/config.py (add parameter)
-
-## Priority 4: EDA and Configuration Robustness (P1 - High)
-
-### 4.0.1 Fix EDA Memory Issues
-**Problem**: EDA converts full Parquet to pandas, risks memory exhaustion
-**Impact**: Pipeline fails on large datasets (>50K cases)
-
-**Solution**:
-- Add sampling parameter: `eda_sample_size: Optional[int]` (default None = full)
-- Stream data instead of loading all at once
-- Downcast numeric columns before conversion
-- Add memory monitoring and warnings
-
-**Files**:
-- src/eda_exploration.py (add sampling)
-- src/eda_config.py (memory limits)
-
-### 4.0.2 Fix Headless Rendering
-**Problem**: Plotly renderer defaults to "browser", fails in CI/CD
-**Impact**: Cannot run EDA in automated pipelines
-
-**Solution**:
-- Detect headless environment (check DISPLAY env var)
-- Default to "png" or "svg" renderer in headless mode
-- Add `--renderer` CLI flag to override
-
-**Files**:
-- src/eda_exploration.py (renderer detection)
-- court_scheduler_rl.py (add CLI flag)
-
-### 4.0.3 Fix Missing Parameters Fallback
-**Problem**: get_latest_params_dir raises when no params exist
-**Impact**: Fresh environments can't run simulations
-
-**Solution**:
-- Bundle baseline parameters in `scheduler/data/defaults/`
-- Fallback to bundled params if no EDA run found
-- Add `--use-defaults` flag to force baseline params
-- Log warning when using defaults vs EDA-derived
-
-**Files**:
-- scheduler/data/config.py (fallback logic)
-- scheduler/data/defaults/ (new directory with baseline params)
-
-### 4.0.4 Fix RL Parameter Alignment (COMPLETED - See top of document)
-~~Moved to Completed Enhancements section~~
-
-## Priority 5: Enhanced Scheduling Constraints (P2 - Medium)
-
-### 4.1 Judge Blocking & Availability
-**Problem**: No per-judge blocked dates
-**Impact**: Schedules hearings when judge unavailable
-
-**Solution**:
-- Add `blocked_dates: list[date]` to Judge entity
-- Add `availability_override: dict[date, bool]` for one-time changes
-- Filter eligible courtrooms by judge availability
-
-**Files**:
-- scheduler/core/judge.py (add availability fields)
-- scheduler/core/algorithm.py (check availability)
-
-### 4.2 Per-Case Gap Overrides
-**Problem**: Global MIN_GAP_BETWEEN_HEARINGS, no exceptions
-**Impact**: Urgent cases can't be expedited
-
-**Solution**:
-- Add `min_gap_override: Optional[int]` to Case
-- Apply in eligibility check: `gap = case.min_gap_override or MIN_GAP`
-- Track override applications in metrics
-
-**Files**:
-- scheduler/core/case.py (add field)
-- scheduler/core/algorithm.py (use override in eligibility)
-
-### 4.3 Courtroom Capacity Changes
-**Problem**: Fixed daily capacity, no dynamic adjustments
-**Impact**: Can't model half-days, special sessions
-
-**Solution**:
-- Add `capacity_overrides: dict[date, int]` to Courtroom
-- Apply in allocation: check date-specific capacity first
-- Support judge preferences (e.g., "Property cases Mondays")
-
-**Files**:
-- scheduler/core/courtroom.py (add override dict)
-- scheduler/simulation/allocator.py (check overrides)
-
-## Priority 5: Testing & Validation (P1 - High)
-
-### 5.1 Unit Tests for Bug Fixes
-**Coverage**:
-- Override state clearing
-- Ripeness UNKNOWN handling
-- Inflow rate calculations
-- Constraint validation
-
-**Files**:
-- tests/test_overrides.py (new)
-- tests/test_ripeness.py (expand)
-- tests/test_simulation.py (inflow tests)
-
-### 5.2 Integration Tests
-**Scenarios**:
-- Full pipeline with overrides applied
-- Ripeness transitions over time
-- Blocked judge dates respected
-- Capacity overrides honored
-
-**Files**:
-- tests/integration/test_scheduling_pipeline.py (new)
-
-## Implementation Order
-
-1. **Week 1**: Fix critical bugs
-   - State management (1.1, 1.2, 1.3)
-   - Configuration robustness (4.0.3 - parameter fallback)
-   - Unit tests for above
-
-2. **Week 2**: Strengthen core systems
-   - Ripeness detection (2.1, 2.2 - UNKNOWN status, multi-signal)
-   - RL reward alignment (4.0.4 - shared reward logic)
-   - Re-enable inflow (3.1, 3.2)
-
-3. **Week 3**: Robustness and constraints
-   - EDA scaling (4.0.1 - memory management)
-   - Headless rendering (4.0.2 - CI/CD compatibility)
-   - Enhanced constraints (5.1, 5.2, 5.3)
-
-4. **Week 4**: Testing and polish
-   - Comprehensive integration tests
-   - Ripeness learning feedback (2.3)
-   - All edge cases documented
-
-## Success Criteria
-
-**Bug Fixes**:
-- Override state doesn't leak between runs
-- All override decisions auditable
-- Rejected overrides tracked with reasons
-
-**Ripeness**:
-- UNKNOWN status used when confidence low
-- False positive rate < 15% (marked RIPE but adjourned)
-- Multi-signal scoring operational
-
-**Simulation Realism**:
-- Inflow configurable and metrics tracked
-- Long runs show realistic caseload patterns
-- Ripeness re-evaluation frequency tunable
-
-**Constraints**:
-- Judge blocked dates respected 100%
-- Per-case gap overrides functional
-- Capacity changes applied correctly
-
-**Quality**:
-- 90%+ test coverage for bug fixes
-- Integration tests pass
-- All edge cases documented
-
-## Background
-
-This plan addresses critical bugs and architectural improvements identified through code analysis:
-
-1. **State Management**: Override flags persist across runs, causing silent bias
-2. **Ripeness Defaults**: System defaults to RIPE when uncertain, risking premature scheduling
-3. **Closed Simulation**: No case inflow, making long-term runs unrealistic
-4. **Limited Auditability**: In-place mutations make debugging and QA difficult
-
-See commit history for OutputManager refactoring and Windows compatibility fixes already completed.

models/latest.pkl

@@ -1 +0,0 @@
-D:/personal/code4change/code4change-analysis/outputs/runs/run_20251127_054834/training/agent.pkl

outputs/runs/run_20251127_054834/reports/COMPARISON_REPORT.md

@@ -1,19 +0,0 @@
-# Court Scheduling System - Performance Comparison
-
-Generated: 2025-11-27 05:50:04
-
-## Configuration
-
-- Training Cases: 10,000
-- Simulation Period: 90 days (0.2 years)
-- RL Episodes: 20
-- RL Learning Rate: 0.15
-- RL Epsilon: 0.4
-- Policies Compared: readiness, rl
-
-## Results Summary
-
-| Policy | Disposals | Disposal Rate | Utilization | Avg Hearings/Day |
-|--------|-----------|---------------|-------------|------------------|
-| Readiness | 5,343 | 53.4% | 78.8% | 594.7 |
-| Rl | 5,365 | 53.6% | 78.5% | 593.0 |

outputs/runs/run_20251127_054834/reports/EXECUTIVE_SUMMARY.md

@@ -1,47 +0,0 @@
-# Court Scheduling System - Executive Summary
-
-## Hackathon Submission: Karnataka High Court
-
-### System Overview
-This intelligent court scheduling system uses Reinforcement Learning to optimize case allocation and improve judicial efficiency. The system was evaluated using a comprehensive 2-year simulation with 10,000 real cases.
-
-### Key Achievements
-
-**53.6% Case Disposal Rate** - Significantly improved case clearance
-**78.5% Court Utilization** - Optimal resource allocation  
-**53,368 Hearings Scheduled** - Over 90 days
-**AI-Powered Decisions** - Reinforcement learning with 20 training episodes
-
-### Technical Innovation
-
-- **Reinforcement Learning**: Tabular Q-learning with 6D state space
-- **Real-time Adaptation**: Dynamic policy adjustment based on case characteristics
-- **Multi-objective Optimization**: Balances disposal rate, fairness, and utilization
-- **Production Ready**: Generates daily cause lists for immediate deployment
-
-### Impact Metrics
-
-- **Cases Disposed**: 5,365 out of 10,000
-- **Average Hearings per Day**: 593.0
-- **System Scalability**: Handles 50,000+ case simulations efficiently
-- **Judicial Time Saved**: Estimated 71 productive court days
-
-### Deployment Readiness
-
-**Daily Cause Lists**: Automated generation for 90 days  
-**Performance Monitoring**: Comprehensive metrics and analytics  
-**Judicial Override**: Complete control system for judge approval  
-**Multi-courtroom Support**: Load-balanced allocation across courtrooms
-
-### Next Steps
-
-1. **Pilot Deployment**: Begin with select courtrooms for validation
-2. **Judge Training**: Familiarization with AI-assisted scheduling
-3. **Performance Monitoring**: Track real-world improvement metrics
-4. **System Expansion**: Scale to additional court complexes
-
----
-
-**Generated**: 2025-11-27 05:50:04  
-**System Version**: 2.0 (Hackathon Submission)  
-**Contact**: Karnataka High Court Digital Innovation Team

outputs/runs/run_20251127_054834/reports/visualizations/performance_charts.md

@@ -1,7 +0,0 @@
-# Performance Visualizations
-
-Generated charts showing:
-- Daily disposal rates
-- Court utilization over time
-- Case type performance
-- Load balancing effectiveness

pyproject.toml

@@ -51,7 +51,7 @@ target-version = ["py311"]
 [tool.ruff]
 select = ["E", "F", "I", "B", "C901", "N", "D"]
 line-length = 100
-src = ["src"]
+src = [".", "scheduler"]
 
 [tool.ruff.pydocstyle]
 convention = "google"
@@ -63,5 +63,11 @@ markers = [
     "unit: Unit tests",
     "integration: Integration tests",
     "fairness: Fairness validation tests",
-    "performance: Performance benchmark tests"
+    "performance: Performance benchmark tests",
+    "rl: Reinforcement learning tests",
+    "simulation: Simulation engine tests",
+    "edge_case: Edge case and boundary condition tests",
+    "failure: Failure scenario tests",
+    "slow: Slow-running tests (>5 seconds)"
 ]
+

report.txt

@@ -1,56 +0,0 @@
-================================================================================
-SIMULATION REPORT
-================================================================================
-
-Configuration:
-  Cases: 3000
-  Days simulated: 60
-  Policy: readiness
-  Horizon end: 2024-06-20
-
-Hearing Metrics:
-  Total hearings: 16,137
-  Heard: 9,981 (61.9%)
-  Adjourned: 6,156 (38.1%)
-
-Disposal Metrics:
-  Cases disposed: 708
-  Disposal rate: 23.6%
-  Gini coefficient: 0.195
-
-Disposal Rates by Case Type:
-  CA  :  159/ 587 ( 27.1%)
-  CCC :  133/ 334 ( 39.8%)
-  CMP :   14/  86 ( 16.3%)
-  CP  :  105/ 294 ( 35.7%)
-  CRP :  142/ 612 ( 23.2%)
-  RFA :   77/ 519 ( 14.8%)
-  RSA :   78/ 568 ( 13.7%)
-
-Efficiency Metrics:
-  Court utilization: 35.6%
-  Avg hearings/day: 268.9
-
-Ripeness Impact:
-  Transitions: 0
-  Cases filtered (unripe): 3,360
-  Filter rate: 17.2%
-
-Final Ripeness Distribution:
-  RIPE: 2236 (97.6%)
-  UNRIPE_DEPENDENT: 19 (0.8%)
-  UNRIPE_SUMMONS: 37 (1.6%)
-
-Courtroom Allocation:
-  Strategy: load_balanced
-  Load balance fairness (Gini): 0.002
-  Avg daily load: 53.8 cases
-  Allocation changes: 10,527
-  Capacity rejections: 0
-
-  Courtroom-wise totals:
-    Courtroom 1: 3,244 cases (54.1/day)
-    Courtroom 2: 3,233 cases (53.9/day)
-    Courtroom 3: 3,227 cases (53.8/day)
-    Courtroom 4: 3,221 cases (53.7/day)
-    Courtroom 5: 3,212 cases (53.5/day)

rl/README.md

@@ -1,110 +0,0 @@
-# Reinforcement Learning Module
-
-This module implements tabular Q-learning for court case scheduling prioritization, following the hybrid approach outlined in `RL_EXPLORATION_PLAN.md`.
-
-## Architecture
-
-### Core Components
-
-- **`simple_agent.py`**: Tabular Q-learning agent with 6D state space
-- **`training.py`**: Training environment and learning pipeline  
-- **`__init__.py`**: Module exports and interface
-
-### State Representation (6D)
-
-Cases are represented by a 6-dimensional state vector:
-
-1. **Stage** (0-10): Current litigation stage (discretized)
-2. **Age** (0-9): Case age in days (normalized and discretized) 
-3. **Days since last** (0-9): Days since last hearing (normalized)
-4. **Urgency** (0-1): Binary urgent status
-5. **Ripeness** (0-1): Binary ripeness status
-6. **Hearing count** (0-9): Number of previous hearings (normalized)
-
-### Reward Function
-
-- **Base scheduling**: +0.5 for taking action
-- **Disposal**: +10.0 for case disposal/settlement
-- **Progress**: +3.0 for case advancement
-- **Adjournment**: -3.0 penalty
-- **Urgency bonus**: +2.0 for urgent cases
-- **Ripeness penalty**: -4.0 for scheduling unripe cases  
-- **Long pending bonus**: +2.0 for cases >365 days old
-
-## Usage
-
-### Basic Training
-
-```python
-from rl import TabularQAgent, train_agent
-
-# Create agent
-agent = TabularQAgent(learning_rate=0.1, epsilon=0.3)
-
-# Train
-stats = train_agent(agent, episodes=50, cases_per_episode=500)
-
-# Save
-agent.save(Path("models/my_agent.pkl"))
-```
-
-### Configuration-Driven Training
-
-```bash
-# Use predefined config
-uv run python train_rl_agent.py --config configs/rl_training_fast.json
-
-# Override specific parameters  
-uv run python train_rl_agent.py --episodes 100 --learning-rate 0.2
-
-# Custom model name
-uv run python train_rl_agent.py --model-name "custom_agent.pkl"
-```
-
-### Integration with Simulation
-
-```python
-from scheduler.simulation.policies import RLPolicy
-
-# Use trained agent in simulation
-policy = RLPolicy(agent_path=Path("models/intensive_rl_agent.pkl"))
-
-# Or auto-load latest trained agent
-policy = RLPolicy()  # Automatically finds intensive_trained_rl_agent.pkl
-```
-
-## Configuration Files
-
-### Fast Training (`configs/rl_training_fast.json`)
-- 20 episodes, 200 cases/episode
-- Higher learning rate (0.2) and exploration (0.5)
-- Suitable for quick experiments
-
-### Intensive Training (`configs/rl_training_intensive.json`)  
-- 100 episodes, 1000 cases/episode
-- Balanced parameters for production training
-- Generates `intensive_rl_agent.pkl`
-
-## Performance
-
-Current results on 10,000 case dataset (90-day simulation):
-- **RL Agent**: 52.1% disposal rate
-- **Baseline**: 51.9% disposal rate
-- **Status**: Performance parity achieved
-
-## Hybrid Design
-
-The RL agent works within a **hybrid architecture**:
-
-1. **Rule-based filtering**: Maintains fairness and judicial constraints
-2. **RL prioritization**: Learns optimal case priority scoring
-3. **Deterministic allocation**: Respects courtroom capacity limits
-
-This ensures the system remains explainable and legally compliant while leveraging learned scheduling patterns.
-
-## Development Notes
-
-- State space: 44,000 theoretical states, ~100 typically explored
-- Training requires 10,000+ diverse cases for effective learning
-- Agent learns to match expert heuristics rather than exceed them
-- Suitable for research and proof-of-concept applications

rl/__init__.py

@@ -1,12 +0,0 @@
-"""RL-based court scheduling components.
-
-This module contains the reinforcement learning components for court scheduling:
-- Tabular Q-learning agent for case priority scoring
-- Training environment and loops  
-- Explainability tools for judicial decisions
-"""
-
-from .simple_agent import TabularQAgent
-from .training import train_agent, evaluate_agent, RLTrainingEnvironment
-
-__all__ = ['TabularQAgent', 'train_agent', 'evaluate_agent', 'RLTrainingEnvironment']

rl/config.py

@@ -1,115 +0,0 @@
-"""RL training configuration and hyperparameters.
-
-This module contains all configurable parameters for RL agent training,
-separate from domain constants and simulation settings.
-"""
-
-from dataclasses import dataclass
-
-
-@dataclass
-class RLTrainingConfig:
-    """Configuration for RL agent training.
-    
-    Hyperparameters that affect learning behavior and convergence.
-    """
-    # Training episodes
-    episodes: int = 100
-    cases_per_episode: int = 1000
-    episode_length_days: int = 60
-
-    # Courtroom + allocation constraints
-    courtrooms: int = 5
-    daily_capacity_per_courtroom: int = 151
-    cap_daily_allocations: bool = True
-    max_daily_allocations: int | None = None  # Optional hard cap (overrides computed capacity)
-    enforce_min_gap: bool = True
-    apply_judge_preferences: bool = True
-    
-    # Q-learning hyperparameters
-    learning_rate: float = 0.15
-    discount_factor: float = 0.95
-    
-    # Exploration strategy
-    initial_epsilon: float = 0.4
-    epsilon_decay: float = 0.99
-    min_epsilon: float = 0.05
-    
-    # Training data generation
-    training_seed: int = 42
-    stage_mix_auto: bool = True  # Use EDA-derived stage distribution
-    
-    def __post_init__(self):
-        """Validate configuration parameters."""
-        if not (0.0 < self.learning_rate <= 1.0):
-            raise ValueError(f"learning_rate must be in (0, 1], got {self.learning_rate}")
-        
-        if not (0.0 <= self.discount_factor <= 1.0):
-            raise ValueError(f"discount_factor must be in [0, 1], got {self.discount_factor}")
-        
-        if not (0.0 <= self.initial_epsilon <= 1.0):
-            raise ValueError(f"initial_epsilon must be in [0, 1], got {self.initial_epsilon}")
-        
-        if self.episodes < 1:
-            raise ValueError(f"episodes must be >= 1, got {self.episodes}")
-        
-        if self.cases_per_episode < 1:
-            raise ValueError(f"cases_per_episode must be >= 1, got {self.cases_per_episode}")
-
-        if self.courtrooms < 1:
-            raise ValueError(f"courtrooms must be >= 1, got {self.courtrooms}")
-
-        if self.daily_capacity_per_courtroom < 1:
-            raise ValueError(
-                f"daily_capacity_per_courtroom must be >= 1, got {self.daily_capacity_per_courtroom}"
-            )
-
-        if self.max_daily_allocations is not None and self.max_daily_allocations < 1:
-            raise ValueError(
-                f"max_daily_allocations must be >= 1 when provided, got {self.max_daily_allocations}"
-            )
-
-
-@dataclass
-class PolicyConfig:
-    """Configuration for scheduling policy behavior.
-    
-    Settings that affect how policies prioritize and filter cases.
-    """
-    # Minimum gap between hearings (days)
-    min_gap_days: int = 7  # From MIN_GAP_BETWEEN_HEARINGS in config.py
-    
-    # Maximum gap before alert (days)
-    max_gap_alert_days: int = 90  # From MAX_GAP_WITHOUT_ALERT
-    
-    # Old case threshold for priority boost (days)
-    old_case_threshold_days: int = 180
-    
-    # Ripeness filtering
-    skip_unripe_cases: bool = True
-    allow_old_unripe_cases: bool = True  # Allow scheduling if age > old_case_threshold
-    
-    def __post_init__(self):
-        """Validate configuration parameters."""
-        if self.min_gap_days < 0:
-            raise ValueError(f"min_gap_days must be >= 0, got {self.min_gap_days}")
-        
-        if self.max_gap_alert_days < self.min_gap_days:
-            raise ValueError(
-                f"max_gap_alert_days ({self.max_gap_alert_days}) must be >= "
-                f"min_gap_days ({self.min_gap_days})"
-            )
-
-
-# Default configurations
-DEFAULT_RL_TRAINING_CONFIG = RLTrainingConfig()
-DEFAULT_POLICY_CONFIG = PolicyConfig()
-
-# Quick demo configuration (for testing)
-QUICK_DEMO_RL_CONFIG = RLTrainingConfig(
-    episodes=20,
-    cases_per_episode=1000,
-    episode_length_days=45,
-    learning_rate=0.15,
-    initial_epsilon=0.4,
-)

rl/rewards.py

@@ -1,127 +0,0 @@
-"""Shared reward helper utilities for RL agents.
-
-The helper operates on episode-level statistics so that reward shaping
-reflects system-wide outcomes (disposal rate, gap compliance, urgent
-case latency, and fairness across cases).
-"""
-
-from __future__ import annotations
-
-from collections import defaultdict
-from dataclasses import dataclass, field
-from typing import Dict, Iterable, Optional
-
-import numpy as np
-
-from scheduler.core.case import Case
-
-
-@dataclass
-class EpisodeRewardHelper:
-    """Aggregates episode metrics and computes shaped rewards."""
-
-    total_cases: int
-    target_gap_days: int = 30
-    max_urgent_latency: int = 60
-    disposal_weight: float = 4.0
-    gap_weight: float = 1.5
-    urgent_weight: float = 2.0
-    fairness_weight: float = 1.0
-    _disposed_cases: int = 0
-    _hearing_counts: Dict[str, int] = field(default_factory=lambda: defaultdict(int))
-    _urgent_latencies: list[float] = field(default_factory=list)
-
-    def _base_outcome_reward(self, case: Case, was_scheduled: bool, hearing_outcome: str) -> float:
-        """Preserve the original per-case shaping signals."""
-
-        reward = 0.0
-        if not was_scheduled:
-            return reward
-
-        # Base scheduling reward (small positive for taking action)
-        reward += 0.5
-
-        # Hearing outcome rewards
-        lower_outcome = hearing_outcome.lower()
-        if "disposal" in lower_outcome or "judgment" in lower_outcome or "settlement" in lower_outcome:
-            reward += 10.0  # Major positive for disposal
-        elif "progress" in lower_outcome and "adjourn" not in lower_outcome:
-            reward += 3.0  # Progress without disposal
-        elif "adjourn" in lower_outcome:
-            reward -= 3.0  # Negative for adjournment
-
-        # Urgency bonus
-        if case.is_urgent:
-            reward += 2.0
-
-        # Ripeness penalty
-        if hasattr(case, "ripeness_status") and case.ripeness_status not in ["RIPE", "UNKNOWN"]:
-            reward -= 4.0
-
-        # Long pending bonus (>365 days)
-        if case.age_days and case.age_days > 365:
-            reward += 2.0
-
-        return reward
-
-    def _fairness_score(self) -> float:
-        """Reward higher uniformity in hearing distribution."""
-
-        counts: Iterable[int] = self._hearing_counts.values()
-        if not counts:
-            return 0.0
-
-        counts_array = np.array(list(counts), dtype=float)
-        mean = np.mean(counts_array)
-        if mean == 0:
-            return 0.0
-
-        dispersion = np.std(counts_array) / (mean + 1e-6)
-        # Lower dispersion -> better fairness. Convert to reward in [0, 1].
-        fairness = max(0.0, 1.0 - dispersion)
-        return fairness
-
-    def compute_case_reward(
-        self,
-        case: Case,
-        was_scheduled: bool,
-        hearing_outcome: str,
-        current_date,
-        previous_gap_days: Optional[int] = None,
-    ) -> float:
-        """Compute reward using both local and episode-level signals."""
-
-        reward = self._base_outcome_reward(case, was_scheduled, hearing_outcome)
-
-        if not was_scheduled:
-            return reward
-
-        # Track disposals
-        if "disposal" in hearing_outcome.lower() or getattr(case, "is_disposed", False):
-            self._disposed_cases += 1
-
-        # Track hearing counts for fairness
-        self._hearing_counts[case.case_id] = case.hearing_count or self._hearing_counts[case.case_id] + 1
-
-        # Track urgent latencies
-        if case.is_urgent:
-            self._urgent_latencies.append(case.age_days or 0)
-
-        # Episode-level components
-        disposal_rate = (self._disposed_cases / self.total_cases) if self.total_cases else 0.0
-        reward += self.disposal_weight * disposal_rate
-
-        if previous_gap_days is not None:
-            gap_score = max(0.0, 1.0 - (previous_gap_days / self.target_gap_days))
-            reward += self.gap_weight * gap_score
-
-        if self._urgent_latencies:
-            avg_latency = float(np.mean(self._urgent_latencies))
-            latency_score = max(0.0, 1.0 - (avg_latency / self.max_urgent_latency))
-            reward += self.urgent_weight * latency_score
-
-        fairness = self._fairness_score()
-        reward += self.fairness_weight * fairness
-
-        return reward
-

rl/simple_agent.py

@@ -1,291 +0,0 @@
-"""Tabular Q-learning agent for court case priority scoring.
-
-Implements the simplified RL approach described in RL_EXPLORATION_PLAN.md:
-- 6D state space per case
-- Binary action space (schedule/skip)
-- Tabular Q-learning with epsilon-greedy exploration
-"""
-
-import numpy as np
-import pickle
-from pathlib import Path
-from typing import Dict, Tuple, Optional, List
-from dataclasses import dataclass
-from collections import defaultdict
-
-from scheduler.core.case import Case
-
-
-@dataclass
-class CaseState:
-    """Expanded state representation for a case with environment context."""
-
-    stage_encoded: int      # 0-7 for different stages
-    age_days: float        # normalized 0-1
-    days_since_last: float # normalized 0-1
-    urgency: int           # 0 or 1
-    ripe: int              # 0 or 1
-    hearing_count: float   # normalized 0-1
-    capacity_ratio: float  # normalized 0-1 (remaining capacity for the day)
-    min_gap_days: int      # encoded min gap rule in effect
-    preference_score: float  # normalized 0-1 preference alignment
-
-    def to_tuple(self) -> Tuple[int, int, int, int, int, int, int, int, int]:
-        """Convert to tuple for use as dict key."""
-        return (
-            self.stage_encoded,
-            min(9, int(self.age_days * 20)),  # discretize to 20 bins, cap at 9
-            min(9, int(self.days_since_last * 20)),  # discretize to 20 bins, cap at 9
-            self.urgency,
-            self.ripe,
-            min(9, int(self.hearing_count * 20)),  # discretize to 20 bins, cap at 9
-            min(9, int(self.capacity_ratio * 10)),
-            min(30, self.min_gap_days),
-            min(9, int(self.preference_score * 10))
-        )
-
-
-class TabularQAgent:
-    """Tabular Q-learning agent for case priority scoring."""
-    
-    # Stage mapping based on config.py
-    STAGE_TO_ID = {
-        "PRE-ADMISSION": 0,
-        "ADMISSION": 1, 
-        "FRAMING OF CHARGES": 2,
-        "EVIDENCE": 3,
-        "ARGUMENTS": 4,
-        "INTERLOCUTORY APPLICATION": 5,
-        "SETTLEMENT": 6,
-        "ORDERS / JUDGMENT": 7,
-        "FINAL DISPOSAL": 8,
-        "OTHER": 9,
-        "NA": 10
-    }
-    
-    def __init__(self, learning_rate: float = 0.1, epsilon: float = 0.1, 
-                 discount: float = 0.95):
-        """Initialize tabular Q-learning agent.
-        
-        Args:
-            learning_rate: Q-learning step size
-            epsilon: Exploration probability
-            discount: Discount factor for future rewards
-        """
-        self.learning_rate = learning_rate
-        self.epsilon = epsilon
-        self.discount = discount
-        
-        # Q-table: state -> action -> Q-value
-        # Actions: 0 = skip, 1 = schedule
-        self.q_table: Dict[Tuple, Dict[int, float]] = defaultdict(lambda: {0: 0.0, 1: 0.0})
-        
-        # Statistics
-        self.states_visited = set()
-        self.total_updates = 0
-        
-    def extract_state(
-        self,
-        case: Case,
-        current_date,
-        *,
-        capacity_ratio: float = 1.0,
-        min_gap_days: int = 7,
-        preference_score: float = 0.0,
-    ) -> CaseState:
-        """Extract 6D state representation from a case.
-        
-        Args:
-            case: Case object
-            current_date: Current simulation date
-            
-        Returns:
-            CaseState representation
-        """
-        # Stage encoding
-        stage_id = self.STAGE_TO_ID.get(case.current_stage, 9)  # Default to "OTHER"
-        
-        # Age in days (normalized by max reasonable age of 2 years)
-        actual_age = max(0, case.age_days) if case.age_days is not None else max(0, (current_date - case.filed_date).days)
-        age_days = min(actual_age / (365 * 2), 1.0)
-        
-        # Days since last hearing (normalized by max reasonable gap of 180 days)
-        days_since = 0.0
-        if case.last_hearing_date:
-            days_gap = max(0, (current_date - case.last_hearing_date).days)
-            days_since = min(days_gap / 180, 1.0)
-        else:
-            # No previous hearing - use age as days since "last" hearing
-            days_since = min(actual_age / 180, 1.0)
-        
-        # Urgency flag
-        urgency = 1 if case.is_urgent else 0
-        
-        # Ripeness (assuming we have ripeness status)
-        ripe = 1 if hasattr(case, 'ripeness_status') and case.ripeness_status == "RIPE" else 0
-        
-        # Hearing count (normalized by reasonable max of 20 hearings)
-        hearing_count = min(case.hearing_count / 20, 1.0) if case.hearing_count else 0.0
-        
-        return CaseState(
-            stage_encoded=stage_id,
-            age_days=age_days,
-            days_since_last=days_since,
-            urgency=urgency,
-            ripe=ripe,
-            hearing_count=hearing_count,
-            capacity_ratio=max(0.0, min(1.0, capacity_ratio)),
-            min_gap_days=max(0, min_gap_days),
-            preference_score=max(0.0, min(1.0, preference_score))
-        )
-    
-    def get_action(self, state: CaseState, training: bool = False) -> int:
-        """Select action using epsilon-greedy policy.
-        
-        Args:
-            state: Current case state
-            training: Whether in training mode (enables exploration)
-            
-        Returns:
-            Action: 0 = skip, 1 = schedule
-        """
-        state_key = state.to_tuple()
-        self.states_visited.add(state_key)
-        
-        # Epsilon-greedy exploration during training
-        if training and np.random.random() < self.epsilon:
-            return np.random.choice([0, 1])
-        
-        # Greedy action selection
-        q_values = self.q_table[state_key]
-        if q_values[0] == q_values[1]:  # If tied, prefer scheduling (action 1)
-            return 1
-        return max(q_values, key=q_values.get)
-    
-    def get_priority_score(self, case: Case, current_date) -> float:
-        """Get priority score for a case (Q-value for schedule action).
-        
-        Args:
-            case: Case object
-            current_date: Current simulation date
-            
-        Returns:
-            Priority score (Q-value for action=1)
-        """
-        state = self.extract_state(case, current_date)
-        state_key = state.to_tuple()
-        return self.q_table[state_key][1]  # Q-value for schedule action
-    
-    def update_q_value(self, state: CaseState, action: int, reward: float, 
-                      next_state: Optional[CaseState] = None):
-        """Update Q-table using Q-learning rule.
-        
-        Args:
-            state: Current state
-            action: Action taken
-            reward: Reward received
-            next_state: Next state (optional, for terminal states)
-        """
-        state_key = state.to_tuple()
-        
-        # Q-learning update
-        old_q = self.q_table[state_key][action]
-        
-        if next_state is not None:
-            next_key = next_state.to_tuple()
-            max_next_q = max(self.q_table[next_key].values())
-            target = reward + self.discount * max_next_q
-        else:
-            # Terminal state
-            target = reward
-            
-        new_q = old_q + self.learning_rate * (target - old_q)
-        self.q_table[state_key][action] = new_q
-        self.total_updates += 1
-    
-    def compute_reward(self, case: Case, was_scheduled: bool, hearing_outcome: str) -> float:
-        """Compute reward based on the outcome as per RL plan.
-        
-        Reward function:
-        +2 if case progresses
-        -1 if adjourned  
-        +3 if urgent & scheduled
-        -2 if unripe & scheduled
-        +1 if long pending & scheduled
-        
-        Args:
-            case: Case object
-            was_scheduled: Whether case was scheduled
-            hearing_outcome: Outcome of the hearing
-            
-        Returns:
-            Reward value
-        """
-        reward = 0.0
-        
-        if was_scheduled:
-            # Base scheduling reward (small positive for taking action)
-            reward += 0.5
-            
-            # Hearing outcome rewards
-            if "disposal" in hearing_outcome.lower() or "judgment" in hearing_outcome.lower() or "settlement" in hearing_outcome.lower():
-                reward += 10.0  # Major positive for disposal
-            elif "progress" in hearing_outcome.lower() and "adjourn" not in hearing_outcome.lower():
-                reward += 3.0  # Progress without disposal
-            elif "adjourn" in hearing_outcome.lower():
-                reward -= 3.0  # Negative for adjournment
-            
-            # Urgency bonus
-            if case.is_urgent:
-                reward += 2.0
-                
-            # Ripeness penalty  
-            if hasattr(case, 'ripeness_status') and case.ripeness_status not in ["RIPE", "UNKNOWN"]:
-                reward -= 4.0
-                
-            # Long pending bonus (>365 days)
-            if case.age_days and case.age_days > 365:
-                reward += 2.0
-        
-        return reward
-    
-    def get_stats(self) -> Dict:
-        """Get agent statistics."""
-        return {
-            "states_visited": len(self.states_visited),
-            "total_updates": self.total_updates,
-            "q_table_size": len(self.q_table),
-            "epsilon": self.epsilon,
-            "learning_rate": self.learning_rate
-        }
-    
-    def save(self, path: Path):
-        """Save agent to file."""
-        agent_data = {
-            'q_table': dict(self.q_table),
-            'learning_rate': self.learning_rate,
-            'epsilon': self.epsilon,
-            'discount': self.discount,
-            'states_visited': self.states_visited,
-            'total_updates': self.total_updates
-        }
-        with open(path, 'wb') as f:
-            pickle.dump(agent_data, f)
-    
-    @classmethod
-    def load(cls, path: Path) -> 'TabularQAgent':
-        """Load agent from file."""
-        with open(path, 'rb') as f:
-            agent_data = pickle.load(f)
-        
-        agent = cls(
-            learning_rate=agent_data['learning_rate'],
-            epsilon=agent_data['epsilon'],
-            discount=agent_data['discount']
-        )
-        agent.q_table = defaultdict(lambda: {0: 0.0, 1: 0.0})
-        agent.q_table.update(agent_data['q_table'])
-        agent.states_visited = agent_data['states_visited']
-        agent.total_updates = agent_data['total_updates']
-        
-        return agent

rl/training.py

@@ -1,515 +0,0 @@
-"""Training pipeline for tabular Q-learning agent.
-
-Implements episodic training on generated case data to learn optimal
-case prioritization policies through simulation-based rewards.
-"""
-
-import numpy as np
-from pathlib import Path
-from typing import List, Tuple, Dict, Optional
-from datetime import date, datetime, timedelta
-import random
-
-from scheduler.data.case_generator import CaseGenerator
-from scheduler.data.param_loader import ParameterLoader
-from scheduler.core.case import Case, CaseStatus
-from scheduler.core.algorithm import SchedulingAlgorithm
-from scheduler.core.courtroom import Courtroom
-from scheduler.core.policy import SchedulerPolicy
-from scheduler.simulation.policies.readiness import ReadinessPolicy
-from scheduler.simulation.allocator import CourtroomAllocator, AllocationStrategy
-from scheduler.control.overrides import Override, OverrideType, JudgePreferences
-from .simple_agent import TabularQAgent, CaseState
-from .rewards import EpisodeRewardHelper
-from .config import (
-    RLTrainingConfig,
-    PolicyConfig,
-    DEFAULT_RL_TRAINING_CONFIG,
-    DEFAULT_POLICY_CONFIG,
-)
-
-
-class RLTrainingEnvironment:
-    """Training environment for RL agent using court simulation."""
-
-    def __init__(
-        self,
-        cases: List[Case],
-        start_date: date,
-        horizon_days: int = 90,
-        rl_config: RLTrainingConfig | None = None,
-        policy_config: PolicyConfig | None = None,
-        params_dir: Optional[Path] = None,
-    ):
-        """Initialize training environment.
-
-        Args:
-            cases: List of cases to simulate
-            start_date: Simulation start date
-            horizon_days: Training episode length in days
-            rl_config: RL-specific training constraints
-            policy_config: Policy knobs for ripeness/gap rules
-            params_dir: Directory with EDA parameters (uses latest if None)
-        """
-        self.cases = cases
-        self.start_date = start_date
-        self.horizon_days = horizon_days
-        self.current_date = start_date
-        self.episode_rewards = []
-        self.rl_config = rl_config or DEFAULT_RL_TRAINING_CONFIG
-        self.policy_config = policy_config or DEFAULT_POLICY_CONFIG
-        self.reward_helper = EpisodeRewardHelper(total_cases=len(cases))
-        self.param_loader = ParameterLoader(params_dir)
-
-        # Resources mirroring production defaults
-        self.courtrooms = [
-            Courtroom(
-                courtroom_id=i + 1,
-                judge_id=f"J{i+1:03d}",
-                daily_capacity=self.rl_config.daily_capacity_per_courtroom,
-            )
-            for i in range(self.rl_config.courtrooms)
-        ]
-        self.allocator = CourtroomAllocator(
-            num_courtrooms=self.rl_config.courtrooms,
-            per_courtroom_capacity=self.rl_config.daily_capacity_per_courtroom,
-            strategy=AllocationStrategy.LOAD_BALANCED,
-        )
-        self.policy: SchedulerPolicy = ReadinessPolicy()
-        self.algorithm = SchedulingAlgorithm(
-            policy=self.policy,
-            allocator=self.allocator,
-            min_gap_days=self.policy_config.min_gap_days if self.rl_config.enforce_min_gap else 0,
-        )
-        self.preferences = self._build_preferences()
-
-    def _build_preferences(self) -> Optional[JudgePreferences]:
-        """Synthetic judge preferences for training context."""
-        if not self.rl_config.apply_judge_preferences:
-            return None
-
-        capacity_overrides = {room.courtroom_id: room.daily_capacity for room in self.courtrooms}
-        return JudgePreferences(
-            judge_id="RL-JUDGE",
-            capacity_overrides=capacity_overrides,
-            case_type_preferences={
-                "Monday": ["RSA"],
-                "Tuesday": ["CCC"],
-                "Wednesday": ["NI ACT"],
-            },
-        )
-    def reset(self) -> List[Case]:
-        """Reset environment for new training episode.
-
-        Note: In practice, train_agent() generates fresh cases per episode,
-        so case state doesn't need resetting. This method just resets
-        environment state (date, rewards).
-        """
-        self.current_date = self.start_date
-        self.episode_rewards = []
-        self.reward_helper = EpisodeRewardHelper(total_cases=len(self.cases))
-        return self.cases.copy()
-
-    def capacity_ratio(self, remaining_slots: int) -> float:
-        """Proportion of courtroom capacity still available for the day."""
-        total_capacity = self.rl_config.courtrooms * self.rl_config.daily_capacity_per_courtroom
-        return max(0.0, min(1.0, remaining_slots / total_capacity)) if total_capacity else 0.0
-
-    def preference_score(self, case: Case) -> float:
-        """Return 1.0 when case_type aligns with day-of-week preference, else 0."""
-        if not self.preferences:
-            return 0.0
-
-        day_name = self.current_date.strftime("%A")
-        preferred_types = self.preferences.case_type_preferences.get(day_name, [])
-        return 1.0 if case.case_type in preferred_types else 0.0
-
-    def step(self, agent_decisions: Dict[str, int]) -> Tuple[List[Case], Dict[str, float], bool]:
-        """Execute one day of simulation with agent decisions via SchedulingAlgorithm."""
-        rewards: Dict[str, float] = {}
-
-        # Convert agent schedule actions into priority overrides
-        overrides: List[Override] = []
-        priority_boost = 1.0
-        for case in self.cases:
-            if agent_decisions.get(case.case_id) == 1:
-                overrides.append(
-                    Override(
-                        override_id=f"rl-{case.case_id}-{self.current_date.isoformat()}",
-                        override_type=OverrideType.PRIORITY,
-                        case_id=case.case_id,
-                        judge_id="RL-JUDGE",
-                        timestamp=datetime.combine(self.current_date, datetime.min.time()),
-                        new_priority=case.get_priority_score() + priority_boost,
-                    )
-                )
-                priority_boost += 0.1  # keep relative ordering stable
-
-        # Run scheduling algorithm (capacity, ripeness, min-gap enforced)
-        result = self.algorithm.schedule_day(
-            cases=self.cases,
-            courtrooms=self.courtrooms,
-            current_date=self.current_date,
-            overrides=overrides or None,
-            preferences=self.preferences,
-        )
-
-        # Flatten scheduled cases
-        scheduled_cases = [c for cases in result.scheduled_cases.values() for c in cases]
-        # Simulate hearing outcomes for scheduled cases
-        for case in scheduled_cases:
-            if case.is_disposed:
-                continue
-
-            outcome = self._simulate_hearing_outcome(case)
-            was_heard = "heard" in outcome.lower()
-
-            # Track gap relative to previous hearing for reward shaping
-            previous_gap = None
-            if case.last_hearing_date:
-                previous_gap = max(0, (self.current_date - case.last_hearing_date).days)
-
-            case.record_hearing(self.current_date, was_heard=was_heard, outcome=outcome)
-
-            if was_heard:
-                if outcome in ["FINAL DISPOSAL", "SETTLEMENT", "NA"]:
-                    case.status = CaseStatus.DISPOSED
-                    case.disposal_date = self.current_date
-                elif outcome != "ADJOURNED":
-                    case.current_stage = outcome
-
-            # Compute reward using shared reward helper
-            rewards[case.case_id] = self.reward_helper.compute_case_reward(
-                case,
-                was_scheduled=True,
-                hearing_outcome=outcome,
-                current_date=self.current_date,
-                previous_gap_days=previous_gap,
-            )
-        # Update case ages
-        for case in self.cases:
-            case.update_age(self.current_date)
-
-        # Move to next day
-        self.current_date += timedelta(days=1)
-        episode_done = (self.current_date - self.start_date).days >= self.horizon_days
-
-        return self.cases, rewards, episode_done
-
-    def _simulate_hearing_outcome(self, case: Case) -> str:
-        """Simulate hearing outcome using EDA-derived parameters.
-        
-        Uses param_loader for adjournment probabilities and stage transitions
-        instead of hardcoded values, ensuring training aligns with production.
-        """
-        current_stage = case.current_stage
-        case_type = case.case_type
-
-        # Query EDA-derived adjournment probability
-        p_adjourn = self.param_loader.get_adjournment_prob(current_stage, case_type)
-        
-        # Sample adjournment
-        if random.random() < p_adjourn:
-            return "ADJOURNED"
-
-        # Case progresses - determine next stage using EDA-derived transitions
-        # Terminal stages lead to disposal
-        if current_stage in ["ORDERS / JUDGMENT", "FINAL DISPOSAL"]:
-            return "FINAL DISPOSAL"
-        
-        # Sample next stage using cumulative transition probabilities
-        transitions = self.param_loader.get_stage_transitions_fast(current_stage)
-        if not transitions:
-            # No transition data - use fallback progression
-            return self._fallback_stage_progression(current_stage)
-        
-        # Sample from cumulative probabilities
-        rand_val = random.random()
-        for next_stage, cum_prob in transitions:
-            if rand_val <= cum_prob:
-                return next_stage
-        
-        # Fallback if sampling fails (shouldn't happen with normalized probs)
-        return transitions[-1][0] if transitions else current_stage
-    
-    def _fallback_stage_progression(self, current_stage: str) -> str:
-        """Fallback stage progression when no transition data available."""
-        progression_map = {
-            "PRE-ADMISSION": "ADMISSION",
-            "ADMISSION": "EVIDENCE",
-            "FRAMING OF CHARGES": "EVIDENCE",
-            "EVIDENCE": "ARGUMENTS",
-            "ARGUMENTS": "ORDERS / JUDGMENT",
-            "INTERLOCUTORY APPLICATION": "ARGUMENTS",
-            "SETTLEMENT": "FINAL DISPOSAL",
-        }
-        return progression_map.get(current_stage, "ARGUMENTS")
-
-
-def train_agent(
-    agent: TabularQAgent,
-    rl_config: RLTrainingConfig = DEFAULT_RL_TRAINING_CONFIG,
-    policy_config: PolicyConfig = DEFAULT_POLICY_CONFIG,
-    params_dir: Optional[Path] = None,
-    verbose: bool = True,
-) -> Dict:
-    """Train RL agent using episodic simulation with courtroom constraints.
-    
-    Args:
-        agent: TabularQAgent to train
-        rl_config: RL training configuration
-        policy_config: Policy configuration
-        params_dir: Directory with EDA parameters (uses latest if None)
-        verbose: Print training progress
-    """
-    config = rl_config or DEFAULT_RL_TRAINING_CONFIG
-    policy_cfg = policy_config or DEFAULT_POLICY_CONFIG
-
-    # Align agent hyperparameters with config
-    agent.learning_rate = config.learning_rate
-    agent.discount = config.discount_factor
-    agent.epsilon = config.initial_epsilon
-
-    training_stats = {
-        "episodes": [],
-        "total_rewards": [],
-        "disposal_rates": [],
-        "states_explored": [],
-        "q_updates": [],
-    }
-
-    if verbose:
-        print(f"Training RL agent for {config.episodes} episodes...")
-
-    for episode in range(config.episodes):
-        # Generate fresh cases for this episode
-        start_date = date(2024, 1, 1) + timedelta(days=episode * 10)
-        end_date = start_date + timedelta(days=30)
-
-        generator = CaseGenerator(
-            start=start_date,
-            end=end_date,
-            seed=config.training_seed + episode,
-        )
-        cases = generator.generate(config.cases_per_episode, stage_mix_auto=config.stage_mix_auto)
-
-        # Initialize training environment
-        env = RLTrainingEnvironment(
-            cases,
-            start_date,
-            config.episode_length_days,
-            rl_config=config,
-            policy_config=policy_cfg,
-            params_dir=params_dir,
-        )
-
-        # Reset environment
-        episode_cases = env.reset()
-        episode_reward = 0.0
-
-        total_capacity = config.courtrooms * config.daily_capacity_per_courtroom
-
-        # Run episode
-        for _ in range(config.episode_length_days):
-            # Get eligible cases (not disposed, basic filtering)
-            eligible_cases = [c for c in episode_cases if not c.is_disposed]
-            if not eligible_cases:
-                break
-
-            # Agent makes decisions for each case
-            agent_decisions = {}
-            case_states = {}
-
-            daily_cap = config.max_daily_allocations or total_capacity
-            if not config.cap_daily_allocations:
-                daily_cap = len(eligible_cases)
-            remaining_slots = min(daily_cap, total_capacity) if config.cap_daily_allocations else daily_cap
-
-            for case in eligible_cases[:daily_cap]:
-                cap_ratio = env.capacity_ratio(remaining_slots if remaining_slots else total_capacity)
-                pref_score = env.preference_score(case)
-                state = agent.extract_state(
-                    case,
-                    env.current_date,
-                    capacity_ratio=cap_ratio,
-                    min_gap_days=policy_cfg.min_gap_days if config.enforce_min_gap else 0,
-                    preference_score=pref_score,
-                )
-                action = agent.get_action(state, training=True)
-
-                if config.cap_daily_allocations and action == 1 and remaining_slots <= 0:
-                    action = 0
-                elif action == 1 and config.cap_daily_allocations:
-                    remaining_slots = max(0, remaining_slots - 1)
-
-                agent_decisions[case.case_id] = action
-                case_states[case.case_id] = state
-
-            # Environment step
-            _, rewards, done = env.step(agent_decisions)
-
-            # Update Q-values based on rewards
-            for case_id, reward in rewards.items():
-                if case_id in case_states:
-                    state = case_states[case_id]
-                    action = agent_decisions.get(case_id, 0)
-
-                    agent.update_q_value(state, action, reward)
-                    episode_reward += reward
-
-            if done:
-                break
-
-        # Compute episode statistics
-        disposed_count = sum(1 for c in episode_cases if c.is_disposed)
-        disposal_rate = disposed_count / len(episode_cases) if episode_cases else 0.0
-
-        # Record statistics
-        training_stats["episodes"].append(episode)
-        training_stats["total_rewards"].append(episode_reward)
-        training_stats["disposal_rates"].append(disposal_rate)
-        training_stats["states_explored"].append(len(agent.states_visited))
-        training_stats["q_updates"].append(agent.total_updates)
-
-        # Decay exploration
-        agent.epsilon = max(config.min_epsilon, agent.epsilon * config.epsilon_decay)
-
-        if verbose and (episode + 1) % 10 == 0:
-            print(
-                f"Episode {episode + 1}/{config.episodes}: "
-                f"Reward={episode_reward:.1f}, "
-                f"Disposal={disposal_rate:.1%}, "
-                f"States={len(agent.states_visited)}, "
-                f"Epsilon={agent.epsilon:.3f}"
-            )
-
-    if verbose:
-        final_stats = agent.get_stats()
-        print(f"\nTraining complete!")
-        print(f"States explored: {final_stats['states_visited']}")
-        print(f"Q-table size: {final_stats['q_table_size']}")
-        print(f"Total updates: {final_stats['total_updates']}")
-
-    return training_stats
-
-
-def evaluate_agent(
-    agent: TabularQAgent,
-    test_cases: List[Case],
-    episodes: Optional[int] = None,
-    episode_length: Optional[int] = None,
-    rl_config: RLTrainingConfig = DEFAULT_RL_TRAINING_CONFIG,
-    policy_config: PolicyConfig = DEFAULT_POLICY_CONFIG,
-    params_dir: Optional[Path] = None,
-) -> Dict:
-    """Evaluate trained agent performance.
-    
-    Args:
-        agent: Trained TabularQAgent to evaluate
-        test_cases: Cases to evaluate on
-        episodes: Number of evaluation episodes (default 10)
-        episode_length: Length of each episode in days
-        rl_config: RL configuration
-        policy_config: Policy configuration
-        params_dir: Directory with EDA parameters (uses latest if None)
-    """
-    # Set agent to evaluation mode (no exploration)
-    original_epsilon = agent.epsilon
-    agent.epsilon = 0.0
-
-    config = rl_config or DEFAULT_RL_TRAINING_CONFIG
-    policy_cfg = policy_config or DEFAULT_POLICY_CONFIG
-
-    evaluation_stats = {
-        "disposal_rates": [],
-        "total_hearings": [],
-        "avg_hearing_to_disposal": [],
-        "utilization": [],
-    }
-
-    eval_episodes = episodes if episodes is not None else 10
-    eval_length = episode_length if episode_length is not None else config.episode_length_days
-
-    print(f"Evaluating agent on {eval_episodes} test episodes...")
-
-    total_capacity = config.courtrooms * config.daily_capacity_per_courtroom
-
-    for episode in range(eval_episodes):
-        start_date = date(2024, 6, 1) + timedelta(days=episode * 10)
-        env = RLTrainingEnvironment(
-            test_cases.copy(),
-            start_date,
-            eval_length,
-            rl_config=config,
-            policy_config=policy_cfg,
-            params_dir=params_dir,
-        )
-
-        episode_cases = env.reset()
-        total_hearings = 0
-
-        # Run evaluation episode
-        for _ in range(eval_length):
-            eligible_cases = [c for c in episode_cases if not c.is_disposed]
-            if not eligible_cases:
-                break
-
-            daily_cap = config.max_daily_allocations or total_capacity
-            remaining_slots = min(daily_cap, total_capacity) if config.cap_daily_allocations else len(eligible_cases)
-
-            # Agent makes decisions (no exploration)
-            agent_decisions = {}
-            for case in eligible_cases[:daily_cap]:
-                cap_ratio = env.capacity_ratio(remaining_slots if remaining_slots else total_capacity)
-                pref_score = env.preference_score(case)
-                state = agent.extract_state(
-                    case,
-                    env.current_date,
-                    capacity_ratio=cap_ratio,
-                    min_gap_days=policy_cfg.min_gap_days if config.enforce_min_gap else 0,
-                    preference_score=pref_score,
-                )
-                action = agent.get_action(state, training=False)
-                if config.cap_daily_allocations and action == 1 and remaining_slots <= 0:
-                    action = 0
-                elif action == 1 and config.cap_daily_allocations:
-                    remaining_slots = max(0, remaining_slots - 1)
-
-                agent_decisions[case.case_id] = action
-
-            # Environment step
-            _, rewards, done = env.step(agent_decisions)
-            total_hearings += len([r for r in rewards.values() if r != 0])
-
-            if done:
-                break
-
-        # Compute metrics
-        disposed_count = sum(1 for c in episode_cases if c.is_disposed)
-        disposal_rate = disposed_count / len(episode_cases)
-
-        disposed_cases = [c for c in episode_cases if c.is_disposed]
-        avg_hearings = np.mean([c.hearing_count for c in disposed_cases]) if disposed_cases else 0
-
-        evaluation_stats["disposal_rates"].append(disposal_rate)
-        evaluation_stats["total_hearings"].append(total_hearings)
-        evaluation_stats["avg_hearing_to_disposal"].append(avg_hearings)
-        evaluation_stats["utilization"].append(total_hearings / (eval_length * total_capacity))
-
-    # Restore original epsilon
-    agent.epsilon = original_epsilon
-
-    # Compute summary statistics
-    summary = {
-        "mean_disposal_rate": np.mean(evaluation_stats["disposal_rates"]),
-        "std_disposal_rate": np.std(evaluation_stats["disposal_rates"]),
-        "mean_utilization": np.mean(evaluation_stats["utilization"]),
-        "mean_hearings_to_disposal": np.mean(evaluation_stats["avg_hearing_to_disposal"]),
-    }
-
-    print("Evaluation complete:")
-    print(f"Mean disposal rate: {summary['mean_disposal_rate']:.1%} ± {summary['std_disposal_rate']:.1%}")
-    print(f"Mean utilization: {summary['mean_utilization']:.1%}")
-    print(f"Avg hearings to disposal: {summary['mean_hearings_to_disposal']:.1f}")
-
-    return summary

run_comprehensive_sweep.ps1

@@ -1,316 +0,0 @@
-# Comprehensive Parameter Sweep for Court Scheduling System
-# Runs multiple scenarios × multiple policies × multiple seeds
-
-Write-Host "================================================" -ForegroundColor Cyan
-Write-Host "COMPREHENSIVE PARAMETER SWEEP" -ForegroundColor Cyan
-Write-Host "================================================" -ForegroundColor Cyan
-Write-Host ""
-
-$ErrorActionPreference = "Stop"
-$results = @()
-
-# Configuration matrix
-$scenarios = @(
-    @{
-        name = "baseline_10k_2year"
-        cases = 10000
-        seed = 42
-        days = 500
-        description = "2-year simulation: 10k cases, ~500 working days (HACKATHON REQUIREMENT)"
-    },
-    @{
-        name = "baseline_10k"
-        cases = 10000
-        seed = 42
-        days = 200
-        description = "Baseline: 10k cases, balanced distribution"
-    },
-    @{
-        name = "baseline_10k_seed2"
-        cases = 10000
-        seed = 123
-        days = 200
-        description = "Baseline replica with different seed"
-    },
-    @{
-        name = "baseline_10k_seed3"
-        cases = 10000
-        seed = 456
-        days = 200
-        description = "Baseline replica with different seed"
-    },
-    @{
-        name = "small_5k"
-        cases = 5000
-        seed = 42
-        days = 200
-        description = "Small court: 5k cases"
-    },
-    @{
-        name = "large_15k"
-        cases = 15000
-        seed = 42
-        days = 200
-        description = "Large backlog: 15k cases"
-    },
-    @{
-        name = "xlarge_20k"
-        cases = 20000
-        seed = 42
-        days = 150
-        description = "Extra large: 20k cases, capacity stress"
-    }
-)
-
-$policies = @("fifo", "age", "readiness")
-
-Write-Host "Configuration:" -ForegroundColor Yellow
-Write-Host "  Scenarios: $($scenarios.Count)" -ForegroundColor White
-Write-Host "  Policies: $($policies.Count)" -ForegroundColor White
-Write-Host "  Total simulations: $($scenarios.Count * $policies.Count)" -ForegroundColor White
-Write-Host ""
-
-$totalRuns = $scenarios.Count * $policies.Count
-$currentRun = 0
-
-# Create results directory
-$timestamp = Get-Date -Format "yyyyMMdd_HHmmss"
-$resultsDir = "data\comprehensive_sweep_$timestamp"
-New-Item -ItemType Directory -Path $resultsDir -Force | Out-Null
-
-# Generate datasets
-Write-Host "Step 1: Generating datasets..." -ForegroundColor Cyan
-$datasetDir = "$resultsDir\datasets"
-New-Item -ItemType Directory -Path $datasetDir -Force | Out-Null
-
-foreach ($scenario in $scenarios) {
-    Write-Host "  Generating $($scenario.name)..." -NoNewline
-    $datasetPath = "$datasetDir\$($scenario.name)_cases.csv"
-    
-    & uv run python main.py generate --cases $scenario.cases --seed $scenario.seed --output $datasetPath > $null
-    
-    if ($LASTEXITCODE -eq 0) {
-        Write-Host " OK" -ForegroundColor Green
-    } else {
-        Write-Host " FAILED" -ForegroundColor Red
-        exit 1
-    }
-}
-
-Write-Host ""
-Write-Host "Step 2: Running simulations..." -ForegroundColor Cyan
-
-foreach ($scenario in $scenarios) {
-    $datasetPath = "$datasetDir\$($scenario.name)_cases.csv"
-    
-    foreach ($policy in $policies) {
-        $currentRun++
-        $runName = "$($scenario.name)_$policy"
-        $logDir = "$resultsDir\$runName"
-        
-        $progress = [math]::Round(($currentRun / $totalRuns) * 100, 1)
-        Write-Host "[$currentRun/$totalRuns - $progress%] " -NoNewline -ForegroundColor Yellow
-        Write-Host "$runName" -NoNewline -ForegroundColor White
-        Write-Host " ($($scenario.days) days)..." -NoNewline -ForegroundColor Gray
-        
-        $startTime = Get-Date
-        
-        & uv run python main.py simulate `
-            --days $scenario.days `
-            --cases $datasetPath `
-            --policy $policy `
-            --log-dir $logDir `
-            --seed $scenario.seed > $null
-        
-        $endTime = Get-Date
-        $duration = ($endTime - $startTime).TotalSeconds
-        
-        if ($LASTEXITCODE -eq 0) {
-            Write-Host " OK " -ForegroundColor Green -NoNewline
-            Write-Host "($([math]::Round($duration, 1))s)" -ForegroundColor Gray
-            
-            # Parse report
-            $reportPath = "$logDir\report.txt"
-            if (Test-Path $reportPath) {
-                $reportContent = Get-Content $reportPath -Raw
-                
-                # Extract metrics using regex
-                if ($reportContent -match 'Cases disposed: (\d+)') {
-                    $disposed = [int]$matches[1]
-                }
-                if ($reportContent -match 'Disposal rate: ([\d.]+)%') {
-                    $disposalRate = [double]$matches[1]
-                }
-                if ($reportContent -match 'Gini coefficient: ([\d.]+)') {
-                    $gini = [double]$matches[1]
-                }
-                if ($reportContent -match 'Court utilization: ([\d.]+)%') {
-                    $utilization = [double]$matches[1]
-                }
-                if ($reportContent -match 'Total hearings: ([\d,]+)') {
-                    $hearings = $matches[1] -replace ',', ''
-                }
-                
-                $results += [PSCustomObject]@{
-                    Scenario = $scenario.name
-                    Policy = $policy
-                    Cases = $scenario.cases
-                    Days = $scenario.days
-                    Seed = $scenario.seed
-                    Disposed = $disposed
-                    DisposalRate = $disposalRate
-                    Gini = $gini
-                    Utilization = $utilization
-                    Hearings = $hearings
-                    Duration = [math]::Round($duration, 1)
-                }
-            }
-        } else {
-            Write-Host " FAILED" -ForegroundColor Red
-        }
-    }
-}
-
-Write-Host ""
-Write-Host "Step 3: Generating summary..." -ForegroundColor Cyan
-
-# Export results to CSV
-$resultsCSV = "$resultsDir\summary_results.csv"
-$results | Export-Csv -Path $resultsCSV -NoTypeInformation
-
-Write-Host "  Results saved to: $resultsCSV" -ForegroundColor Green
-
-# Generate markdown summary
-$summaryMD = "$resultsDir\SUMMARY.md"
-$markdown = @"
-# Comprehensive Simulation Results
-
-**Generated**: $(Get-Date -Format "yyyy-MM-dd HH:mm:ss")
-**Total Simulations**: $totalRuns
-**Scenarios**: $($scenarios.Count)
-**Policies**: $($policies.Count)
-
-## Results Matrix
-
-### Disposal Rate (%)
-
-| Scenario | FIFO | Age | Readiness | Best |
-|----------|------|-----|-----------|------|
-"@
-
-foreach ($scenario in $scenarios) {
-    $fifo = ($results | Where-Object { $_.Scenario -eq $scenario.name -and $_.Policy -eq "fifo" }).DisposalRate
-    $age = ($results | Where-Object { $_.Scenario -eq $scenario.name -and $_.Policy -eq "age" }).DisposalRate
-    $readiness = ($results | Where-Object { $_.Scenario -eq $scenario.name -and $_.Policy -eq "readiness" }).DisposalRate
-    
-    $best = [math]::Max($fifo, [math]::Max($age, $readiness))
-    $bestPolicy = if ($fifo -eq $best) { "FIFO" } elseif ($age -eq $best) { "Age" } else { "**Readiness**" }
-    
-    $markdown += "`n| $($scenario.name) | $fifo | $age | **$readiness** | $bestPolicy |"
-}
-
-$markdown += @"
-
-
-### Gini Coefficient (Fairness)
-
-| Scenario | FIFO | Age | Readiness | Best |
-|----------|------|-----|-----------|------|
-"@
-
-foreach ($scenario in $scenarios) {
-    $fifo = ($results | Where-Object { $_.Scenario -eq $scenario.name -and $_.Policy -eq "fifo" }).Gini
-    $age = ($results | Where-Object { $_.Scenario -eq $scenario.name -and $_.Policy -eq "age" }).Gini
-    $readiness = ($results | Where-Object { $_.Scenario -eq $scenario.name -and $_.Policy -eq "readiness" }).Gini
-    
-    $best = [math]::Min($fifo, [math]::Min($age, $readiness))
-    $bestPolicy = if ($fifo -eq $best) { "FIFO" } elseif ($age -eq $best) { "Age" } else { "**Readiness**" }
-    
-    $markdown += "`n| $($scenario.name) | $fifo | $age | **$readiness** | $bestPolicy |"
-}
-
-$markdown += @"
-
-
-### Utilization (%)
-
-| Scenario | FIFO | Age | Readiness | Best |
-|----------|------|-----|-----------|------|
-"@
-
-foreach ($scenario in $scenarios) {
-    $fifo = ($results | Where-Object { $_.Scenario -eq $scenario.name -and $_.Policy -eq "fifo" }).Utilization
-    $age = ($results | Where-Object { $_.Scenario -eq $scenario.name -and $_.Policy -eq "age" }).Utilization
-    $readiness = ($results | Where-Object { $_.Scenario -eq $scenario.name -and $_.Policy -eq "readiness" }).Utilization
-    
-    $best = [math]::Max($fifo, [math]::Max($age, $readiness))
-    $bestPolicy = if ($fifo -eq $best) { "FIFO" } elseif ($age -eq $best) { "Age" } else { "**Readiness**" }
-    
-    $markdown += "`n| $($scenario.name) | $fifo | $age | **$readiness** | $bestPolicy |"
-}
-
-$markdown += @"
-
-
-## Statistical Summary
-
-### Our Algorithm (Readiness) Performance
-
-"@
-
-$readinessResults = $results | Where-Object { $_.Policy -eq "readiness" }
-$avgDisposal = ($readinessResults.DisposalRate | Measure-Object -Average).Average
-$stdDisposal = [math]::Sqrt((($readinessResults.DisposalRate | ForEach-Object { [math]::Pow($_ - $avgDisposal, 2) }) | Measure-Object -Average).Average)
-$minDisposal = ($readinessResults.DisposalRate | Measure-Object -Minimum).Minimum
-$maxDisposal = ($readinessResults.DisposalRate | Measure-Object -Maximum).Maximum
-
-$markdown += @"
-
-- **Mean Disposal Rate**: $([math]::Round($avgDisposal, 1))%
-- **Std Dev**: $([math]::Round($stdDisposal, 2))%
-- **Min**: $minDisposal%
-- **Max**: $maxDisposal%
-- **Coefficient of Variation**: $([math]::Round(($stdDisposal / $avgDisposal) * 100, 1))%
-
-### Performance Comparison (Average across all scenarios)
-
-| Metric | FIFO | Age | Readiness | Advantage |
-|--------|------|-----|-----------|-----------|
-"@
-
-$avgDisposalFIFO = ($results | Where-Object { $_.Policy -eq "fifo" } | Measure-Object -Property DisposalRate -Average).Average
-$avgDisposalAge = ($results | Where-Object { $_.Policy -eq "age" } | Measure-Object -Property DisposalRate -Average).Average
-$avgDisposalReadiness = ($results | Where-Object { $_.Policy -eq "readiness" } | Measure-Object -Property DisposalRate -Average).Average
-$advDisposal = $avgDisposalReadiness - [math]::Max($avgDisposalFIFO, $avgDisposalAge)
-
-$avgGiniFIFO = ($results | Where-Object { $_.Policy -eq "fifo" } | Measure-Object -Property Gini -Average).Average
-$avgGiniAge = ($results | Where-Object { $_.Policy -eq "age" } | Measure-Object -Property Gini -Average).Average
-$avgGiniReadiness = ($results | Where-Object { $_.Policy -eq "readiness" } | Measure-Object -Property Gini -Average).Average
-$advGini = [math]::Min($avgGiniFIFO, $avgGiniAge) - $avgGiniReadiness
-
-$markdown += @"
-
-| **Disposal Rate** | $([math]::Round($avgDisposalFIFO, 1))% | $([math]::Round($avgDisposalAge, 1))% | **$([math]::Round($avgDisposalReadiness, 1))%** | +$([math]::Round($advDisposal, 1))% |
-| **Gini** | $([math]::Round($avgGiniFIFO, 3)) | $([math]::Round($avgGiniAge, 3)) | **$([math]::Round($avgGiniReadiness, 3))** | -$([math]::Round($advGini, 3)) (better) |
-
-## Files
-
-- Raw data: `summary_results.csv`
-- Individual reports: `<scenario>_<policy>/report.txt`
-- Datasets: `datasets/<scenario>_cases.csv`
-
----
-Generated by comprehensive_sweep.ps1
-"@
-
-$markdown | Out-File -FilePath $summaryMD -Encoding UTF8
-
-Write-Host "  Summary saved to: $summaryMD" -ForegroundColor Green
-Write-Host ""
-
-Write-Host "================================================" -ForegroundColor Cyan
-Write-Host "SWEEP COMPLETE!" -ForegroundColor Green
-Write-Host "================================================" -ForegroundColor Cyan
-Write-Host "Results directory: $resultsDir" -ForegroundColor Yellow
-Write-Host "Total duration: $([math]::Round(($results | Measure-Object -Property Duration -Sum).Sum / 60, 1)) minutes" -ForegroundColor White
-Write-Host ""

runs/baseline/report.txt

@@ -1,56 +0,0 @@
-================================================================================
-SIMULATION REPORT
-================================================================================
-
-Configuration:
-  Cases: 3000
-  Days simulated: 30
-  Policy: readiness
-  Horizon end: 2024-05-09
-
-Hearing Metrics:
-  Total hearings: 8,671
-  Heard: 5,355 (61.8%)
-  Adjourned: 3,316 (38.2%)
-
-Disposal Metrics:
-  Cases disposed: 320
-  Disposal rate: 10.7%
-  Gini coefficient: 0.190
-
-Disposal Rates by Case Type:
-  CA  :   73/ 587 ( 12.4%)
-  CCC :   57/ 334 ( 17.1%)
-  CMP :    6/  86 (  7.0%)
-  CP  :   46/ 294 ( 15.6%)
-  CRP :   61/ 612 ( 10.0%)
-  RFA :   49/ 519 (  9.4%)
-  RSA :   28/ 568 (  4.9%)
-
-Efficiency Metrics:
-  Court utilization: 38.3%
-  Avg hearings/day: 289.0
-
-Ripeness Impact:
-  Transitions: 0
-  Cases filtered (unripe): 1,680
-  Filter rate: 16.2%
-
-Final Ripeness Distribution:
-  RIPE: 2624 (97.9%)
-  UNRIPE_DEPENDENT: 19 (0.7%)
-  UNRIPE_SUMMONS: 37 (1.4%)
-
-Courtroom Allocation:
-  Strategy: load_balanced
-  Load balance fairness (Gini): 0.002
-  Avg daily load: 57.8 cases
-  Allocation changes: 4,624
-  Capacity rejections: 0
-
-  Courtroom-wise totals:
-    Courtroom 1: 1,740 cases (58.0/day)
-    Courtroom 2: 1,737 cases (57.9/day)
-    Courtroom 3: 1,736 cases (57.9/day)
-    Courtroom 4: 1,732 cases (57.7/day)
-    Courtroom 5: 1,726 cases (57.5/day)

runs/baseline_comparison/report.txt

@@ -1,56 +0,0 @@
-================================================================================
-SIMULATION REPORT
-================================================================================
-
-Configuration:
-  Cases: 3000
-  Days simulated: 60
-  Policy: readiness
-  Horizon end: 2024-06-20
-
-Hearing Metrics:
-  Total hearings: 16,137
-  Heard: 9,981 (61.9%)
-  Adjourned: 6,156 (38.1%)
-
-Disposal Metrics:
-  Cases disposed: 708
-  Disposal rate: 23.6%
-  Gini coefficient: 0.195
-
-Disposal Rates by Case Type:
-  CA  :  159/ 587 ( 27.1%)
-  CCC :  133/ 334 ( 39.8%)
-  CMP :   14/  86 ( 16.3%)
-  CP  :  105/ 294 ( 35.7%)
-  CRP :  142/ 612 ( 23.2%)
-  RFA :   77/ 519 ( 14.8%)
-  RSA :   78/ 568 ( 13.7%)
-
-Efficiency Metrics:
-  Court utilization: 35.6%
-  Avg hearings/day: 268.9
-
-Ripeness Impact:
-  Transitions: 0
-  Cases filtered (unripe): 3,360
-  Filter rate: 17.2%
-
-Final Ripeness Distribution:
-  RIPE: 2236 (97.6%)
-  UNRIPE_DEPENDENT: 19 (0.8%)
-  UNRIPE_SUMMONS: 37 (1.6%)
-
-Courtroom Allocation:
-  Strategy: load_balanced
-  Load balance fairness (Gini): 0.002
-  Avg daily load: 53.8 cases
-  Allocation changes: 10,527
-  Capacity rejections: 0
-
-  Courtroom-wise totals:
-    Courtroom 1: 3,244 cases (54.1/day)
-    Courtroom 2: 3,233 cases (53.9/day)
-    Courtroom 3: 3,227 cases (53.8/day)
-    Courtroom 4: 3,221 cases (53.7/day)
-    Courtroom 5: 3,212 cases (53.5/day)

runs/baseline_large_data/report.txt

@@ -1,56 +0,0 @@
-================================================================================
-SIMULATION REPORT
-================================================================================
-
-Configuration:
-  Cases: 10000
-  Days simulated: 90
-  Policy: readiness
-  Horizon end: 2024-10-31
-
-Hearing Metrics:
-  Total hearings: 58,262
-  Heard: 36,595 (62.8%)
-  Adjourned: 21,667 (37.2%)
-
-Disposal Metrics:
-  Cases disposed: 5,195
-  Disposal rate: 51.9%
-  Gini coefficient: 0.243
-
-Disposal Rates by Case Type:
-  CA  : 1358/1952 ( 69.6%)
-  CCC :  796/1132 ( 70.3%)
-  CMP :  172/ 281 ( 61.2%)
-  CP  :  662/ 960 ( 69.0%)
-  CRP : 1365/2061 ( 66.2%)
-  RFA :  363/1676 ( 21.7%)
-  RSA :  479/1938 ( 24.7%)
-
-Efficiency Metrics:
-  Court utilization: 85.7%
-  Avg hearings/day: 647.4
-
-Ripeness Impact:
-  Transitions: 0
-  Cases filtered (unripe): 20,340
-  Filter rate: 25.9%
-
-Final Ripeness Distribution:
-  RIPE: 4579 (95.3%)
-  UNRIPE_DEPENDENT: 58 (1.2%)
-  UNRIPE_SUMMONS: 168 (3.5%)
-
-Courtroom Allocation:
-  Strategy: load_balanced
-  Load balance fairness (Gini): 0.001
-  Avg daily load: 129.5 cases
-  Allocation changes: 38,756
-  Capacity rejections: 0
-
-  Courtroom-wise totals:
-    Courtroom 1: 11,671 cases (129.7/day)
-    Courtroom 2: 11,666 cases (129.6/day)
-    Courtroom 3: 11,654 cases (129.5/day)
-    Courtroom 4: 11,640 cases (129.3/day)
-    Courtroom 5: 11,631 cases (129.2/day)

runs/rl_final_test/report.txt

@@ -1,56 +0,0 @@
-================================================================================
-SIMULATION REPORT
-================================================================================
-
-Configuration:
-  Cases: 3000
-  Days simulated: 60
-  Policy: rl
-  Horizon end: 2024-06-20
-
-Hearing Metrics:
-  Total hearings: 16,133
-  Heard: 9,929 (61.5%)
-  Adjourned: 6,204 (38.5%)
-
-Disposal Metrics:
-  Cases disposed: 700
-  Disposal rate: 23.3%
-  Gini coefficient: 0.194
-
-Disposal Rates by Case Type:
-  CA  :  159/ 587 ( 27.1%)
-  CCC :  128/ 334 ( 38.3%)
-  CMP :   15/  86 ( 17.4%)
-  CP  :  101/ 294 ( 34.4%)
-  CRP :  151/ 612 ( 24.7%)
-  RFA :   72/ 519 ( 13.9%)
-  RSA :   74/ 568 ( 13.0%)
-
-Efficiency Metrics:
-  Court utilization: 35.6%
-  Avg hearings/day: 268.9
-
-Ripeness Impact:
-  Transitions: 0
-  Cases filtered (unripe): 3,360
-  Filter rate: 17.2%
-
-Final Ripeness Distribution:
-  RIPE: 2244 (97.6%)
-  UNRIPE_DEPENDENT: 19 (0.8%)
-  UNRIPE_SUMMONS: 37 (1.6%)
-
-Courtroom Allocation:
-  Strategy: load_balanced
-  Load balance fairness (Gini): 0.002
-  Avg daily load: 53.8 cases
-  Allocation changes: 9,860
-  Capacity rejections: 0
-
-  Courtroom-wise totals:
-    Courtroom 1: 3,242 cases (54.0/day)
-    Courtroom 2: 3,234 cases (53.9/day)
-    Courtroom 3: 3,227 cases (53.8/day)
-    Courtroom 4: 3,219 cases (53.6/day)
-    Courtroom 5: 3,211 cases (53.5/day)

runs/rl_intensive/report.txt

@@ -1,56 +0,0 @@
-================================================================================
-SIMULATION REPORT
-================================================================================
-
-Configuration:
-  Cases: 3000
-  Days simulated: 60
-  Policy: rl
-  Horizon end: 2024-06-20
-
-Hearing Metrics:
-  Total hearings: 16,133
-  Heard: 9,929 (61.5%)
-  Adjourned: 6,204 (38.5%)
-
-Disposal Metrics:
-  Cases disposed: 700
-  Disposal rate: 23.3%
-  Gini coefficient: 0.194
-
-Disposal Rates by Case Type:
-  CA  :  159/ 587 ( 27.1%)
-  CCC :  128/ 334 ( 38.3%)
-  CMP :   15/  86 ( 17.4%)
-  CP  :  101/ 294 ( 34.4%)
-  CRP :  151/ 612 ( 24.7%)
-  RFA :   72/ 519 ( 13.9%)
-  RSA :   74/ 568 ( 13.0%)
-
-Efficiency Metrics:
-  Court utilization: 35.6%
-  Avg hearings/day: 268.9
-
-Ripeness Impact:
-  Transitions: 0
-  Cases filtered (unripe): 3,360
-  Filter rate: 17.2%
-
-Final Ripeness Distribution:
-  RIPE: 2244 (97.6%)
-  UNRIPE_DEPENDENT: 19 (0.8%)
-  UNRIPE_SUMMONS: 37 (1.6%)
-
-Courtroom Allocation:
-  Strategy: load_balanced
-  Load balance fairness (Gini): 0.002
-  Avg daily load: 53.8 cases
-  Allocation changes: 9,860
-  Capacity rejections: 0
-
-  Courtroom-wise totals:
-    Courtroom 1: 3,242 cases (54.0/day)
-    Courtroom 2: 3,234 cases (53.9/day)
-    Courtroom 3: 3,227 cases (53.8/day)
-    Courtroom 4: 3,219 cases (53.6/day)
-    Courtroom 5: 3,211 cases (53.5/day)

runs/rl_large_data/report.txt

@@ -1,56 +0,0 @@
-================================================================================
-SIMULATION REPORT
-================================================================================
-
-Configuration:
-  Cases: 10000
-  Days simulated: 90
-  Policy: rl
-  Horizon end: 2024-10-31
-
-Hearing Metrics:
-  Total hearings: 57,999
-  Heard: 36,465 (62.9%)
-  Adjourned: 21,534 (37.1%)
-
-Disposal Metrics:
-  Cases disposed: 5,212
-  Disposal rate: 52.1%
-  Gini coefficient: 0.248
-
-Disposal Rates by Case Type:
-  CA  : 1366/1952 ( 70.0%)
-  CCC :  815/1132 ( 72.0%)
-  CMP :  174/ 281 ( 61.9%)
-  CP  :  649/ 960 ( 67.6%)
-  CRP : 1348/2061 ( 65.4%)
-  RFA :  356/1676 ( 21.2%)
-  RSA :  504/1938 ( 26.0%)
-
-Efficiency Metrics:
-  Court utilization: 85.4%
-  Avg hearings/day: 644.4
-
-Ripeness Impact:
-  Transitions: 0
-  Cases filtered (unripe): 20,340
-  Filter rate: 26.0%
-
-Final Ripeness Distribution:
-  RIPE: 4562 (95.3%)
-  UNRIPE_DEPENDENT: 58 (1.2%)
-  UNRIPE_SUMMONS: 168 (3.5%)
-
-Courtroom Allocation:
-  Strategy: load_balanced
-  Load balance fairness (Gini): 0.001
-  Avg daily load: 128.9 cases
-  Allocation changes: 37,970
-  Capacity rejections: 0
-
-  Courtroom-wise totals:
-    Courtroom 1: 11,622 cases (129.1/day)
-    Courtroom 2: 11,610 cases (129.0/day)
-    Courtroom 3: 11,599 cases (128.9/day)
-    Courtroom 4: 11,590 cases (128.8/day)
-    Courtroom 5: 11,578 cases (128.6/day)

runs/rl_untrained/report.txt

@@ -1,56 +0,0 @@
-================================================================================
-SIMULATION REPORT
-================================================================================
-
-Configuration:
-  Cases: 3000
-  Days simulated: 30
-  Policy: rl
-  Horizon end: 2024-05-09
-
-Hearing Metrics:
-  Total hearings: 8,668
-  Heard: 5,338 (61.6%)
-  Adjourned: 3,330 (38.4%)
-
-Disposal Metrics:
-  Cases disposed: 312
-  Disposal rate: 10.4%
-  Gini coefficient: 0.191
-
-Disposal Rates by Case Type:
-  CA  :   73/ 587 ( 12.4%)
-  CCC :   46/ 334 ( 13.8%)
-  CMP :    5/  86 (  5.8%)
-  CP  :   44/ 294 ( 15.0%)
-  CRP :   72/ 612 ( 11.8%)
-  RFA :   40/ 519 (  7.7%)
-  RSA :   32/ 568 (  5.6%)
-
-Efficiency Metrics:
-  Court utilization: 38.3%
-  Avg hearings/day: 288.9
-
-Ripeness Impact:
-  Transitions: 0
-  Cases filtered (unripe): 1,680
-  Filter rate: 16.2%
-
-Final Ripeness Distribution:
-  RIPE: 2632 (97.9%)
-  UNRIPE_DEPENDENT: 19 (0.7%)
-  UNRIPE_SUMMONS: 37 (1.4%)
-
-Courtroom Allocation:
-  Strategy: load_balanced
-  Load balance fairness (Gini): 0.002
-  Avg daily load: 57.8 cases
-  Allocation changes: 4,412
-  Capacity rejections: 0
-
-  Courtroom-wise totals:
-    Courtroom 1: 1,742 cases (58.1/day)
-    Courtroom 2: 1,737 cases (57.9/day)
-    Courtroom 3: 1,732 cases (57.7/day)
-    Courtroom 4: 1,730 cases (57.7/day)
-    Courtroom 5: 1,727 cases (57.6/day)

runs/rl_vs_baseline/comparison_report.md

@@ -1,29 +0,0 @@
-# Scheduling Policy Comparison Report
-
-Policies evaluated: readiness, rl
-
-## Key Metrics Comparison
-
-| Metric | readiness | rl | Best |
-|--------|-------|-------|------|
-| Disposals | - | - | - |
-| Gini (fairness) | - | - | - |
-| Utilization (%) | - | - | - |
-| Adjournment Rate (%) | - | - | - |
-| Hearings Heard | 5 | 5 | - |
-| Total Hearings | - | - | - |
-
-## Analysis
-
-**Fairness**: readiness policy achieves lowest Gini coefficient (999.000), indicating most equitable disposal time distribution.
-
-**Efficiency**: readiness policy achieves highest utilization (0.0%), maximizing courtroom capacity usage.
-
-**Throughput**: readiness policy produces most disposals (0), clearing cases fastest.
-
-
-## Recommendation
-
-**Recommended Policy**: readiness
-
-This policy wins on 0/0 key metrics, providing the best balance of fairness, efficiency, and throughput.

runs/rl_vs_baseline/readiness/report.txt

@@ -1,56 +0,0 @@
-================================================================================
-SIMULATION REPORT
-================================================================================
-
-Configuration:
-  Cases: 3000
-  Days simulated: 30
-  Policy: readiness
-  Horizon end: 2024-05-09
-
-Hearing Metrics:
-  Total hearings: 8,671
-  Heard: 5,355 (61.8%)
-  Adjourned: 3,316 (38.2%)
-
-Disposal Metrics:
-  Cases disposed: 320
-  Disposal rate: 10.7%
-  Gini coefficient: 0.190
-
-Disposal Rates by Case Type:
-  CA  :   73/ 587 ( 12.4%)
-  CCC :   57/ 334 ( 17.1%)
-  CMP :    6/  86 (  7.0%)
-  CP  :   46/ 294 ( 15.6%)
-  CRP :   61/ 612 ( 10.0%)
-  RFA :   49/ 519 (  9.4%)
-  RSA :   28/ 568 (  4.9%)
-
-Efficiency Metrics:
-  Court utilization: 38.3%
-  Avg hearings/day: 289.0
-
-Ripeness Impact:
-  Transitions: 0
-  Cases filtered (unripe): 1,680
-  Filter rate: 16.2%
-
-Final Ripeness Distribution:
-  RIPE: 2624 (97.9%)
-  UNRIPE_DEPENDENT: 19 (0.7%)
-  UNRIPE_SUMMONS: 37 (1.4%)
-
-Courtroom Allocation:
-  Strategy: load_balanced
-  Load balance fairness (Gini): 0.002
-  Avg daily load: 57.8 cases
-  Allocation changes: 4,624
-  Capacity rejections: 0
-
-  Courtroom-wise totals:
-    Courtroom 1: 1,740 cases (58.0/day)
-    Courtroom 2: 1,737 cases (57.9/day)
-    Courtroom 3: 1,736 cases (57.9/day)
-    Courtroom 4: 1,732 cases (57.7/day)
-    Courtroom 5: 1,726 cases (57.5/day)

runs/rl_vs_baseline/rl/report.txt

@@ -1,56 +0,0 @@
-================================================================================
-SIMULATION REPORT
-================================================================================
-
-Configuration:
-  Cases: 3000
-  Days simulated: 30
-  Policy: rl
-  Horizon end: 2024-05-09
-
-Hearing Metrics:
-  Total hearings: 8,668
-  Heard: 5,338 (61.6%)
-  Adjourned: 3,330 (38.4%)
-
-Disposal Metrics:
-  Cases disposed: 312
-  Disposal rate: 10.4%
-  Gini coefficient: 0.191
-
-Disposal Rates by Case Type:
-  CA  :   73/ 587 ( 12.4%)
-  CCC :   46/ 334 ( 13.8%)
-  CMP :    5/  86 (  5.8%)
-  CP  :   44/ 294 ( 15.0%)
-  CRP :   72/ 612 ( 11.8%)
-  RFA :   40/ 519 (  7.7%)
-  RSA :   32/ 568 (  5.6%)
-
-Efficiency Metrics:
-  Court utilization: 38.3%
-  Avg hearings/day: 288.9
-
-Ripeness Impact:
-  Transitions: 0
-  Cases filtered (unripe): 1,680
-  Filter rate: 16.2%
-
-Final Ripeness Distribution:
-  RIPE: 2632 (97.9%)
-  UNRIPE_DEPENDENT: 19 (0.7%)
-  UNRIPE_SUMMONS: 37 (1.4%)
-
-Courtroom Allocation:
-  Strategy: load_balanced
-  Load balance fairness (Gini): 0.002
-  Avg daily load: 57.8 cases
-  Allocation changes: 4,412
-  Capacity rejections: 0
-
-  Courtroom-wise totals:
-    Courtroom 1: 1,742 cases (58.1/day)
-    Courtroom 2: 1,737 cases (57.9/day)
-    Courtroom 3: 1,732 cases (57.7/day)
-    Courtroom 4: 1,730 cases (57.7/day)
-    Courtroom 5: 1,727 cases (57.6/day)

scheduler/control/__init__.py

@@ -3,19 +3,14 @@
 Provides explainability and judge override capabilities.
 """
 
-from .explainability import (
-    DecisionStep,
-    SchedulingExplanation,
-    ExplainabilityEngine
-)
-
+from .explainability import DecisionStep, ExplainabilityEngine, SchedulingExplanation
 from .overrides import (
-    OverrideType,
-    Override,
-    JudgePreferences,
     CauseListDraft,
+    JudgePreferences,
+    Override,
+    OverrideManager,
+    OverrideType,
     OverrideValidator,
-    OverrideManager
 )
 
 __all__ = [

scheduler/control/explainability.py

@@ -2,16 +2,27 @@
 
 Provides human-readable explanations for why each case was or wasn't scheduled.
 """
+
 from dataclasses import dataclass
-from typing import Optional
 from datetime import date
+from typing import Optional
 
 from scheduler.core.case import Case
 
 
+def _fmt_score(score: Optional[float]) -> str:
+    """Format a score safely; return 'N/A' when score is None.
+
+    Avoids `TypeError: unsupported format string passed to NoneType.__format__`
+    when `priority_score` may be missing for not-scheduled cases.
+    """
+    return f"{score:.4f}" if isinstance(score, (int, float)) else "N/A"
+
+
 @dataclass
 class DecisionStep:
     """Single step in decision reasoning."""
+
     step_name: str
     passed: bool
     reason: str
@@ -21,43 +32,44 @@ class DecisionStep:
 @dataclass
 class SchedulingExplanation:
     """Complete explanation of scheduling decision for a case."""
+
     case_id: str
     scheduled: bool
     decision_steps: list[DecisionStep]
     final_reason: str
     priority_breakdown: Optional[dict] = None
     courtroom_assignment_reason: Optional[str] = None
-    
+
     def to_readable_text(self) -> str:
         """Convert to human-readable explanation."""
         lines = [f"Case {self.case_id}: {'SCHEDULED' if self.scheduled else 'NOT SCHEDULED'}"]
         lines.append("=" * 60)
-        
+
         for i, step in enumerate(self.decision_steps, 1):
-            status = "✓ PASS" if step.passed else "✗ FAIL"
+            status = "[PASS]" if step.passed else "[FAIL]"
             lines.append(f"\nStep {i}: {step.step_name} - {status}")
             lines.append(f"  Reason: {step.reason}")
             if step.details:
                 for key, value in step.details.items():
                     lines.append(f"    {key}: {value}")
-        
+
         if self.priority_breakdown and self.scheduled:
-            lines.append(f"\nPriority Score Breakdown:")
+            lines.append("\nPriority Score Breakdown:")
             for component, value in self.priority_breakdown.items():
                 lines.append(f"  {component}: {value}")
-        
+
         if self.courtroom_assignment_reason and self.scheduled:
-            lines.append(f"\nCourtroom Assignment:")
+            lines.append("\nCourtroom Assignment:")
             lines.append(f"  {self.courtroom_assignment_reason}")
-        
+
         lines.append(f"\nFinal Decision: {self.final_reason}")
-        
+
         return "\n".join(lines)
 
 
 class ExplainabilityEngine:
     """Generate explanations for scheduling decisions."""
-    
+
     @staticmethod
     def explain_scheduling_decision(
         case: Case,
@@ -67,51 +79,56 @@ class ExplainabilityEngine:
         priority_score: Optional[float] = None,
         courtroom_id: Optional[int] = None,
         capacity_full: bool = False,
-        below_threshold: bool = False
+        below_threshold: bool = False,
     ) -> SchedulingExplanation:
         """Generate complete explanation for why case was/wasn't scheduled.
-        
+
         Args:
             case: The case being scheduled
             current_date: Current simulation date
             scheduled: Whether case was scheduled
             ripeness_status: Ripeness classification
-            priority_score: Calculated priority score if scheduled
+            priority_score: Calculated priority score if available
             courtroom_id: Assigned courtroom if scheduled
             capacity_full: Whether capacity was full
             below_threshold: Whether priority was below threshold
-            
+
         Returns:
             Complete scheduling explanation
         """
-        steps = []
-        
+        steps: list[DecisionStep] = []
+        priority_breakdown: Optional[dict] = None  # ensure defined for return
+
         # Step 1: Disposal status check
         if case.is_disposed:
-            steps.append(DecisionStep(
-                step_name="Case Status Check",
-                passed=False,
-                reason="Case already disposed",
-                details={"disposal_date": str(case.disposal_date)}
-            ))
+            steps.append(
+                DecisionStep(
+                    step_name="Case Status Check",
+                    passed=False,
+                    reason="Case already disposed",
+                    details={"disposal_date": str(case.disposal_date)},
+                )
+            )
             return SchedulingExplanation(
                 case_id=case.case_id,
                 scheduled=False,
                 decision_steps=steps,
-                final_reason="Case disposed, no longer eligible for scheduling"
+                final_reason="Case disposed, no longer eligible for scheduling",
             )
-        
-        steps.append(DecisionStep(
-            step_name="Case Status Check",
-            passed=True,
-            reason="Case active and eligible",
-            details={"status": case.status.value}
-        ))
-        
+
+        steps.append(
+            DecisionStep(
+                step_name="Case Status Check",
+                passed=True,
+                reason="Case active and eligible",
+                details={"status": case.status.value},
+            )
+        )
+
         # Step 2: Ripeness check
         is_ripe = ripeness_status == "RIPE"
-        ripeness_detail = {}
-        
+        ripeness_detail: dict = {}
+
         if not is_ripe:
             if "SUMMONS" in ripeness_status:
                 ripeness_detail["bottleneck"] = "Summons not yet served"
@@ -126,191 +143,237 @@ class ExplainabilityEngine:
                 ripeness_detail["bottleneck"] = ripeness_status
         else:
             ripeness_detail["status"] = "All prerequisites met, ready for hearing"
-        
+
         if case.last_hearing_purpose:
             ripeness_detail["last_hearing_purpose"] = case.last_hearing_purpose
-        
-        steps.append(DecisionStep(
-            step_name="Ripeness Classification",
-            passed=is_ripe,
-            reason="Case is RIPE (ready for hearing)" if is_ripe else f"Case is UNRIPE ({ripeness_status})",
-            details=ripeness_detail
-        ))
-        
+
+        steps.append(
+            DecisionStep(
+                step_name="Ripeness Classification",
+                passed=is_ripe,
+                reason=(
+                    "Case is RIPE (ready for hearing)"
+                    if is_ripe
+                    else f"Case is UNRIPE ({ripeness_status})"
+                ),
+                details=ripeness_detail,
+            )
+        )
+
         if not is_ripe and not scheduled:
             return SchedulingExplanation(
                 case_id=case.case_id,
                 scheduled=False,
                 decision_steps=steps,
-                final_reason=f"Case not scheduled: UNRIPE status blocks scheduling. {ripeness_detail.get('action_needed', 'Waiting for case to become ready')}"
+                final_reason=(
+                    "Case not scheduled: UNRIPE status blocks scheduling. "
+                    f"{ripeness_detail.get('action_needed', 'Waiting for case to become ready')}"
+                ),
             )
-        
+
         # Step 3: Minimum gap check
         min_gap_days = 7
         days_since = case.days_since_last_hearing
         meets_gap = case.last_hearing_date is None or days_since >= min_gap_days
-        
-        gap_details = {
-            "days_since_last_hearing": days_since,
-            "minimum_required": min_gap_days
-        }
-        
+
+        gap_details = {"days_since_last_hearing": days_since, "minimum_required": min_gap_days}
+
         if case.last_hearing_date:
             gap_details["last_hearing_date"] = str(case.last_hearing_date)
-        
-        steps.append(DecisionStep(
-            step_name="Minimum Gap Check",
-            passed=meets_gap,
-            reason=f"{'Meets' if meets_gap else 'Does not meet'} minimum {min_gap_days}-day gap requirement",
-            details=gap_details
-        ))
-        
+
+        steps.append(
+            DecisionStep(
+                step_name="Minimum Gap Check",
+                passed=meets_gap,
+                reason=f"{'Meets' if meets_gap else 'Does not meet'} minimum {min_gap_days}-day gap requirement",
+                details=gap_details,
+            )
+        )
+
         if not meets_gap and not scheduled:
-            next_eligible = case.last_hearing_date.isoformat() if case.last_hearing_date else "unknown"
+            next_eligible = (
+                case.last_hearing_date.isoformat() if case.last_hearing_date else "unknown"
+            )
             return SchedulingExplanation(
                 case_id=case.case_id,
                 scheduled=False,
                 decision_steps=steps,
-                final_reason=f"Case not scheduled: Only {days_since} days since last hearing (minimum {min_gap_days} required). Next eligible after {next_eligible}"
+                final_reason=(
+                    f"Case not scheduled: Only {days_since} days since last hearing (minimum {min_gap_days} required). "
+                    f"Next eligible after {next_eligible}"
+                ),
             )
-        
-        # Step 4: Priority calculation
+
+        # Step 4: Priority calculation (only if a score was provided)
         if priority_score is not None:
+            import math
+
             age_component = min(case.age_days / 2000, 1.0) * 0.35
             readiness_component = case.readiness_score * 0.25
             urgency_component = (1.0 if case.is_urgent else 0.0) * 0.25
-            
+
             # Adjournment boost calculation
-            import math
             adj_boost_value = 0.0
             if case.status.value == "ADJOURNED" and case.hearing_count > 0:
                 adj_boost_value = math.exp(-case.days_since_last_hearing / 21)
             adj_boost_component = adj_boost_value * 0.15
-            
+
             priority_breakdown = {
                 "Age": f"{age_component:.4f} (age={case.age_days}d, weight=0.35)",
                 "Readiness": f"{readiness_component:.4f} (score={case.readiness_score:.2f}, weight=0.25)",
                 "Urgency": f"{urgency_component:.4f} ({'URGENT' if case.is_urgent else 'normal'}, weight=0.25)",
-                "Adjournment Boost": f"{adj_boost_component:.4f} (days_since={days_since}, decay=exp(-{days_since}/21), weight=0.15)",
-                "TOTAL": f"{priority_score:.4f}"
+                "Adjournment Boost": (
+                    f"{adj_boost_component:.4f} (days_since={days_since}, decay=exp(-{days_since}/21), weight=0.15)"
+                ),
+                "TOTAL": _fmt_score(priority_score),
             }
-            
-            steps.append(DecisionStep(
-                step_name="Priority Calculation",
-                passed=True,
-                reason=f"Priority score calculated: {priority_score:.4f}",
-                details=priority_breakdown
-            ))
-        
-        # Step 5: Selection by policy
+
+            steps.append(
+                DecisionStep(
+                    step_name="Priority Calculation",
+                    passed=True,
+                    reason=f"Priority score calculated: {_fmt_score(priority_score)}",
+                    details=priority_breakdown,
+                )
+            )
+
+        # Step 5: Selection by policy and final assembly
         if scheduled:
             if capacity_full:
-                steps.append(DecisionStep(
-                    step_name="Capacity Check",
-                    passed=True,
-                    reason="Selected despite full capacity (high priority override)",
-                    details={"priority_score": f"{priority_score:.4f}"}
-                ))
+                steps.append(
+                    DecisionStep(
+                        step_name="Capacity Check",
+                        passed=True,
+                        reason="Selected despite full capacity (high priority override)",
+                        details={"priority_score": _fmt_score(priority_score)},
+                    )
+                )
             elif below_threshold:
-                steps.append(DecisionStep(
-                    step_name="Policy Selection",
-                    passed=True,
-                    reason="Selected by policy despite being below typical threshold",
-                    details={"reason": "Algorithm determined case should be scheduled"}
-                ))
+                steps.append(
+                    DecisionStep(
+                        step_name="Policy Selection",
+                        passed=True,
+                        reason="Selected by policy despite being below typical threshold",
+                        details={"reason": "Algorithm determined case should be scheduled"},
+                    )
+                )
             else:
-                steps.append(DecisionStep(
-                    step_name="Policy Selection",
-                    passed=True,
-                    reason="Selected by scheduling policy among eligible cases",
-                    details={
-                        "priority_rank": "Top priority among eligible cases",
-                        "policy": "Readiness + Adjournment Boost"
-                    }
-                ))
-            
-            # Courtroom assignment
+                steps.append(
+                    DecisionStep(
+                        step_name="Policy Selection",
+                        passed=True,
+                        reason="Selected by scheduling policy among eligible cases",
+                        details={
+                            "priority_rank": "Top priority among eligible cases",
+                            "policy": "Readiness + Adjournment Boost",
+                        },
+                    )
+                )
+
+            courtroom_reason = None
             if courtroom_id:
                 courtroom_reason = f"Assigned to Courtroom {courtroom_id} via load balancing (least loaded courtroom selected)"
-                steps.append(DecisionStep(
-                    step_name="Courtroom Assignment",
-                    passed=True,
-                    reason=courtroom_reason,
-                    details={"courtroom_id": courtroom_id}
-                ))
-            
-            final_reason = f"Case SCHEDULED: Passed all checks, priority score {priority_score:.4f}, assigned to Courtroom {courtroom_id}"
-            
+                steps.append(
+                    DecisionStep(
+                        step_name="Courtroom Assignment",
+                        passed=True,
+                        reason=courtroom_reason,
+                        details={"courtroom_id": courtroom_id},
+                    )
+                )
+
+            # Build final reason safely (omit missing parts)
+            parts = [
+                "Case SCHEDULED: Passed all checks",
+                f"priority score {_fmt_score(priority_score)}"
+                if priority_score is not None
+                else None,
+                f"assigned to Courtroom {courtroom_id}" if courtroom_id else None,
+            ]
+            final_reason = ", ".join(part for part in parts if part)
+
             return SchedulingExplanation(
                 case_id=case.case_id,
                 scheduled=True,
                 decision_steps=steps,
                 final_reason=final_reason,
-                priority_breakdown=priority_breakdown if priority_score else None,
-                courtroom_assignment_reason=courtroom_reason if courtroom_id else None
+                priority_breakdown=priority_breakdown if priority_breakdown is not None else None,
+                courtroom_assignment_reason=courtroom_reason,
             )
-        else:
-            # Not scheduled - determine why
-            if capacity_full:
-                steps.append(DecisionStep(
+
+        # Not scheduled
+        if capacity_full:
+            steps.append(
+                DecisionStep(
                     step_name="Capacity Check",
                     passed=False,
                     reason="Daily capacity limit reached",
                     details={
-                        "priority_score": f"{priority_score:.4f}" if priority_score else "N/A",
-                        "explanation": "Higher priority cases filled all available slots"
-                    }
-                ))
-                final_reason = f"Case NOT SCHEDULED: Capacity full. Priority score {priority_score:.4f} was not high enough to displace scheduled cases"
-            elif below_threshold:
-                steps.append(DecisionStep(
+                        "priority_score": _fmt_score(priority_score),
+                        "explanation": "Higher priority cases filled all available slots",
+                    },
+                )
+            )
+            final_reason = (
+                "Case NOT SCHEDULED: Capacity full. "
+                f"Priority {_fmt_score(priority_score)} was not high enough to displace scheduled cases"
+            )
+        elif below_threshold:
+            steps.append(
+                DecisionStep(
                     step_name="Policy Selection",
                     passed=False,
                     reason="Priority below scheduling threshold",
                     details={
-                        "priority_score": f"{priority_score:.4f}" if priority_score else "N/A",
-                        "explanation": "Other cases had higher priority scores"
-                    }
-                ))
-                final_reason = f"Case NOT SCHEDULED: Priority score {priority_score:.4f} below threshold. Wait for case to age or become more urgent"
-            else:
-                final_reason = "Case NOT SCHEDULED: Unknown reason (policy decision)"
-            
-            return SchedulingExplanation(
-                case_id=case.case_id,
-                scheduled=False,
-                decision_steps=steps,
-                final_reason=final_reason,
-                priority_breakdown=priority_breakdown if priority_score else None
+                        "priority_score": _fmt_score(priority_score),
+                        "explanation": "Other cases had higher priority scores",
+                    },
+                )
             )
-    
+            final_reason = (
+                "Case NOT SCHEDULED: "
+                f"Priority {_fmt_score(priority_score)} below threshold. Wait for case to age or become more urgent"
+            )
+        else:
+            final_reason = "Case NOT SCHEDULED: Unknown reason (policy decision)"
+
+        return SchedulingExplanation(
+            case_id=case.case_id,
+            scheduled=False,
+            decision_steps=steps,
+            final_reason=final_reason,
+            priority_breakdown=priority_breakdown if priority_breakdown is not None else None,
+        )
+
     @staticmethod
     def explain_why_not_scheduled(case: Case, current_date: date) -> str:
         """Quick explanation for why a case wasn't scheduled.
-        
+
         Args:
             case: Case to explain
             current_date: Current date
-            
+
         Returns:
             Human-readable reason
         """
         if case.is_disposed:
             return f"Already disposed on {case.disposal_date}"
-        
+
         if case.ripeness_status != "RIPE":
             bottleneck_reasons = {
                 "UNRIPE_SUMMONS": "Summons not served",
                 "UNRIPE_DEPENDENT": "Waiting for dependent case",
                 "UNRIPE_PARTY": "Party unavailable",
-                "UNRIPE_DOCUMENT": "Documents pending"
+                "UNRIPE_DOCUMENT": "Documents pending",
             }
             reason = bottleneck_reasons.get(case.ripeness_status, case.ripeness_status)
             return f"UNRIPE: {reason}"
-        
+
         if case.last_hearing_date and case.days_since_last_hearing < 7:
-            return f"Too recent (last hearing {case.days_since_last_hearing} days ago, minimum 7 days)"
-        
+            return (
+                f"Too recent (last hearing {case.days_since_last_hearing} days ago, minimum 7 days)"
+            )
+
         # If ripe and meets gap, then it's priority-based
         priority = case.get_priority_score()
         return f"Low priority (score {priority:.3f}) - other cases ranked higher"

scheduler/control/overrides.py

@@ -3,11 +3,11 @@
 Allows judges to review, modify, and approve algorithmic scheduling suggestions.
 System is suggestive, not prescriptive - judges retain final control.
 """
+import json
 from dataclasses import dataclass, field
 from datetime import date, datetime
 from enum import Enum
 from typing import Optional
-import json
 
 
 class OverrideType(Enum):
@@ -35,13 +35,13 @@ class Override:
     reason: str = ""
     date_affected: Optional[date] = None
     courtroom_id: Optional[int] = None
-    
+
     # Algorithm-specific attributes
     make_ripe: Optional[bool] = None  # For RIPENESS overrides
-    new_position: Optional[int] = None  # For REORDER/ADD_CASE overrides  
+    new_position: Optional[int] = None  # For REORDER/ADD_CASE overrides
     new_priority: Optional[float] = None  # For PRIORITY overrides
     new_capacity: Optional[int] = None  # For CAPACITY overrides
-    
+
     def to_dict(self) -> dict:
         """Convert to dictionary for logging."""
         return {
@@ -60,32 +60,32 @@ class Override:
             "new_priority": self.new_priority,
             "new_capacity": self.new_capacity
         }
-    
+
     def to_readable_text(self) -> str:
         """Human-readable description of override."""
         action_desc = {
             OverrideType.RIPENESS: f"Changed ripeness from {self.old_value} to {self.new_value}",
             OverrideType.PRIORITY: f"Adjusted priority from {self.old_value} to {self.new_value}",
-            OverrideType.ADD_CASE: f"Manually added case to cause list",
-            OverrideType.REMOVE_CASE: f"Removed case from cause list",
+            OverrideType.ADD_CASE: "Manually added case to cause list",
+            OverrideType.REMOVE_CASE: "Removed case from cause list",
             OverrideType.REORDER: f"Reordered from position {self.old_value} to {self.new_value}",
             OverrideType.CAPACITY: f"Changed capacity from {self.old_value} to {self.new_value}",
             OverrideType.MIN_GAP: f"Overrode min gap from {self.old_value} to {self.new_value} days",
             OverrideType.COURTROOM: f"Changed courtroom from {self.old_value} to {self.new_value}"
         }
-        
+
         action = action_desc.get(self.override_type, f"Override: {self.override_type.value}")
-        
+
         parts = [
             f"[{self.timestamp.strftime('%Y-%m-%d %H:%M')}]",
             f"Judge {self.judge_id}:",
             action,
             f"(Case {self.case_id})"
         ]
-        
+
         if self.reason:
             parts.append(f"Reason: {self.reason}")
-        
+
         return " ".join(parts)
 
 
@@ -98,7 +98,7 @@ class JudgePreferences:
     min_gap_overrides: dict[str, int] = field(default_factory=dict)  # Per-case gap overrides
     case_type_preferences: dict[str, list[str]] = field(default_factory=dict)  # Day-of-week preferences
     capacity_overrides: dict[int, int] = field(default_factory=dict)  # Per-courtroom capacity overrides
-    
+
     def to_dict(self) -> dict:
         """Convert to dictionary."""
         return {
@@ -123,25 +123,25 @@ class CauseListDraft:
     created_at: datetime
     finalized_at: Optional[datetime] = None
     status: str = "DRAFT"  # DRAFT, APPROVED, REJECTED
-    
+
     def get_acceptance_rate(self) -> float:
         """Calculate what % of suggestions were accepted."""
         if not self.algorithm_suggested:
             return 0.0
-        
+
         accepted = len(set(self.algorithm_suggested) & set(self.judge_approved))
         return accepted / len(self.algorithm_suggested) * 100
-    
+
     def get_modifications_summary(self) -> dict:
         """Summarize modifications made."""
         added = set(self.judge_approved) - set(self.algorithm_suggested)
         removed = set(self.algorithm_suggested) - set(self.judge_approved)
-        
+
         override_counts = {}
         for override in self.overrides:
             override_type = override.override_type.value
             override_counts[override_type] = override_counts.get(override_type, 0) + 1
-        
+
         return {
             "cases_added": len(added),
             "cases_removed": len(removed),
@@ -153,32 +153,31 @@ class CauseListDraft:
 
 class OverrideValidator:
     """Validates override requests against constraints."""
-    
+
     def __init__(self):
         self.errors: list[str] = []
-    
+
     def validate(self, override: Override) -> bool:
         """Validate an override against all applicable constraints.
-        
+
         Args:
             override: Override to validate
-            
+
         Returns:
             True if valid, False otherwise
         """
         self.errors.clear()
-        
+
         if override.override_type == OverrideType.RIPENESS:
             valid, error = self.validate_ripeness_override(
                 override.case_id,
-                override.old_value or "",
                 override.new_value or "",
                 override.reason
             )
             if not valid:
                 self.errors.append(error)
                 return False
-        
+
         elif override.override_type == OverrideType.CAPACITY:
             if override.new_capacity is not None:
                 valid, error = self.validate_capacity_override(
@@ -188,59 +187,57 @@ class OverrideValidator:
                 if not valid:
                     self.errors.append(error)
                     return False
-        
+
         elif override.override_type == OverrideType.PRIORITY:
             if override.new_priority is not None:
                 if not (0 <= override.new_priority <= 1.0):
                     self.errors.append("Priority must be between 0 and 1.0")
                     return False
-        
+
         # Basic validation
         if not override.case_id:
             self.errors.append("Case ID is required")
             return False
-        
+
         if not override.judge_id:
             self.errors.append("Judge ID is required")
             return False
-        
+
         return True
-    
+
     def get_errors(self) -> list[str]:
         """Get validation errors from last validation."""
         return self.errors.copy()
-    
+
     @staticmethod
     def validate_ripeness_override(
         case_id: str,
-        old_status: str,
         new_status: str,
         reason: str
     ) -> tuple[bool, str]:
         """Validate ripeness override.
-        
+
         Args:
             case_id: Case ID
-            old_status: Current ripeness status
             new_status: Requested new status
             reason: Reason for override
-            
+
         Returns:
             (valid, error_message)
         """
         valid_statuses = ["RIPE", "UNRIPE_SUMMONS", "UNRIPE_DEPENDENT", "UNRIPE_PARTY", "UNRIPE_DOCUMENT"]
-        
+
         if new_status not in valid_statuses:
             return False, f"Invalid ripeness status: {new_status}"
-        
+
         if not reason:
             return False, "Reason required for ripeness override"
-        
+
         if len(reason) < 10:
             return False, "Reason must be at least 10 characters"
-        
+
         return True, ""
-    
+
     @staticmethod
     def validate_capacity_override(
         current_capacity: int,
@@ -248,26 +245,26 @@ class OverrideValidator:
         max_capacity: int = 200
     ) -> tuple[bool, str]:
         """Validate capacity override.
-        
+
         Args:
             current_capacity: Current daily capacity
             new_capacity: Requested new capacity
             max_capacity: Maximum allowed capacity
-            
+
         Returns:
             (valid, error_message)
         """
         if new_capacity < 0:
             return False, "Capacity cannot be negative"
-        
+
         if new_capacity > max_capacity:
             return False, f"Capacity cannot exceed maximum ({max_capacity})"
-        
+
         if new_capacity == 0:
             return False, "Capacity cannot be zero (use blocked dates for full closures)"
-        
+
         return True, ""
-    
+
     @staticmethod
     def validate_add_case(
         case_id: str,
@@ -276,52 +273,52 @@ class OverrideValidator:
         max_capacity: int
     ) -> tuple[bool, str]:
         """Validate adding a case to cause list.
-        
+
         Args:
             case_id: Case to add
             current_schedule: Currently scheduled case IDs
             current_capacity: Current number of scheduled cases
             max_capacity: Maximum capacity
-            
+
         Returns:
             (valid, error_message)
         """
         if case_id in current_schedule:
             return False, f"Case {case_id} already in schedule"
-        
+
         if current_capacity >= max_capacity:
             return False, f"Schedule at capacity ({current_capacity}/{max_capacity})"
-        
+
         return True, ""
-    
+
     @staticmethod
     def validate_remove_case(
         case_id: str,
         current_schedule: list[str]
     ) -> tuple[bool, str]:
         """Validate removing a case from cause list.
-        
+
         Args:
             case_id: Case to remove
             current_schedule: Currently scheduled case IDs
-            
+
         Returns:
             (valid, error_message)
         """
         if case_id not in current_schedule:
             return False, f"Case {case_id} not in schedule"
-        
+
         return True, ""
 
 
 class OverrideManager:
     """Manages judge overrides and interventions."""
-    
+
     def __init__(self):
         self.overrides: list[Override] = []
         self.drafts: list[CauseListDraft] = []
         self.preferences: dict[str, JudgePreferences] = {}
-    
+
     def create_draft(
         self,
         date: date,
@@ -330,13 +327,13 @@ class OverrideManager:
         algorithm_suggested: list[str]
     ) -> CauseListDraft:
         """Create a draft cause list for judge review.
-        
+
         Args:
             date: Date of cause list
             courtroom_id: Courtroom ID
             judge_id: Judge ID
             algorithm_suggested: Case IDs suggested by algorithm
-            
+
         Returns:
             Draft cause list
         """
@@ -350,21 +347,21 @@ class OverrideManager:
             created_at=datetime.now(),
             status="DRAFT"
         )
-        
+
         self.drafts.append(draft)
         return draft
-    
+
     def apply_override(
         self,
         draft: CauseListDraft,
         override: Override
     ) -> tuple[bool, str]:
         """Apply an override to a draft cause list.
-        
+
         Args:
             draft: Draft to modify
             override: Override to apply
-            
+
         Returns:
             (success, error_message)
         """
@@ -378,7 +375,7 @@ class OverrideManager:
             )
             if not valid:
                 return False, error
-        
+
         elif override.override_type == OverrideType.ADD_CASE:
             valid, error = OverrideValidator.validate_add_case(
                 override.case_id,
@@ -388,9 +385,9 @@ class OverrideManager:
             )
             if not valid:
                 return False, error
-            
+
             draft.judge_approved.append(override.case_id)
-        
+
         elif override.override_type == OverrideType.REMOVE_CASE:
             valid, error = OverrideValidator.validate_remove_case(
                 override.case_id,
@@ -398,79 +395,79 @@ class OverrideManager:
             )
             if not valid:
                 return False, error
-            
+
             draft.judge_approved.remove(override.case_id)
-        
+
         # Record override
         draft.overrides.append(override)
         self.overrides.append(override)
-        
+
         return True, ""
-    
+
     def finalize_draft(self, draft: CauseListDraft) -> bool:
         """Finalize draft cause list (judge approval).
-        
+
         Args:
             draft: Draft to finalize
-            
+
         Returns:
             Success status
         """
         if draft.status != "DRAFT":
             return False
-        
+
         draft.status = "APPROVED"
         draft.finalized_at = datetime.now()
-        
+
         return True
-    
+
     def get_judge_preferences(self, judge_id: str) -> JudgePreferences:
         """Get or create judge preferences.
-        
+
         Args:
             judge_id: Judge ID
-            
+
         Returns:
             Judge preferences
         """
         if judge_id not in self.preferences:
             self.preferences[judge_id] = JudgePreferences(judge_id=judge_id)
-        
+
         return self.preferences[judge_id]
-    
+
     def get_override_statistics(self, judge_id: Optional[str] = None) -> dict:
         """Get override statistics.
-        
+
         Args:
             judge_id: Optional filter by judge
-            
+
         Returns:
             Statistics dictionary
         """
         relevant_overrides = self.overrides
         if judge_id:
             relevant_overrides = [o for o in self.overrides if o.judge_id == judge_id]
-        
+
         if not relevant_overrides:
             return {
                 "total_overrides": 0,
                 "by_type": {},
                 "avg_per_day": 0
             }
-        
+
         override_counts = {}
         for override in relevant_overrides:
             override_type = override.override_type.value
             override_counts[override_type] = override_counts.get(override_type, 0) + 1
-        
+
         # Calculate acceptance rate from drafts
         relevant_drafts = self.drafts
         if judge_id:
             relevant_drafts = [d for d in self.drafts if d.judge_id == judge_id]
-        
+
         acceptance_rates = [d.get_acceptance_rate() for d in relevant_drafts if d.status == "APPROVED"]
         avg_acceptance = sum(acceptance_rates) / len(acceptance_rates) if acceptance_rates else 0
-        
+
         return {
             "total_overrides": len(relevant_overrides),
             "by_type": override_counts,
@@ -479,10 +476,10 @@ class OverrideManager:
             "avg_acceptance_rate": avg_acceptance,
             "modification_rate": 100 - avg_acceptance if avg_acceptance else 0
         }
-    
+
     def export_audit_trail(self, output_file: str):
         """Export complete audit trail to file.
-        
+
         Args:
             output_file: Path to output file
         """
@@ -501,6 +498,6 @@ class OverrideManager:
             ],
             "statistics": self.get_override_statistics()
         }
-        
+
         with open(output_file, 'w') as f:
             json.dump(audit_data, f, indent=2)

scheduler/core/algorithm.py

@@ -14,25 +14,25 @@ from dataclasses import dataclass, field
 from datetime import date
 from typing import Dict, List, Optional, Tuple
 
-from scheduler.core.case import Case, CaseStatus
-from scheduler.core.courtroom import Courtroom
-from scheduler.core.ripeness import RipenessClassifier, RipenessStatus
-from scheduler.core.policy import SchedulerPolicy
-from scheduler.simulation.allocator import CourtroomAllocator, AllocationStrategy
 from scheduler.control.explainability import ExplainabilityEngine, SchedulingExplanation
 from scheduler.control.overrides import (
+    JudgePreferences,
     Override,
     OverrideType,
-    JudgePreferences,
     OverrideValidator,
 )
+from scheduler.core.case import Case, CaseStatus
+from scheduler.core.courtroom import Courtroom
+from scheduler.core.policy import SchedulerPolicy
+from scheduler.core.ripeness import RipenessClassifier, RipenessStatus
 from scheduler.data.config import MIN_GAP_BETWEEN_HEARINGS
+from scheduler.simulation.allocator import CourtroomAllocator
 
 
 @dataclass
 class SchedulingResult:
     """Result of single-day scheduling with full transparency.
-    
+
     Attributes:
         scheduled_cases: Mapping of courtroom_id to list of scheduled cases
         explanations: Decision explanations for each case (scheduled + sample unscheduled)
@@ -45,7 +45,7 @@ class SchedulingResult:
         policy_used: Name of scheduling policy used (FIFO, Age, Readiness)
         total_scheduled: Total number of cases scheduled (calculated)
     """
-    
+
     # Core output
     scheduled_cases: Dict[int, List[Case]]
 
@@ -58,12 +58,12 @@ class SchedulingResult:
     unscheduled_cases: List[Tuple[Case, str]]
     ripeness_filtered: int
     capacity_limited: int
-    
+
     # Metadata
     scheduling_date: date
     policy_used: str
     total_scheduled: int = field(init=False)
-    
+
     def __post_init__(self):
         """Calculate derived fields."""
         self.total_scheduled = sum(len(cases) for cases in self.scheduled_cases.values())
@@ -71,14 +71,14 @@ class SchedulingResult:
 
 class SchedulingAlgorithm:
     """Core scheduling algorithm with override support.
-    
+
     This is the main product - a clean, reusable scheduling algorithm that:
     1. Filters cases by ripeness and eligibility
     2. Applies judge preferences and manual overrides
     3. Prioritizes cases using selected policy
     4. Allocates cases to courtrooms with load balancing
     5. Generates explanations for all decisions
-    
+
     Usage:
         algorithm = SchedulingAlgorithm(policy=readiness_policy, allocator=allocator)
         result = algorithm.schedule_day(
@@ -89,7 +89,7 @@ class SchedulingAlgorithm:
             preferences=judge_prefs
         )
     """
-    
+
     def __init__(
         self,
         policy: SchedulerPolicy,
@@ -97,7 +97,7 @@ class SchedulingAlgorithm:
         min_gap_days: int = MIN_GAP_BETWEEN_HEARINGS
     ):
         """Initialize algorithm with policy and allocator.
-        
+
         Args:
             policy: Scheduling policy (FIFO, Age, Readiness)
             allocator: Courtroom allocator (defaults to load-balanced)
@@ -107,7 +107,7 @@ class SchedulingAlgorithm:
         self.allocator = allocator
         self.min_gap_days = min_gap_days
         self.explainer = ExplainabilityEngine()
-    
+
     def schedule_day(
         self,
         cases: List[Case],
@@ -118,7 +118,7 @@ class SchedulingAlgorithm:
         max_explanations_unscheduled: int = 100
     ) -> SchedulingResult:
         """Schedule cases for a single day with override support.
-        
+
         Args:
             cases: All active cases (will be filtered)
             courtrooms: Available courtrooms
@@ -126,7 +126,7 @@ class SchedulingAlgorithm:
             overrides: Optional manual overrides to apply
             preferences: Optional judge preferences/constraints
             max_explanations_unscheduled: Max unscheduled cases to generate explanations for
-            
+
         Returns:
             SchedulingResult with scheduled cases, explanations, and audit trail
         """
@@ -161,43 +161,43 @@ class SchedulingAlgorithm:
 
         # Filter disposed cases
         active_cases = [c for c in cases if c.status != CaseStatus.DISPOSED]
-        
+
         # Update age and readiness for all cases
         for case in active_cases:
             case.update_age(current_date)
             case.compute_readiness_score()
-        
+
         # CHECKPOINT 1: Ripeness filtering with override support
         ripe_cases, ripeness_filtered = self._filter_by_ripeness(
             active_cases, current_date, validated_overrides, applied_overrides
         )
-        
+
         # CHECKPOINT 2: Eligibility check (min gap requirement)
         eligible_cases = self._filter_eligible(ripe_cases, current_date, unscheduled)
-        
+
         # CHECKPOINT 3: Apply judge preferences (capacity overrides tracked)
         if preferences:
             applied_overrides.extend(self._get_preference_overrides(preferences, courtrooms))
-        
+
         # CHECKPOINT 4: Prioritize using policy
         prioritized = self.policy.prioritize(eligible_cases, current_date)
-        
+
         # CHECKPOINT 5: Apply manual overrides (add/remove/reorder/priority)
         if validated_overrides:
             prioritized = self._apply_manual_overrides(
                 prioritized, validated_overrides, applied_overrides, unscheduled, active_cases
             )
-        
+
         # CHECKPOINT 6: Allocate to courtrooms
         scheduled_allocation, capacity_limited = self._allocate_cases(
             prioritized, courtrooms, current_date, preferences
         )
-        
+
         # Track capacity-limited cases
         total_scheduled = sum(len(cases) for cases in scheduled_allocation.values())
         for case in prioritized[total_scheduled:]:
             unscheduled.append((case, "Capacity exceeded - all courtrooms full"))
-        
+
         # CHECKPOINT 7: Generate explanations for scheduled cases
         for courtroom_id, cases_in_room in scheduled_allocation.items():
             for case in cases_in_room:
@@ -210,7 +210,7 @@ class SchedulingAlgorithm:
                     courtroom_id=courtroom_id
                 )
                 explanations[case.case_id] = explanation
-        
+
         # Generate explanations for sample of unscheduled cases
         for case, reason in unscheduled[:max_explanations_unscheduled]:
             if case is not None:  # Skip invalid override entries
@@ -237,7 +237,7 @@ class SchedulingAlgorithm:
             scheduling_date=current_date,
             policy_used=self.policy.get_name()
         )
-    
+
     def _filter_by_ripeness(
         self,
         cases: List[Case],
@@ -252,10 +252,10 @@ class SchedulingAlgorithm:
             for override in overrides:
                 if override.override_type == OverrideType.RIPENESS:
                     ripeness_overrides[override.case_id] = override.make_ripe
-        
+
         ripe_cases = []
         filtered_count = 0
-        
+
         for case in cases:
             # Check for ripeness override
             if case.case_id in ripeness_overrides:
@@ -269,24 +269,24 @@ class SchedulingAlgorithm:
                     case.mark_unripe(RipenessStatus.UNRIPE_DEPENDENT, "Judge override", current_date)
                     filtered_count += 1
                 continue
-            
+
             # Normal ripeness classification
             ripeness = RipenessClassifier.classify(case, current_date)
-            
+
             if ripeness.value != case.ripeness_status:
                 if ripeness.is_ripe():
                     case.mark_ripe(current_date)
                 else:
                     reason = RipenessClassifier.get_ripeness_reason(ripeness)
                     case.mark_unripe(ripeness, reason, current_date)
-            
+
             if ripeness.is_ripe():
                 ripe_cases.append(case)
             else:
                 filtered_count += 1
-        
+
         return ripe_cases, filtered_count
-    
+
     def _filter_eligible(
         self,
         cases: List[Case],
@@ -302,7 +302,7 @@ class SchedulingAlgorithm:
                 reason = f"Min gap not met - last hearing {case.days_since_last_hearing}d ago (min {self.min_gap_days}d)"
                 unscheduled.append((case, reason))
         return eligible
-    
+
     def _get_preference_overrides(
         self,
         preferences: JudgePreferences,
@@ -310,7 +310,7 @@ class SchedulingAlgorithm:
     ) -> List[Override]:
         """Extract overrides from judge preferences for audit trail."""
         overrides = []
-        
+
         if preferences.capacity_overrides:
             from datetime import datetime
             for courtroom_id, new_capacity in preferences.capacity_overrides.items():
@@ -325,9 +325,9 @@ class SchedulingAlgorithm:
                     reason="Judge preference"
                 )
                 overrides.append(override)
-        
+
         return overrides
-    
+
     def _apply_manual_overrides(
         self,
         prioritized: List[Case],
@@ -338,7 +338,7 @@ class SchedulingAlgorithm:
     ) -> List[Case]:
         """Apply manual overrides (ADD_CASE, REMOVE_CASE, PRIORITY, REORDER)."""
         result = prioritized.copy()
-        
+
         # Apply ADD_CASE overrides (insert at high priority)
         add_overrides = [o for o in overrides if o.override_type == OverrideType.ADD_CASE]
         for override in add_overrides:
@@ -349,7 +349,7 @@ class SchedulingAlgorithm:
                 insert_pos = override.new_position if override.new_position is not None else 0
                 result.insert(min(insert_pos, len(result)), case_to_add)
                 applied_overrides.append(override)
-        
+
         # Apply REMOVE_CASE overrides
         remove_overrides = [o for o in overrides if o.override_type == OverrideType.REMOVE_CASE]
         for override in remove_overrides:
@@ -358,23 +358,23 @@ class SchedulingAlgorithm:
             if removed:
                 applied_overrides.append(override)
                 unscheduled.append((removed[0], f"Judge override: {override.reason}"))
-        
+
         # Apply PRIORITY overrides (adjust priority scores)
         priority_overrides = [o for o in overrides if o.override_type == OverrideType.PRIORITY]
         for override in priority_overrides:
             case_to_adjust = next((c for c in result if c.case_id == override.case_id), None)
             if case_to_adjust and override.new_priority is not None:
                 # Store original priority for reference
-                original_priority = case_to_adjust.get_priority_score()
+                case_to_adjust.get_priority_score()
                 # Temporarily adjust case to force re-sorting
                 # Note: This is a simplification - in production might need case.set_priority_override()
                 case_to_adjust._priority_override = override.new_priority
                 applied_overrides.append(override)
-        
+
         # Re-sort if priority overrides were applied
         if priority_overrides:
             result.sort(key=lambda c: getattr(c, '_priority_override', c.get_priority_score()), reverse=True)
-        
+
         # Apply REORDER overrides (explicit positioning)
         reorder_overrides = [o for o in overrides if o.override_type == OverrideType.REORDER]
         for override in reorder_overrides:
@@ -384,9 +384,9 @@ class SchedulingAlgorithm:
                     result.remove(case_to_move)
                     result.insert(override.new_position, case_to_move)
                     applied_overrides.append(override)
-        
+
         return result
-    
+
     def _allocate_cases(
         self,
         prioritized: List[Case],
@@ -402,11 +402,11 @@ class SchedulingAlgorithm:
                 total_capacity += preferences.capacity_overrides[room.courtroom_id]
             else:
                 total_capacity += room.get_capacity_for_date(current_date)
-        
+
         # Limit cases to total capacity
         cases_to_allocate = prioritized[:total_capacity]
         capacity_limited = len(prioritized) - len(cases_to_allocate)
-        
+
         # Use allocator to distribute
         if self.allocator:
             case_to_courtroom = self.allocator.allocate(cases_to_allocate, current_date)
@@ -416,7 +416,7 @@ class SchedulingAlgorithm:
             for i, case in enumerate(cases_to_allocate):
                 room_id = courtrooms[i % len(courtrooms)].courtroom_id
                 case_to_courtroom[case.case_id] = room_id
-        
+
         # Build allocation dict
         allocation: Dict[int, List[Case]] = {r.courtroom_id: [] for r in courtrooms}
         for case in cases_to_allocate:
@@ -429,7 +429,6 @@ class SchedulingAlgorithm:
     @staticmethod
     def _clear_temporary_case_flags(cases: List[Case]) -> None:
         """Remove temporary scheduling flags to keep case objects clean between runs."""
-
         for case in cases:
             if hasattr(case, "_priority_override"):
                 delattr(case, "_priority_override")

scheduler/core/case.py

@@ -8,8 +8,8 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from datetime import date, datetime
-from typing import List, Optional, TYPE_CHECKING
 from enum import Enum
+from typing import TYPE_CHECKING, List, Optional
 
 from scheduler.data.config import TERMINAL_STAGES
 
@@ -26,12 +26,12 @@ class CaseStatus(Enum):
     ACTIVE = "active"            # Has had at least one hearing
     ADJOURNED = "adjourned"      # Last hearing was adjourned
     DISPOSED = "disposed"        # Final disposal/settlement reached
-    
+
 
 @dataclass
 class Case:
     """Represents a single court case.
-    
+
     Attributes:
         case_id: Unique identifier (like CNR number)
         case_type: Type of case (RSA, CRP, RFA, CA, CCC, CP, CMP)
@@ -64,20 +64,20 @@ class Case:
     stage_start_date: Optional[date] = None
     days_in_stage: int = 0
     history: List[dict] = field(default_factory=list)
-    
+
     # Ripeness tracking (NEW - for bottleneck detection)
     ripeness_status: str = "UNKNOWN"  # RipenessStatus enum value (stored as string to avoid circular import)
     bottleneck_reason: Optional[str] = None
     ripeness_updated_at: Optional[datetime] = None
     last_hearing_purpose: Optional[str] = None  # Purpose of last hearing (for classification)
-    
+
     # No-case-left-behind tracking (NEW)
     last_scheduled_date: Optional[date] = None
     days_since_last_scheduled: int = 0
-    
+
     def progress_to_stage(self, new_stage: str, current_date: date) -> None:
         """Progress case to a new stage.
-        
+
         Args:
             new_stage: The stage to progress to
             current_date: Current simulation date
@@ -85,22 +85,22 @@ class Case:
         self.current_stage = new_stage
         self.stage_start_date = current_date
         self.days_in_stage = 0
-        
+
         # Check if terminal stage (case disposed)
         if new_stage in TERMINAL_STAGES:
             self.status = CaseStatus.DISPOSED
             self.disposal_date = current_date
-            
+
         # Record in history
         self.history.append({
             "date": current_date,
             "event": "stage_change",
             "stage": new_stage,
         })
-    
+
     def record_hearing(self, hearing_date: date, was_heard: bool, outcome: str = "") -> None:
         """Record a hearing event.
-        
+
         Args:
             hearing_date: Date of the hearing
             was_heard: Whether the hearing actually proceeded (not adjourned)
@@ -108,12 +108,12 @@ class Case:
         """
         self.hearing_count += 1
         self.last_hearing_date = hearing_date
-        
+
         if was_heard:
             self.status = CaseStatus.ACTIVE
         else:
             self.status = CaseStatus.ADJOURNED
-        
+
         # Record in history
         self.history.append({
             "date": hearing_date,
@@ -122,114 +122,114 @@ class Case:
             "outcome": outcome,
             "stage": self.current_stage,
         })
-    
+
     def update_age(self, current_date: date) -> None:
         """Update age and days since last hearing.
-        
+
         Args:
             current_date: Current simulation date
         """
         self.age_days = (current_date - self.filed_date).days
-        
+
         if self.last_hearing_date:
             self.days_since_last_hearing = (current_date - self.last_hearing_date).days
         else:
             self.days_since_last_hearing = self.age_days
-        
+
         if self.stage_start_date:
             self.days_in_stage = (current_date - self.stage_start_date).days
         else:
             self.days_in_stage = self.age_days
-        
+
         # Update days since last scheduled (for no-case-left-behind tracking)
         if self.last_scheduled_date:
             self.days_since_last_scheduled = (current_date - self.last_scheduled_date).days
         else:
             self.days_since_last_scheduled = self.age_days
-    
+
     def compute_readiness_score(self) -> float:
         """Compute readiness score based on hearings, gaps, and stage.
-        
+
         Formula (from EDA):
             READINESS = (hearings_capped/50) * 0.4 +
                        (100/gap_clamped) * 0.3 +
                        (stage_advanced) * 0.3
-        
+
         Returns:
             Readiness score (0-1, higher = more ready)
         """
         # Cap hearings at 50
         hearings_capped = min(self.hearing_count, 50)
         hearings_component = (hearings_capped / 50) * 0.4
-        
+
         # Gap component (inverse of days since last hearing)
         gap_clamped = min(max(self.days_since_last_hearing, 1), 100)
         gap_component = (100 / gap_clamped) * 0.3
-        
+
         # Stage component (advanced stages get higher score)
         advanced_stages = ["ARGUMENTS", "EVIDENCE", "ORDERS / JUDGMENT"]
         stage_component = 0.3 if self.current_stage in advanced_stages else 0.1
-        
+
         readiness = hearings_component + gap_component + stage_component
         self.readiness_score = min(1.0, max(0.0, readiness))
-        
+
         return self.readiness_score
-    
+
     def is_ready_for_scheduling(self, min_gap_days: int = 7) -> bool:
         """Check if case is ready to be scheduled.
-        
+
         Args:
             min_gap_days: Minimum days required since last hearing
-            
+
         Returns:
             True if case can be scheduled
         """
         if self.status == CaseStatus.DISPOSED:
             return False
-        
+
         if self.last_hearing_date is None:
             return True  # First hearing, always ready
-        
+
         return self.days_since_last_hearing >= min_gap_days
-    
+
     def needs_alert(self, max_gap_days: int = 90) -> bool:
         """Check if case needs alert due to long gap.
-        
+
         Args:
             max_gap_days: Maximum allowed gap before alert
-            
+
         Returns:
             True if alert should be triggered
         """
         if self.status == CaseStatus.DISPOSED:
             return False
-        
+
         return self.days_since_last_hearing > max_gap_days
-    
+
     def get_priority_score(self) -> float:
         """Get overall priority score for scheduling.
-        
+
         Combines age, readiness, urgency, and adjournment boost into single score.
-        
+
         Formula:
             priority = age*0.35 + readiness*0.25 + urgency*0.25 + adjournment_boost*0.15
-        
+
         Adjournment boost: Recently adjourned cases get priority to avoid indefinite postponement.
         The boost decays exponentially: strongest immediately after adjournment, weaker over time.
-        
+
         Returns:
             Priority score (higher = higher priority)
         """
         # Age component (normalize to 0-1, assuming max age ~2000 days)
         age_component = min(self.age_days / 2000, 1.0) * 0.35
-        
+
         # Readiness component
         readiness_component = self.readiness_score * 0.25
-        
+
         # Urgency component
         urgency_component = 1.0 if self.is_urgent else 0.0
         urgency_component *= 0.25
-        
+
         # Adjournment boost (NEW - prevents cases from being repeatedly postponed)
         adjournment_boost = 0.0
         if self.status == CaseStatus.ADJOURNED and self.hearing_count > 0:
@@ -243,12 +243,12 @@ class Case:
             decay_factor = 21  # Half-life of boost
             adjournment_boost = math.exp(-self.days_since_last_hearing / decay_factor)
         adjournment_boost *= 0.15
-        
+
         return age_component + readiness_component + urgency_component + adjournment_boost
-    
+
     def mark_unripe(self, status, reason: str, current_date: datetime) -> None:
         """Mark case as unripe with bottleneck reason.
-        
+
         Args:
             status: Ripeness status (UNRIPE_SUMMONS, UNRIPE_PARTY, etc.) - RipenessStatus enum
             reason: Human-readable reason for unripeness
@@ -258,7 +258,7 @@ class Case:
         self.ripeness_status = status.value if hasattr(status, 'value') else str(status)
         self.bottleneck_reason = reason
         self.ripeness_updated_at = current_date
-        
+
         # Record in history
         self.history.append({
             "date": current_date,
@@ -266,17 +266,17 @@ class Case:
             "status": self.ripeness_status,
             "reason": reason,
         })
-    
+
     def mark_ripe(self, current_date: datetime) -> None:
         """Mark case as ripe (ready for hearing).
-        
+
         Args:
             current_date: Current simulation date
         """
         self.ripeness_status = "RIPE"
         self.bottleneck_reason = None
         self.ripeness_updated_at = current_date
-        
+
         # Record in history
         self.history.append({
             "date": current_date,
@@ -284,28 +284,28 @@ class Case:
             "status": "RIPE",
             "reason": "Case became ripe",
         })
-    
+
     def mark_scheduled(self, scheduled_date: date) -> None:
         """Mark case as scheduled for a hearing.
-        
+
         Used for no-case-left-behind tracking.
-        
+
         Args:
             scheduled_date: Date case was scheduled
         """
         self.last_scheduled_date = scheduled_date
         self.days_since_last_scheduled = 0
-    
+
     @property
     def is_disposed(self) -> bool:
         """Check if case is disposed."""
         return self.status == CaseStatus.DISPOSED
-    
+
     def __repr__(self) -> str:
         return (f"Case(id={self.case_id}, type={self.case_type}, "
                 f"stage={self.current_stage}, status={self.status.value}, "
                 f"hearings={self.hearing_count})")
-    
+
     def to_dict(self) -> dict:
         """Convert case to dictionary for serialization."""
         return {

scheduler/core/courtroom.py

@@ -14,7 +14,7 @@ from scheduler.data.config import DEFAULT_DAILY_CAPACITY
 @dataclass
 class Courtroom:
     """Represents a courtroom resource.
-    
+
     Attributes:
         courtroom_id: Unique identifier (0-4 for 5 courtrooms)
         judge_id: Currently assigned judge (optional)
@@ -31,134 +31,134 @@ class Courtroom:
     schedule: Dict[date, List[str]] = field(default_factory=dict)
     hearings_held: int = 0
     utilization_history: List[Dict] = field(default_factory=list)
-    
+
     def assign_judge(self, judge_id: str) -> None:
         """Assign a judge to this courtroom.
-        
+
         Args:
             judge_id: Judge identifier
         """
         self.judge_id = judge_id
-    
+
     def add_case_types(self, *case_types: str) -> None:
         """Add case types that this courtroom handles.
-        
+
         Args:
             *case_types: One or more case type strings (e.g., 'RSA', 'CRP')
         """
         self.case_types.update(case_types)
-    
+
     def can_schedule(self, hearing_date: date, case_id: str) -> bool:
         """Check if a case can be scheduled on a given date.
-        
+
         Args:
             hearing_date: Date to check
             case_id: Case identifier
-            
+
         Returns:
             True if slot available, False if at capacity
         """
         if hearing_date not in self.schedule:
             return True  # No hearings scheduled yet
-        
+
         # Check if already scheduled
         if case_id in self.schedule[hearing_date]:
             return False  # Already scheduled
-        
+
         # Check capacity
         return len(self.schedule[hearing_date]) < self.daily_capacity
-    
+
     def schedule_case(self, hearing_date: date, case_id: str) -> bool:
         """Schedule a case for a hearing.
-        
+
         Args:
             hearing_date: Date of hearing
             case_id: Case identifier
-            
+
         Returns:
             True if successfully scheduled, False if at capacity
         """
         if not self.can_schedule(hearing_date, case_id):
             return False
-        
+
         if hearing_date not in self.schedule:
             self.schedule[hearing_date] = []
-        
+
         self.schedule[hearing_date].append(case_id)
         return True
-    
+
     def unschedule_case(self, hearing_date: date, case_id: str) -> bool:
         """Remove a case from schedule (e.g., if adjourned).
-        
+
         Args:
             hearing_date: Date of hearing
             case_id: Case identifier
-            
+
         Returns:
             True if successfully removed, False if not found
         """
         if hearing_date not in self.schedule:
             return False
-        
+
         if case_id in self.schedule[hearing_date]:
             self.schedule[hearing_date].remove(case_id)
             return True
-        
+
         return False
-    
+
     def get_daily_schedule(self, hearing_date: date) -> List[str]:
         """Get list of cases scheduled for a specific date.
-        
+
         Args:
             hearing_date: Date to query
-            
+
         Returns:
             List of case_ids scheduled (empty if none)
         """
         return self.schedule.get(hearing_date, [])
-    
+
     def get_capacity_for_date(self, hearing_date: date) -> int:
         """Get remaining capacity for a specific date.
-        
+
         Args:
             hearing_date: Date to query
-            
+
         Returns:
             Number of available slots
         """
         scheduled_count = len(self.get_daily_schedule(hearing_date))
         return self.daily_capacity - scheduled_count
-    
+
     def record_hearing_completed(self, hearing_date: date) -> None:
         """Record that a hearing was held.
-        
+
         Args:
             hearing_date: Date of hearing
         """
         self.hearings_held += 1
-    
+
     def compute_utilization(self, hearing_date: date) -> float:
         """Compute utilization rate for a specific date.
-        
+
         Args:
             hearing_date: Date to compute for
-            
+
         Returns:
             Utilization rate (0.0 to 1.0)
         """
         scheduled_count = len(self.get_daily_schedule(hearing_date))
         return scheduled_count / self.daily_capacity if self.daily_capacity > 0 else 0.0
-    
+
     def record_daily_utilization(self, hearing_date: date, actual_hearings: int) -> None:
         """Record actual utilization for a day.
-        
+
         Args:
             hearing_date: Date of hearings
             actual_hearings: Number of hearings actually held (not adjourned)
         """
         scheduled = len(self.get_daily_schedule(hearing_date))
         utilization = actual_hearings / self.daily_capacity if self.daily_capacity > 0 else 0.0
-        
+
         self.utilization_history.append({
             "date": hearing_date,
             "scheduled": scheduled,
@@ -166,55 +166,55 @@ class Courtroom:
             "capacity": self.daily_capacity,
             "utilization": utilization,
         })
-    
+
     def get_average_utilization(self) -> float:
         """Calculate average utilization rate across all recorded days.
-        
+
         Returns:
             Average utilization (0.0 to 1.0)
         """
         if not self.utilization_history:
             return 0.0
-        
+
         total = sum(day["utilization"] for day in self.utilization_history)
         return total / len(self.utilization_history)
-    
+
     def get_schedule_summary(self, start_date: date, end_date: date) -> Dict:
         """Get summary statistics for a date range.
-        
+
         Args:
             start_date: Start of range
             end_date: End of range
-            
+
         Returns:
             Dict with counts and utilization stats
         """
-        days_in_range = [d for d in self.schedule.keys() 
+        days_in_range = [d for d in self.schedule.keys()
                         if start_date <= d <= end_date]
-        
+
         total_scheduled = sum(len(self.schedule[d]) for d in days_in_range)
         days_with_hearings = len(days_in_range)
-        
+
         return {
             "courtroom_id": self.courtroom_id,
             "days_with_hearings": days_with_hearings,
             "total_cases_scheduled": total_scheduled,
             "avg_cases_per_day": total_scheduled / days_with_hearings if days_with_hearings > 0 else 0,
             "total_capacity": days_with_hearings * self.daily_capacity,
-            "utilization_rate": total_scheduled / (days_with_hearings * self.daily_capacity) 
+            "utilization_rate": total_scheduled / (days_with_hearings * self.daily_capacity)
                               if days_with_hearings > 0 else 0,
         }
-    
+
     def clear_schedule(self) -> None:
         """Clear all scheduled hearings (for testing/reset)."""
         self.schedule.clear()
         self.utilization_history.clear()
         self.hearings_held = 0
-    
+
     def __repr__(self) -> str:
         return (f"Courtroom(id={self.courtroom_id}, judge={self.judge_id}, "
                 f"capacity={self.daily_capacity}, types={self.case_types})")
-    
+
     def to_dict(self) -> dict:
         """Convert courtroom to dictionary for serialization."""
         return {

scheduler/core/hearing.py

@@ -4,7 +4,7 @@ This module defines the Hearing class which represents a scheduled court hearing
 with its outcome and associated metadata.
 """
 
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from datetime import date
 from enum import Enum
 from typing import Optional
@@ -23,7 +23,7 @@ class HearingOutcome(Enum):
 @dataclass
 class Hearing:
     """Represents a scheduled court hearing event.
-    
+
     Attributes:
         hearing_id: Unique identifier
         case_id: Associated case
@@ -46,78 +46,78 @@ class Hearing:
     actual_date: Optional[date] = None
     duration_minutes: int = 30
     notes: Optional[str] = None
-    
+
     def mark_as_heard(self, actual_date: Optional[date] = None) -> None:
         """Mark hearing as successfully completed.
-        
+
         Args:
             actual_date: Actual date if different from scheduled
         """
         self.outcome = HearingOutcome.HEARD
         self.actual_date = actual_date or self.scheduled_date
-    
+
     def mark_as_adjourned(self, reason: str = "") -> None:
         """Mark hearing as adjourned.
-        
+
         Args:
             reason: Reason for adjournment
         """
         self.outcome = HearingOutcome.ADJOURNED
         if reason:
             self.notes = reason
-    
+
     def mark_as_disposed(self) -> None:
         """Mark hearing as final disposition."""
         self.outcome = HearingOutcome.DISPOSED
         self.actual_date = self.scheduled_date
-    
+
     def mark_as_no_show(self, party: str = "") -> None:
         """Mark hearing as no-show.
-        
+
         Args:
             party: Which party was absent
         """
         self.outcome = HearingOutcome.NO_SHOW
         if party:
             self.notes = f"No show: {party}"
-    
+
     def reschedule(self, new_date: date) -> None:
         """Reschedule hearing to a new date.
-        
+
         Args:
             new_date: New scheduled date
         """
         self.scheduled_date = new_date
         self.outcome = HearingOutcome.SCHEDULED
-    
+
     def is_complete(self) -> bool:
         """Check if hearing has concluded.
-        
+
         Returns:
             True if outcome is not SCHEDULED
         """
         return self.outcome != HearingOutcome.SCHEDULED
-    
+
     def is_successful(self) -> bool:
         """Check if hearing was successfully held.
-        
+
         Returns:
             True if outcome is HEARD or DISPOSED
         """
         return self.outcome in (HearingOutcome.HEARD, HearingOutcome.DISPOSED)
-    
+
     def get_effective_date(self) -> date:
         """Get actual or scheduled date.
-        
+
         Returns:
             actual_date if set, else scheduled_date
         """
         return self.actual_date or self.scheduled_date
-    
+
     def __repr__(self) -> str:
         return (f"Hearing(id={self.hearing_id}, case={self.case_id}, "
                 f"date={self.scheduled_date}, outcome={self.outcome.value})")
-    
+
     def to_dict(self) -> dict:
         """Convert hearing to dictionary for serialization."""
         return {

scheduler/core/judge.py

@@ -12,7 +12,7 @@ from typing import Dict, List, Optional, Set
 @dataclass
 class Judge:
     """Represents a judge with workload tracking.
-    
+
     Attributes:
         judge_id: Unique identifier
         name: Judge's name
@@ -29,37 +29,37 @@ class Judge:
     cases_heard: int = 0
     hearings_presided: int = 0
     workload_history: List[Dict] = field(default_factory=list)
-    
+
     def assign_courtroom(self, courtroom_id: int) -> None:
         """Assign judge to a courtroom.
-        
+
         Args:
             courtroom_id: Courtroom identifier
         """
         self.courtroom_id = courtroom_id
-    
+
     def add_preferred_types(self, *case_types: str) -> None:
         """Add case types to judge's preferences.
-        
+
         Args:
             *case_types: One or more case type strings
         """
         self.preferred_case_types.update(case_types)
-    
+
     def record_hearing(self, hearing_date: date, case_id: str, case_type: str) -> None:
         """Record a hearing presided over.
-        
+
         Args:
             hearing_date: Date of hearing
             case_id: Case identifier
             case_type: Type of case
         """
         self.hearings_presided += 1
-    
-    def record_daily_workload(self, hearing_date: date, cases_heard: int, 
+
+    def record_daily_workload(self, hearing_date: date, cases_heard: int,
                             cases_adjourned: int) -> None:
         """Record workload for a specific day.
-        
+
         Args:
             hearing_date: Date of hearings
             cases_heard: Number of cases actually heard
@@ -71,48 +71,48 @@ class Judge:
             "cases_adjourned": cases_adjourned,
             "total_scheduled": cases_heard + cases_adjourned,
         })
-        
+
         self.cases_heard += cases_heard
-    
+
     def get_average_daily_workload(self) -> float:
         """Calculate average cases heard per day.
-        
+
         Returns:
             Average number of cases per day
         """
         if not self.workload_history:
             return 0.0
-        
+
         total = sum(day["cases_heard"] for day in self.workload_history)
         return total / len(self.workload_history)
-    
+
     def get_adjournment_rate(self) -> float:
         """Calculate judge's adjournment rate.
-        
+
         Returns:
             Proportion of cases adjourned (0.0 to 1.0)
         """
         if not self.workload_history:
             return 0.0
-        
+
         total_adjourned = sum(day["cases_adjourned"] for day in self.workload_history)
         total_scheduled = sum(day["total_scheduled"] for day in self.workload_history)
-        
+
         return total_adjourned / total_scheduled if total_scheduled > 0 else 0.0
-    
+
     def get_workload_summary(self, start_date: date, end_date: date) -> Dict:
         """Get workload summary for a date range.
-        
+
         Args:
             start_date: Start of range
             end_date: End of range
-            
+
         Returns:
             Dict with workload statistics
         """
-        days_in_range = [day for day in self.workload_history 
+        days_in_range = [day for day in self.workload_history
                         if start_date <= day["date"] <= end_date]
-        
+
         if not days_in_range:
             return {
                 "judge_id": self.judge_id,
@@ -121,11 +121,11 @@ class Judge:
                 "avg_cases_per_day": 0.0,
                 "adjournment_rate": 0.0,
             }
-        
+
         total_heard = sum(day["cases_heard"] for day in days_in_range)
         total_adjourned = sum(day["cases_adjourned"] for day in days_in_range)
         total_scheduled = total_heard + total_adjourned
-        
+
         return {
             "judge_id": self.judge_id,
             "days_worked": len(days_in_range),
@@ -134,25 +134,25 @@ class Judge:
             "avg_cases_per_day": total_heard / len(days_in_range),
             "adjournment_rate": total_adjourned / total_scheduled if total_scheduled > 0 else 0.0,
         }
-    
+
     def is_specialized_in(self, case_type: str) -> bool:
         """Check if judge specializes in a case type.
-        
+
         Args:
             case_type: Case type to check
-            
+
         Returns:
             True if in preferred types or no preferences set
         """
         if not self.preferred_case_types:
             return True  # No preferences means handles all types
-        
+
         return case_type in self.preferred_case_types
-    
+
     def __repr__(self) -> str:
         return (f"Judge(id={self.judge_id}, courtroom={self.courtroom_id}, "
                 f"hearings={self.hearings_presided})")
-    
+
     def to_dict(self) -> dict:
         """Convert judge to dictionary for serialization."""
         return {

scheduler/core/policy.py

@@ -14,30 +14,30 @@ from scheduler.core.case import Case
 
 class SchedulerPolicy(ABC):
     """Abstract base class for scheduling policies.
-    
+
     All scheduling policies must implement the `prioritize` method which
     ranks cases for scheduling on a given day.
     """
-    
+
     @abstractmethod
     def prioritize(self, cases: List[Case], current_date: date) -> List[Case]:
         """Prioritize cases for scheduling on the given date.
-        
+
         Args:
             cases: List of eligible cases (already filtered for readiness, not disposed)
             current_date: Current simulation date
-            
+
         Returns:
             Sorted list of cases in priority order (highest priority first)
         """
         pass
-    
+
     @abstractmethod
     def get_name(self) -> str:
         """Get the policy name for logging/reporting."""
         pass
-    
+
     @abstractmethod
     def requires_readiness_score(self) -> bool:
         """Return True if this policy requires readiness score computation."""
-        pass
+        pass

scheduler/core/ripeness.py

@@ -7,9 +7,9 @@ Based on analysis of historical PurposeOfHearing patterns (see scripts/analyze_r
 """
 from __future__ import annotations
 
+from datetime import datetime, timedelta
 from enum import Enum
 from typing import TYPE_CHECKING
-from datetime import datetime, timedelta
 
 if TYPE_CHECKING:
     from scheduler.core.case import Case
@@ -17,7 +17,7 @@ if TYPE_CHECKING:
 
 class RipenessStatus(Enum):
     """Status indicating whether a case is ready for hearing."""
-    
+
     RIPE = "RIPE"  # Ready for hearing
     UNRIPE_SUMMONS = "UNRIPE_SUMMONS"  # Waiting for summons service
     UNRIPE_DEPENDENT = "UNRIPE_DEPENDENT"  # Waiting for dependent case/order
@@ -54,7 +54,7 @@ RIPE_KEYWORDS = ["ARGUMENTS", "HEARING", "FINAL", "JUDGMENT", "ORDERS", "DISPOSA
 
 class RipenessClassifier:
     """Classify cases as RIPE or UNRIPE for scheduling optimization.
-    
+
     Thresholds can be adjusted dynamically based on accuracy feedback.
     """
 
@@ -65,7 +65,7 @@ class RipenessClassifier:
         "ORDERS / JUDGMENT",
         "FINAL DISPOSAL"
     ]
-    
+
     # Stages that indicate administrative/preliminary work
     UNRIPE_STAGES = [
         "PRE-ADMISSION",
@@ -83,7 +83,6 @@ class RipenessClassifier:
     @classmethod
     def _has_required_evidence(cls, case: Case) -> tuple[bool, dict[str, bool]]:
         """Check that minimum readiness evidence exists before declaring RIPE."""
-
         # Evidence of service/compliance: at least one hearing or explicit purpose text
         service_confirmed = case.hearing_count >= cls.MIN_SERVICE_HEARINGS or bool(
             getattr(case, "last_hearing_purpose", None)
@@ -109,7 +108,6 @@ class RipenessClassifier:
     @classmethod
     def _has_ripe_signal(cls, case: Case) -> bool:
         """Check if stage or hearing purpose indicates readiness."""
-
         if case.current_stage in cls.RIPE_STAGES:
             return True
 
@@ -118,15 +116,15 @@ class RipenessClassifier:
             return any(keyword in purpose_upper for keyword in RIPE_KEYWORDS)
 
         return False
-    
+
     @classmethod
     def classify(cls, case: Case, current_date: datetime | None = None) -> RipenessStatus:
         """Classify case ripeness status with bottleneck type.
-        
+
         Args:
             case: Case to classify
             current_date: Current simulation date (defaults to now)
-            
+
         Returns:
             RipenessStatus enum indicating ripeness and bottleneck type
 
@@ -141,7 +139,7 @@ class RipenessClassifier:
         """
         if current_date is None:
             current_date = datetime.now()
-        
+
         # 1. Check last hearing purpose for explicit bottleneck keywords
         if hasattr(case, "last_hearing_purpose") and case.last_hearing_purpose:
             purpose_upper = case.last_hearing_purpose.upper()
@@ -149,7 +147,7 @@ class RipenessClassifier:
             for keyword, bottleneck_type in UNRIPE_KEYWORDS.items():
                 if keyword in purpose_upper:
                     return bottleneck_type
-        
+
         # 2. Check stage - ADMISSION stage with few hearings is likely unripe
         if case.current_stage == "ADMISSION":
             # New cases in ADMISSION (< 3 hearings) are often unripe
@@ -177,55 +175,55 @@ class RipenessClassifier:
 
         # 6. Default to UNKNOWN if no bottlenecks but also no clear ripe signal
         return RipenessStatus.UNKNOWN
-    
+
     @classmethod
     def get_ripeness_priority(cls, case: Case, current_date: datetime | None = None) -> float:
         """Get priority adjustment based on ripeness.
-        
+
         Ripe cases should get judicial time priority over unripe cases
         when scheduling is tight.
-        
+
         Returns:
             Priority multiplier (1.5 for RIPE, 0.7 for UNRIPE)
         """
         ripeness = cls.classify(case, current_date)
         return 1.5 if ripeness.is_ripe() else 0.7
-    
+
     @classmethod
     def is_schedulable(cls, case: Case, current_date: datetime | None = None) -> bool:
         """Determine if a case can be scheduled for a hearing.
-        
+
         A case is schedulable if:
         - It is RIPE (no bottlenecks)
         - It has been sufficient time since last hearing
         - It is not disposed
-        
+
         Args:
             case: The case to check
             current_date: Current simulation date
-        
+
         Returns:
             True if case can be scheduled, False otherwise
         """
         # Check disposal status
         if case.is_disposed:
             return False
-        
+
         # Calculate current ripeness
         ripeness = cls.classify(case, current_date)
-        
+
         # Only RIPE cases can be scheduled
         return ripeness.is_ripe()
-    
+
     @classmethod
     def get_ripeness_reason(cls, ripeness_status: RipenessStatus) -> str:
         """Get human-readable explanation for ripeness status.
-        
+
         Used in dashboard tooltips and reports.
-        
+
         Args:
             ripeness_status: The status to explain
-        
+
         Returns:
             Human-readable explanation string
         """
@@ -238,25 +236,25 @@ class RipenessClassifier:
             RipenessStatus.UNKNOWN: "Insufficient readiness evidence; route to manual triage",
         }
         return reasons.get(ripeness_status, "Unknown status")
-    
+
     @classmethod
     def estimate_ripening_time(cls, case: Case, current_date: datetime) -> timedelta | None:
         """Estimate time until case becomes ripe.
-        
+
         This is a heuristic based on bottleneck type and historical data.
-        
+
         Args:
             case: The case to evaluate
             current_date: Current simulation date
-        
+
         Returns:
             Estimated timedelta until ripe, or None if already ripe or unknown
         """
         ripeness = cls.classify(case, current_date)
-        
+
         if ripeness.is_ripe():
             return timedelta(0)
-        
+
         # Heuristic estimates based on bottleneck type
         estimates = {
             RipenessStatus.UNRIPE_SUMMONS: timedelta(days=30),
@@ -264,13 +262,13 @@ class RipenessClassifier:
             RipenessStatus.UNRIPE_PARTY: timedelta(days=14),
             RipenessStatus.UNRIPE_DOCUMENT: timedelta(days=21),
         }
-        
+
         return estimates.get(ripeness, None)
-    
+
     @classmethod
     def set_thresholds(cls, new_thresholds: dict[str, int | float]) -> None:
         """Update classification thresholds for calibration.
-        
+
         Args:
             new_thresholds: Dictionary with threshold names and values
                            e.g., {"MIN_SERVICE_HEARINGS": 2, "MIN_STAGE_DAYS": 5}
@@ -280,11 +278,11 @@ class RipenessClassifier:
                 setattr(cls, threshold_name, int(value))
             else:
                 raise ValueError(f"Unknown threshold: {threshold_name}")
-    
+
     @classmethod
     def get_current_thresholds(cls) -> dict[str, int]:
         """Get current threshold values.
-        
+
         Returns:
             Dictionary of threshold names and values
         """

scheduler/dashboard/app.py

@@ -16,28 +16,32 @@ from scheduler.dashboard.utils import get_data_status
 # Page configuration
 st.set_page_config(
     page_title="Court Scheduling System Dashboard",
-    page_icon="⚖️",
+    page_icon="scales",
     layout="wide",
     initial_sidebar_state="expanded",
 )
 
 # Main page content
-st.title("⚖️ Court Scheduling System Dashboard")
-st.markdown("**Karnataka High Court - Fair & Transparent Scheduling**")
+st.title("Court Scheduling System Dashboard")
+st.markdown("**Karnataka High Court - Algorithmic Decision Support for Fair Scheduling**")
 
 st.markdown("---")
 
 # Introduction
 st.markdown("""
-### Welcome to the Interactive Dashboard
+### Overview
 
-This dashboard provides comprehensive insights and controls for the Court Scheduling System:
+This system provides data-driven scheduling recommendations while maintaining judicial control and autonomy.
 
-- **EDA Analysis**: Explore case data, stage transitions, and adjournment patterns
-- **Ripeness Classifier**: Understand and tune the case readiness algorithm with full explainability
-- **RL Training**: Train and visualize reinforcement learning agents for optimal scheduling
+**Key Capabilities:**
+- Historical data analysis and pattern identification
+- Case ripeness classification (identifying bottlenecks)
+- Multi-courtroom scheduling simulation
+- Algorithmic suggestions with full explainability
+- Judge override and approval system
+- Reinforcement learning optimization
 
-Navigate using the sidebar to access different sections.
+Use the sidebar to navigate between sections.
 """)
 
 # System status
@@ -45,158 +49,146 @@ status_header_col1, status_header_col2 = st.columns([3, 1])
 with status_header_col1:
     st.markdown("### System Status")
 with status_header_col2:
-    if st.button("🔄 Refresh Status", use_container_width=True):
+    if st.button("Refresh Status", use_container_width=True):
         st.rerun()
 
 data_status = get_data_status()
 
-col1, col2, col3, col4 = st.columns(4)
+col1, col2, col3 = st.columns(3)
 
 with col1:
-    status = "✓" if data_status["cleaned_data"] else "✗"
+    status = "Ready" if data_status["cleaned_data"] else "Missing"
     color = "green" if data_status["cleaned_data"] else "red"
     st.markdown(f":{color}[{status}] **Cleaned Data**")
-    
+    if not data_status["cleaned_data"]:
+        st.caption("Run EDA pipeline to process raw data")
+
 with col2:
-    status = "✓" if data_status["parameters"] else "✗"
+    status = "Ready" if data_status["parameters"] else "Missing"
     color = "green" if data_status["parameters"] else "red"
     st.markdown(f":{color}[{status}] **Parameters**")
-    
+    if not data_status["parameters"]:
+        st.caption("Run EDA pipeline to extract parameters")
+
 with col3:
-    status = "✓" if data_status["generated_cases"] else "✗"
-    color = "green" if data_status["generated_cases"] else "red"
-    st.markdown(f":{color}[{status}] **Test Cases**")
-    
-with col4:
-    status = "✓" if data_status["eda_figures"] else "✗"
+    status = "Ready" if data_status["eda_figures"] else "Missing"
     color = "green" if data_status["eda_figures"] else "red"
-    st.markdown(f":{color}[{status}] **EDA Figures**")
+    st.markdown(f":{color}[{status}] **Analysis Figures**")
+    if not data_status["eda_figures"]:
+        st.caption("Run EDA pipeline to generate visualizations")
 
 # Setup Controls
-if not all(data_status.values()):
+eda_ready = data_status["cleaned_data"] and data_status["parameters"] and data_status["eda_figures"]
+
+if not eda_ready:
     st.markdown("---")
-    st.markdown("### Setup Required")
-    st.info("Some prerequisites are missing. Use the controls below to set up the system.")
-    
-    setup_col1, setup_col2 = st.columns(2)
-    
-    with setup_col1:
-        st.markdown("#### EDA Pipeline")
-        if not data_status["cleaned_data"] or not data_status["parameters"]:
-            st.warning("EDA pipeline needs to be run to generate cleaned data and parameters")
-            
-            if st.button("Run EDA Pipeline", type="primary", use_container_width=True):
-                import subprocess
-                
-                with st.spinner("Running EDA pipeline... This may take a few minutes."):
-                    try:
-                        result = subprocess.run(
-                            ["uv", "run", "court-scheduler", "eda"],
-                            capture_output=True,
-                            text=True,
-                            cwd=str(Path.cwd()),
-                        )
-                        
-                        if result.returncode == 0:
-                            st.success("EDA pipeline completed successfully!")
-                            st.rerun()
-                        else:
-                            st.error(f"EDA pipeline failed with error code {result.returncode}")
-                            with st.expander("Show error details"):
-                                st.code(result.stderr, language="text")
-                    except Exception as e:
-                        st.error(f"Error running EDA pipeline: {e}")
-        else:
-            st.success("EDA pipeline already complete")
-    
-    with setup_col2:
-        st.markdown("#### Test Case Generation")
-        if not data_status["generated_cases"]:
-            st.info("Optional: Generate synthetic test cases for classifier testing")
-            
-            n_cases = st.number_input("Number of cases to generate", min_value=100, max_value=50000, value=1000, step=100)
-            
-            if st.button("Generate Test Cases", use_container_width=True):
-                import subprocess
-                
-                with st.spinner(f"Generating {n_cases} test cases..."):
-                    try:
-                        result = subprocess.run(
-                            ["uv", "run", "court-scheduler", "generate", "--cases", str(n_cases)],
-                            capture_output=True,
-                            text=True,
-                            cwd=str(Path.cwd()),
-                        )
-                        
-                        if result.returncode == 0:
-                            st.success(f"Generated {n_cases} test cases successfully!")
-                            st.rerun()
-                        else:
-                            st.error(f"Generation failed with error code {result.returncode}")
-                            with st.expander("Show error details"):
-                                st.code(result.stderr, language="text")
-                    except Exception as e:
-                        st.error(f"Error generating test cases: {e}")
-        else:
-            st.success("Test cases already generated")
-    
-    st.markdown("#### Manual Setup")
-    with st.expander("Run commands manually (if buttons don't work)"):
-        st.code("""
-# Run EDA pipeline
-uv run court-scheduler eda
-
-# Generate test cases (optional)
-uv run court-scheduler generate --cases 1000
-        """, language="bash")
+    st.markdown("### Initial Setup")
+    st.warning("Run the EDA pipeline to process historical data and extract parameters.")
+
+    col1, col2 = st.columns([2, 1])
+
+    with col1:
+        st.markdown("""
+        The EDA pipeline:
+        - Loads and cleans historical court case data
+        - Extracts statistical parameters (distributions, transition probabilities)
+        - Generates analysis visualizations
+
+        This is required before using other dashboard features.
+        """)
+
+    with col2:
+        if st.button("Run EDA Pipeline", type="primary", use_container_width=True):
+            import subprocess
+
+            with st.spinner("Running EDA pipeline... This may take a few minutes."):
+                try:
+                    result = subprocess.run(
+                        ["uv", "run", "court-scheduler", "eda"],
+                        capture_output=True,
+                        text=True,
+                        cwd=str(Path.cwd()),
+                    )
+
+                    if result.returncode == 0:
+                        st.success("EDA pipeline completed")
+                        st.rerun()
+                    else:
+                        st.error(f"Pipeline failed with error code {result.returncode}")
+                        with st.expander("Show error details"):
+                            st.code(result.stderr, language="text")
+                except Exception as e:
+                    st.error(f"Error running pipeline: {e}")
+
+    with st.expander("Run manually via CLI"):
+        st.code("uv run court-scheduler eda", language="bash")
 else:
-    st.success("All prerequisites are ready! You can use all dashboard features.")
+    st.success("System ready - all data processed")
 
 st.markdown("---")
 
-# Quick start guide
-st.markdown("### Quick Start")
+# Navigation Guide
+st.markdown("### Dashboard Sections")
+
+col1, col2 = st.columns(2)
+
+with col1:
+    st.markdown("""
+    #### 1. Data & Insights
+    Explore historical case data, view analysis visualizations, and review extracted parameters.
+
+    #### 2. Ripeness Classifier
+    Test case ripeness classification with interactive threshold tuning and explainability.
 
-with st.expander("How to use this dashboard"):
+    #### 3. Simulation Workflow
+    Generate cases, configure simulation parameters, run scheduling simulations, and view results.
+    """)
+
+with col2:
     st.markdown("""
-    **1. EDA Analysis**
-    - View statistical insights from court case data
-    - Explore case distributions, stage transitions, and patterns
-    - Filter by case type, stage, and date range
-    
-    **2. Ripeness Classifier**
-    - Understand how cases are classified as RIPE/UNRIPE/UNKNOWN
-    - Adjust thresholds interactively and see real-time impact
-    - View case-level explainability with detailed reasoning
-    - Run calibration analysis to optimize thresholds
-    
-    **3. RL Training**
-    - Configure and train reinforcement learning agents
-    - Monitor training progress in real-time
-    - Compare different models and hyperparameters
-    - Visualize Q-table and action distributions
+    #### 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.
+
+    #### 6. Analytics & Reports
+    Compare simulation runs, analyze performance metrics, and export comprehensive reports.
     """)
 
-with st.expander("Prerequisites & Setup"):
+st.markdown("---")
+
+# Typical Workflow
+with st.expander("Typical Usage Workflow"):
     st.markdown("""
-    The dashboard requires some initial setup:
-    
-    1. **EDA Pipeline**: Processes raw data and extracts parameters
-    2. **Test Cases** (optional): Generates synthetic cases for testing
-    
-    **How to set up**:
-    - Use the interactive buttons in the "Setup Required" section above (if shown)
-    - Or run commands manually:
-      - `uv run court-scheduler eda`
-      - `uv run court-scheduler generate` (optional)
-    
-    The system status indicators at the top show what's ready.
+    **Step 1: Initial Setup**
+    - Run EDA pipeline to process historical data (one-time setup)
+
+    **Step 2: Understand the Data**
+    - Explore Data & Insights to understand case patterns
+    - Review extracted parameters and distributions
+
+    **Step 3: Test Ripeness Classifier**
+    - Adjust thresholds for your court's specific needs
+    - Test classification on sample cases
+
+    **Step 4: Run Simulation**
+    - Go to Simulation Workflow
+    - Generate or upload case dataset
+    - Configure simulation parameters
+    - Run simulation and review results
+
+    **Step 5: Review & Override**
+    - View generated cause lists in Cause Lists & Overrides
+    - Make judicial overrides as needed
+    - Approve final cause lists
+
+    **Step 6: Analyze Performance**
+    - Use Analytics & Reports to evaluate fairness and efficiency
+    - Compare different scheduling policies
+    - Identify bottlenecks and improvement opportunities
     """)
 
 # Footer
 st.markdown("---")
-st.markdown("""
-<div style='text-align: center'>
-    <small>Court Scheduling System | Code4Change Hackathon | Karnataka High Court</small>
-</div>
-""", unsafe_allow_html=True)
+st.caption("Court Scheduling System - Code4Change Hackathon - Karnataka High Court")

scheduler/dashboard/pages/1_EDA_Analysis.py

@@ -1,273 +0,0 @@
-"""EDA Analysis page - Explore court case data insights.
-
-This page displays exploratory data analysis visualizations and statistics
-from the court case dataset.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-import pandas as pd
-import plotly.express as px
-import plotly.graph_objects as go
-import streamlit as st
-
-from scheduler.dashboard.utils import (
-    get_case_statistics,
-    load_cleaned_data,
-    load_param_loader,
-)
-
-# Page configuration
-st.set_page_config(
-    page_title="EDA Analysis",
-    page_icon="📊",
-    layout="wide",
-)
-
-st.title("📊 Exploratory Data Analysis")
-st.markdown("Statistical insights from court case data")
-
-# Load data
-with st.spinner("Loading data..."):
-    try:
-        df = load_cleaned_data()
-        params = load_param_loader()
-        stats = get_case_statistics(df)
-    except Exception as e:
-        st.error(f"Error loading data: {e}")
-        st.info("Please run the EDA pipeline first: `uv run court-scheduler eda`")
-        st.stop()
-
-if df.empty:
-    st.warning("No data available. Please run the EDA pipeline first.")
-    st.code("uv run court-scheduler eda")
-    st.stop()
-
-# Sidebar filters
-st.sidebar.header("Filters")
-
-# Case type filter
-available_case_types = df["CaseType"].unique().tolist() if "CaseType" in df else []
-selected_case_types = st.sidebar.multiselect(
-    "Case Types",
-    options=available_case_types,
-    default=available_case_types,
-)
-
-# Stage filter
-available_stages = df["Remappedstages"].unique().tolist() if "Remappedstages" in df else []
-selected_stages = st.sidebar.multiselect(
-    "Stages",
-    options=available_stages,
-    default=available_stages,
-)
-
-# Apply filters
-filtered_df = df.copy()
-if selected_case_types:
-    filtered_df = filtered_df[filtered_df["CaseType"].isin(selected_case_types)]
-if selected_stages:
-    filtered_df = filtered_df[filtered_df["Remappedstages"].isin(selected_stages)]
-
-# Key metrics
-st.markdown("### Key Metrics")
-
-col1, col2, col3, col4 = st.columns(4)
-
-with col1:
-    total_cases = len(filtered_df)
-    st.metric("Total Cases", f"{total_cases:,}")
-
-with col2:
-    n_case_types = len(filtered_df["CaseType"].unique()) if "CaseType" in filtered_df else 0
-    st.metric("Case Types", n_case_types)
-
-with col3:
-    n_stages = len(filtered_df["Remappedstages"].unique()) if "Remappedstages" in filtered_df else 0
-    st.metric("Unique Stages", n_stages)
-
-with col4:
-    if "Outcome" in filtered_df.columns:
-        adj_rate = (filtered_df["Outcome"] == "ADJOURNED").sum() / len(filtered_df)
-        st.metric("Adjournment Rate", f"{adj_rate:.1%}")
-    else:
-        st.metric("Adjournment Rate", "N/A")
-
-st.markdown("---")
-
-# Visualizations
-tab1, tab2, tab3, tab4 = st.tabs(["Case Distribution", "Stage Analysis", "Adjournment Patterns", "Raw Data"])
-
-with tab1:
-    st.markdown("### Case Distribution by Type")
-    
-    if "CaseType" in filtered_df:
-        case_type_counts = filtered_df["CaseType"].value_counts().reset_index()
-        case_type_counts.columns = ["CaseType", "Count"]
-        
-        fig = px.bar(
-            case_type_counts,
-            x="CaseType",
-            y="Count",
-            title="Number of Cases by Type",
-            labels={"CaseType": "Case Type", "Count": "Number of Cases"},
-            color="Count",
-            color_continuous_scale="Blues",
-        )
-        fig.update_layout(xaxis_tickangle=-45, height=500)
-        st.plotly_chart(fig, use_container_width=True)
-        
-        # Pie chart
-        fig_pie = px.pie(
-            case_type_counts,
-            values="Count",
-            names="CaseType",
-            title="Case Type Distribution",
-        )
-        st.plotly_chart(fig_pie, use_container_width=True)
-    else:
-        st.info("CaseType column not found in data")
-
-with tab2:
-    st.markdown("### Stage Analysis")
-    
-    if "Remappedstages" in filtered_df:
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            stage_counts = filtered_df["Remappedstages"].value_counts().reset_index()
-            stage_counts.columns = ["Stage", "Count"]
-            
-            fig = px.bar(
-                stage_counts.head(10),
-                x="Count",
-                y="Stage",
-                orientation="h",
-                title="Top 10 Stages by Case Count",
-                labels={"Stage": "Stage", "Count": "Number of Cases"},
-                color="Count",
-                color_continuous_scale="Greens",
-            )
-            fig.update_layout(height=500)
-            st.plotly_chart(fig, use_container_width=True)
-        
-        with col2:
-            # Stage distribution pie chart
-            fig_pie = px.pie(
-                stage_counts.head(10),
-                values="Count",
-                names="Stage",
-                title="Stage Distribution (Top 10)",
-            )
-            fig_pie.update_layout(height=500)
-            st.plotly_chart(fig_pie, use_container_width=True)
-    else:
-        st.info("Remappedstages column not found in data")
-
-with tab3:
-    st.markdown("### Adjournment Patterns")
-    
-    # Adjournment rate by case type
-    if "CaseType" in filtered_df and "Outcome" in filtered_df:
-        adj_by_type = (
-            filtered_df.groupby("CaseType")["Outcome"]
-            .apply(lambda x: (x == "ADJOURNED").sum() / len(x) if len(x) > 0 else 0)
-            .reset_index()
-        )
-        adj_by_type.columns = ["CaseType", "Adjournment_Rate"]
-        adj_by_type["Adjournment_Rate"] = adj_by_type["Adjournment_Rate"] * 100
-        
-        fig = px.bar(
-            adj_by_type.sort_values("Adjournment_Rate", ascending=False),
-            x="CaseType",
-            y="Adjournment_Rate",
-            title="Adjournment Rate by Case Type (%)",
-            labels={"CaseType": "Case Type", "Adjournment_Rate": "Adjournment Rate (%)"},
-            color="Adjournment_Rate",
-            color_continuous_scale="Reds",
-        )
-        fig.update_layout(xaxis_tickangle=-45, height=500)
-        st.plotly_chart(fig, use_container_width=True)
-    
-    # Adjournment rate by stage
-    if "Remappedstages" in filtered_df and "Outcome" in filtered_df:
-        adj_by_stage = (
-            filtered_df.groupby("Remappedstages")["Outcome"]
-            .apply(lambda x: (x == "ADJOURNED").sum() / len(x) if len(x) > 0 else 0)
-            .reset_index()
-        )
-        adj_by_stage.columns = ["Stage", "Adjournment_Rate"]
-        adj_by_stage["Adjournment_Rate"] = adj_by_stage["Adjournment_Rate"] * 100
-        
-        fig = px.bar(
-            adj_by_stage.sort_values("Adjournment_Rate", ascending=False).head(15),
-            x="Adjournment_Rate",
-            y="Stage",
-            orientation="h",
-            title="Adjournment Rate by Stage (Top 15, %)",
-            labels={"Stage": "Stage", "Adjournment_Rate": "Adjournment Rate (%)"},
-            color="Adjournment_Rate",
-            color_continuous_scale="Oranges",
-        )
-        fig.update_layout(height=600)
-        st.plotly_chart(fig, use_container_width=True)
-    
-    # Heatmap: Adjournment probability by stage and case type
-    if params and "adjournment_stats" in params:
-        st.markdown("#### Adjournment Probability Heatmap (Stage × Case Type)")
-        
-        adj_stats = params["adjournment_stats"]
-        stages = list(adj_stats.keys())
-        case_types = params["case_types"]
-        
-        heatmap_data = []
-        for stage in stages:
-            row = []
-            for ct in case_types:
-                prob = adj_stats.get(stage, {}).get(ct, 0)
-                row.append(prob * 100)  # Convert to percentage
-            heatmap_data.append(row)
-        
-        fig = go.Figure(data=go.Heatmap(
-            z=heatmap_data,
-            x=case_types,
-            y=stages,
-            colorscale="RdYlGn_r",
-            text=[[f"{val:.1f}%" for val in row] for row in heatmap_data],
-            texttemplate="%{text}",
-            textfont={"size": 8},
-            colorbar=dict(title="Adj. Rate (%)"),
-        ))
-        fig.update_layout(
-            title="Adjournment Probability Heatmap",
-            xaxis_title="Case Type",
-            yaxis_title="Stage",
-            height=700,
-        )
-        st.plotly_chart(fig, use_container_width=True)
-
-with tab4:
-    st.markdown("### Raw Data")
-    
-    st.dataframe(
-        filtered_df.head(100),
-        use_container_width=True,
-        height=600,
-    )
-    
-    st.markdown(f"**Showing first 100 of {len(filtered_df):,} filtered rows**")
-    
-    # Download button
-    csv = filtered_df.to_csv(index=False).encode('utf-8')
-    st.download_button(
-        label="Download filtered data as CSV",
-        data=csv,
-        file_name="filtered_cases.csv",
-        mime="text/csv",
-    )
-
-# Footer
-st.markdown("---")
-st.markdown("*Data loaded from EDA pipeline. Refresh to reload.*")

scheduler/dashboard/pages/2_Ripeness_Classifier.py

@@ -10,21 +10,24 @@ from datetime import date, timedelta
 
 import pandas as pd
 import plotly.express as px
-import plotly.graph_objects as go
 import streamlit as st
 
-from scheduler.core.case import Case, CaseStatus, CaseType
+from scheduler.core.case import Case, CaseStatus
 from scheduler.core.ripeness import RipenessClassifier, RipenessStatus
-from scheduler.dashboard.utils import load_generated_cases
+from scheduler.dashboard.utils.data_loader import (
+    attach_history_to_cases,
+    load_generated_cases,
+    load_generated_hearings,
+)
 
 # Page configuration
 st.set_page_config(
     page_title="Ripeness Classifier",
-    page_icon="🎯",
+    page_icon="target",
     layout="wide",
 )
 
-st.title("🎯 Ripeness Classifier - Explainability Dashboard")
+st.title("Ripeness Classifier - Explainability Dashboard")
 st.markdown("Understand and tune the case readiness algorithm")
 
 # Initialize session state for thresholds
@@ -67,6 +70,13 @@ min_case_age_days = st.sidebar.slider(
     help="Minimum case age before considered RIPE",
 )
 
+# Detailed history toggle
+use_history = st.sidebar.toggle(
+    "Use detailed hearing history (if available)",
+    value=True,
+    help="When enabled, the classifier will use per-hearing history from hearings.csv if present.",
+)
+
 # Reset button
 if st.sidebar.button("Reset to Defaults"):
     st.session_state.min_service_hearings = 2
@@ -79,252 +89,213 @@ st.session_state.min_service_hearings = min_service_hearings
 st.session_state.min_stage_days = min_stage_days
 st.session_state.min_case_age_days = min_case_age_days
 
+# Wire sidebar thresholds to the core classifier
+RipenessClassifier.set_thresholds(
+    {
+        "MIN_SERVICE_HEARINGS": min_service_hearings,
+        "MIN_STAGE_DAYS": min_stage_days,
+        "MIN_CASE_AGE_DAYS": min_case_age_days,
+    }
+)
+
 # Main content
 tab1, tab2, tab3 = st.tabs(["Current Configuration", "Interactive Testing", "Batch Classification"])
 
 with tab1:
     st.markdown("### Current Classifier Configuration")
-    
+
     col1, col2, col3 = st.columns(3)
-    
+
     with col1:
         st.metric("Min Service Hearings", min_service_hearings)
         st.caption("Cases need at least this many service hearings")
-        
+
     with col2:
         st.metric("Min Stage Days", min_stage_days)
         st.caption("Days in current stage threshold")
-        
+
     with col3:
         st.metric("Min Case Age", f"{min_case_age_days} days")
         st.caption("Minimum case age requirement")
-    
+
     st.markdown("---")
-    
+
     # Classification logic flowchart
     st.markdown("### Classification Logic")
-    
+
     with st.expander("View Decision Tree Logic"):
         st.markdown("""
         The ripeness classifier uses the following decision logic:
-        
+
         **1. Service Hearings Check**
-        - If `service_hearings < MIN_SERVICE_HEARINGS` → **UNRIPE**
-        
+        - If `service_hearings < MIN_SERVICE_HEARINGS` -> **UNRIPE**
+
         **2. Case Age Check**
-        - If `case_age < MIN_CASE_AGE_DAYS` → **UNRIPE**
-        
+        - If `case_age < MIN_CASE_AGE_DAYS` -> **UNRIPE**
+
         **3. Stage-Specific Checks**
         - Each stage has minimum days requirement
-        - If `days_in_stage < stage_requirement` → **UNRIPE**
-        
+        - If `days_in_stage < stage_requirement` -> **UNRIPE**
+
         **4. Keyword Analysis**
         - Certain keywords indicate ripeness (e.g., "reply filed", "arguments complete")
-        - If keywords found → **RIPE**
-        
+        - If keywords found -> **RIPE**
+
         **5. Final Classification**
-        - If all criteria met → **RIPE**
-        - If some criteria failed but not critical → **UNKNOWN**
-        - Otherwise → **UNRIPE**
+        - If all criteria met -> **RIPE**
+        - If some criteria failed but not critical -> **UNKNOWN**
+        - Otherwise -> **UNRIPE**
         """)
-    
+
     # Show stage-specific rules
     st.markdown("### Stage-Specific Rules")
-    
+
     stage_rules = {
         "PRE-TRIAL": {"min_days": 60, "keywords": ["affidavit filed", "reply filed"]},
         "TRIAL": {"min_days": 45, "keywords": ["evidence complete", "cross complete"]},
         "POST-TRIAL": {"min_days": 30, "keywords": ["arguments complete", "written note"]},
         "FINAL DISPOSAL": {"min_days": 15, "keywords": ["disposed", "judgment"]},
     }
-    
-    df_rules = pd.DataFrame([
-        {"Stage": stage, "Min Days": rules["min_days"], "Keywords": ", ".join(rules["keywords"])}
-        for stage, rules in stage_rules.items()
-    ])
-    
+
+    df_rules = pd.DataFrame(
+        [
+            {
+                "Stage": stage,
+                "Min Days": rules["min_days"],
+                "Keywords": ", ".join(rules["keywords"]),
+            }
+            for stage, rules in stage_rules.items()
+        ]
+    )
+
     st.dataframe(df_rules, use_container_width=True, hide_index=True)
 
 with tab2:
     st.markdown("### Interactive Case Classification Testing")
-    
-    st.markdown("Create a synthetic case and see how it would be classified with current thresholds")
-    
+
+    st.markdown(
+        "Create a synthetic case and see how it would be classified with current thresholds"
+    )
+
     col1, col2 = st.columns(2)
-    
+
     with col1:
         case_id = st.text_input("Case ID", value="TEST-001")
         case_type = st.selectbox("Case Type", ["CIVIL", "CRIMINAL", "WRIT", "PIL"])
-        case_stage = st.selectbox("Current Stage", ["PRE-TRIAL", "TRIAL", "POST-TRIAL", "FINAL DISPOSAL"])
-        
+        case_stage = st.selectbox(
+            "Current Stage", ["PRE-TRIAL", "TRIAL", "POST-TRIAL", "FINAL DISPOSAL"]
+        )
+
     with col2:
-        service_hearings_count = st.number_input("Service Hearings", min_value=0, max_value=20, value=3)
+        service_hearings_count = st.number_input(
+            "Service Hearings", min_value=0, max_value=20, value=3
+        )
         days_in_stage = st.number_input("Days in Stage", min_value=0, max_value=365, value=45)
         case_age = st.number_input("Case Age (days)", min_value=0, max_value=3650, value=120)
-    
+
     # Keywords
     has_keywords = st.multiselect(
         "Keywords Found",
-        options=["reply filed", "affidavit filed", "arguments complete", "evidence complete", "written note"],
+        options=[
+            "reply filed",
+            "affidavit filed",
+            "arguments complete",
+            "evidence complete",
+            "written note",
+        ],
         default=[],
     )
-    
+
     if st.button("Classify Case"):
         # Create synthetic case
         today = date.today()
         filed_date = today - timedelta(days=case_age)
-        
+
         test_case = Case(
             case_id=case_id,
-            case_type=CaseType(case_type),
+            case_type=case_type,  # Use string directly instead of CaseType enum
             filed_date=filed_date,
             current_stage=case_stage,
             status=CaseStatus.PENDING,
         )
-        
-        # Simulate service hearings
-        test_case.hearings_history = [
-            {"date": filed_date + timedelta(days=i*20), "type": "SERVICE"}
-            for i in range(service_hearings_count)
-        ]
-        
-        # Classify using current thresholds
-        # Note: This is a simplified classification for demo purposes
-        # The actual RipenessClassifier has more complex logic
-        
-        criteria_passed = []
-        criteria_failed = []
-        
-        # Check service hearings
-        if service_hearings_count >= min_service_hearings:
-            criteria_passed.append(f"✓ Service hearings: {service_hearings_count} (threshold: {min_service_hearings})")
-        else:
-            criteria_failed.append(f"✗ Service hearings: {service_hearings_count} (threshold: {min_service_hearings})")
-        
-        # Check case age
-        if case_age >= min_case_age_days:
-            criteria_passed.append(f"✓ Case age: {case_age} days (threshold: {min_case_age_days})")
-        else:
-            criteria_failed.append(f"✗ Case age: {case_age} days (threshold: {min_case_age_days})")
-        
-        # Check stage days
-        stage_threshold = stage_rules.get(case_stage, {}).get("min_days", min_stage_days)
-        if days_in_stage >= stage_threshold:
-            criteria_passed.append(f"✓ Stage days: {days_in_stage} (threshold: {stage_threshold} for {case_stage})")
-        else:
-            criteria_failed.append(f"✗ Stage days: {days_in_stage} (threshold: {stage_threshold} for {case_stage})")
-        
-        # Check keywords
-        expected_keywords = stage_rules.get(case_stage, {}).get("keywords", [])
-        keywords_found = [kw for kw in has_keywords if kw in expected_keywords]
-        if keywords_found:
-            criteria_passed.append(f"✓ Keywords: {', '.join(keywords_found)}")
-        else:
-            criteria_failed.append(f"✗ No relevant keywords found")
-        
-        # Final classification
-        if len(criteria_failed) == 0:
-            classification = "RIPE"
-            color = "green"
-        elif len(criteria_failed) <= 1:
-            classification = "UNKNOWN"
-            color = "orange"
-        else:
-            classification = "UNRIPE"
-            color = "red"
-        
-        # Display results
-        st.markdown("### Classification Result")
-        st.markdown(f":{color}[**{classification}**]")
-        
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            st.markdown("#### Criteria Passed")
-            for criterion in criteria_passed:
-                st.markdown(criterion)
-        
-        with col2:
-            st.markdown("#### Criteria Failed")
-            if criteria_failed:
-                for criterion in criteria_failed:
-                    st.markdown(criterion)
-            else:
-                st.markdown("*All criteria passed*")
-        
-        # Feature importance
-        st.markdown("---")
-        st.markdown("### Feature Importance")
-        
-        feature_scores = {
-            "Service Hearings": 1 if service_hearings_count >= min_service_hearings else 0,
-            "Case Age": 1 if case_age >= min_case_age_days else 0,
-            "Stage Days": 1 if days_in_stage >= stage_threshold else 0,
-            "Keywords": 1 if keywords_found else 0,
-        }
-        
-        fig = px.bar(
-            x=list(feature_scores.keys()),
-            y=list(feature_scores.values()),
-            labels={"x": "Feature", "y": "Score (0=Fail, 1=Pass)"},
-            title="Feature Contribution to Ripeness",
-            color=list(feature_scores.values()),
-            color_continuous_scale=["red", "green"],
+
+        # Populate aggregates and optional purpose based on selected keywords
+        test_case.hearing_count = service_hearings_count
+        test_case.days_in_stage = int(days_in_stage)
+        test_case.age_days = int(case_age)
+        test_case.last_hearing_purpose = has_keywords[0] if has_keywords else None
+
+        # Use the real classifier
+        status = RipenessClassifier.classify(test_case)
+        reason = RipenessClassifier.get_ripeness_reason(status)
+
+        color = (
+            "green"
+            if status == RipenessStatus.RIPE
+            else ("red" if status.is_unripe() else "orange")
         )
-        fig.update_layout(height=400, showlegend=False)
-        st.plotly_chart(fig, use_container_width=True)
+        st.markdown("### Classification Result")
+        st.markdown(f":{color}[**{status.value}**]")
+        st.caption(reason)
 
 with tab3:
     st.markdown("### Batch Classification Analysis")
-    
-    st.markdown("Load generated test cases and classify them with current thresholds")
-    
+
+    st.markdown(
+        "Load generated test cases and classify them with current thresholds (core classifier)"
+    )
+
     if st.button("Load & Classify Test Cases"):
         with st.spinner("Loading cases..."):
             try:
                 cases = load_generated_cases()
-                
+
+                if use_history:
+                    hearings_df = load_generated_hearings()
+                    cases = attach_history_to_cases(cases, hearings_df)
+
                 if not cases:
-                    st.warning("No test cases found. Generate cases first: `uv run court-scheduler generate`")
+                    st.warning(
+                        "No test cases found. Generate cases first: `uv run court-scheduler generate`"
+                    )
                 else:
                     st.success(f"Loaded {len(cases)} test cases")
-                    
-                    # Classify all cases (simplified)
+
+                    # Classify all cases using the core classifier
                     classifications = {"RIPE": 0, "UNRIPE": 0, "UNKNOWN": 0}
-                    
-                    # For demo, use simplified logic
+
+                    today = date.today()
                     for case in cases:
-                        service_count = len([h for h in case.hearings_history if h.get("type") == "SERVICE"])
-                        case_age_days = (date.today() - case.filed_date).days
-                        
-                        criteria_met = 0
-                        if service_count >= min_service_hearings:
-                            criteria_met += 1
-                        if case_age_days >= min_case_age_days:
-                            criteria_met += 1
-                        
-                        if criteria_met == 2:
+                        # Ensure aggregates are available
+                        case.age_days = (today - case.filed_date).days
+                        if getattr(case, "stage_start_date", None):
+                            case.days_in_stage = (today - case.stage_start_date).days
+                        else:
+                            case.days_in_stage = case.age_days
+
+                        status = RipenessClassifier.classify(case)
+                        if status == RipenessStatus.RIPE:
                             classifications["RIPE"] += 1
-                        elif criteria_met == 1:
+                        elif status == RipenessStatus.UNKNOWN:
                             classifications["UNKNOWN"] += 1
                         else:
                             classifications["UNRIPE"] += 1
-                    
+
                     # Display results
                     col1, col2, col3 = st.columns(3)
-                    
+
                     with col1:
                         pct = classifications["RIPE"] / len(cases) * 100
                         st.metric("RIPE Cases", f"{classifications['RIPE']:,}", f"{pct:.1f}%")
-                    
+
                     with col2:
                         pct = classifications["UNKNOWN"] / len(cases) * 100
                         st.metric("UNKNOWN Cases", f"{classifications['UNKNOWN']:,}", f"{pct:.1f}%")
-                    
+
                     with col3:
                         pct = classifications["UNRIPE"] / len(cases) * 100
                         st.metric("UNRIPE Cases", f"{classifications['UNRIPE']:,}", f"{pct:.1f}%")
-                    
+
                     # Pie chart
                     fig = px.pie(
                         values=list(classifications.values()),
@@ -334,7 +305,7 @@ with tab3:
                         color_discrete_map={"RIPE": "green", "UNKNOWN": "orange", "UNRIPE": "red"},
                     )
                     st.plotly_chart(fig, use_container_width=True)
-                    
+
             except Exception as e:
                 st.error(f"Error loading cases: {e}")