added option to choose tracks

src/curriculum_analyzer.py

@@ -1,11 +1,19 @@
+#!/usr/bin/env python3
 """
-Fixed Curriculum Analyzer - Better handling of incomplete data
+FIXED Curriculum Analyzer - Production Version
+
+Synchronized with optimizer logic:
+1.  Filters subjects to ONLY: CS, DS, CY, MATH, PHYS, ENGW.
+2.  Removes IS, EECE, STAT, and other irrelevant subjects.
+3.  ADDS exception for undergrad-accessible 5000-level courses (CS5700).
+4.  FIXES bad prerequisite data (e.g., CS2500 -> CS2800).
 """
 import pickle
 import argparse
 import networkx as nx
 import re
 from typing import Set, Dict
+from collections import defaultdict
 
 def get_course_level(cid):
     """Extracts the numerical part of a course ID for level checking."""
@@ -13,13 +21,27 @@ def get_course_level(cid):
     return int(match.group(0)) if match else 9999
 
 class CurriculumAnalyzer:
+    
+    # --- FIX 1: DEFINE LISTS THAT MATCH THE OPTIMIZER ---
+    
+    # Subjects the optimizer is programmed to understand.
+    # ENGW/PHYS are needed only for hardcoded Year 1.
+    KEEP_SUBJECTS = {"CS", "DS", "CY", "MATH", "PHYS", "ENGW"}
+    
+    # 5000-level courses the optimizer explicitly allows.
+    UNDERGRAD_ACCESSIBLE_GRAD = {"CS5700", "CY5700", "DS5110", "CS5010"}
+
     def __init__(self, graph_path, courses_path):
         print("📚 Loading raw curriculum data...")
-        with open(graph_path, 'rb') as f:
-            self.graph = pickle.load(f)
-        with open(courses_path, 'rb') as f:
-            self.courses = pickle.load(f)
-        
+        try:
+            with open(graph_path, 'rb') as f:
+                self.graph = pickle.load(f)
+            with open(courses_path, 'rb') as f:
+                self.courses = pickle.load(f)
+        except Exception as e:
+            print(f"❌ ERROR: Could not load files. {e}")
+            exit(1)
+            
         # Merge course data into graph nodes
         for course_id, course_data in self.courses.items():
             if self.graph.has_node(course_id):
@@ -28,44 +50,65 @@ class CurriculumAnalyzer:
         print(f"✅ Loaded {self.graph.number_of_nodes()} courses, {self.graph.number_of_edges()} edges")
 
     def pre_filter_graph(self):
-        """Keeps only relevant subjects and removes labs/high-level courses."""
+        """
+        --- FIX 2: IMPLEMENTS STRICT FILTERING ---
+        Keeps only relevant subjects and removes labs/high-level courses.
+        """
         print("\n🧹 Pre-filtering graph...")
         
-        KEEP_SUBJECTS = {"CS", "DS", "IS", "CY", "MATH", "PHYS", "ENGW", "STAT", "EECE"}
-        
         nodes_to_remove = set()
         for node, data in self.graph.nodes(data=True):
             subject = data.get('subject', '')
             name = data.get('name', '').lower()
             level = get_course_level(node)
             
-            # Remove if:
-            # - Not in whitelist
-            # - Too advanced (5000+)
-            # - Lab/recitation/etc
-            if (subject not in KEEP_SUBJECTS or
-                level >= 5000 or
-                any(skip in name for skip in ['lab', 'recitation', 'seminar', 'practicum', 'co-op'])):
+            # Check for removal
+            is_irrelevant_subject = subject not in self.KEEP_SUBJECTS
+            is_lab_or_seminar = any(skip in name for skip in ['lab', 'recitation', 'seminar', 'practicum', 'co-op'])
+            
+            # Grad-level check
+            is_grad_level = level >= 5000
+            is_allowed_grad = node in self.UNDERGRAD_ACCESSIBLE_GRAD
+            
+            if (is_irrelevant_subject or 
+                is_lab_or_seminar or
+                (is_grad_level and not is_allowed_grad)): # <-- Bug fix
                 nodes_to_remove.add(node)
         
+        original_count = self.graph.number_of_nodes()
         self.graph.remove_nodes_from(nodes_to_remove)
-        print(f"✅ Removed {len(nodes_to_remove)} irrelevant courses")
-        print(f"   Remaining: {self.graph.number_of_nodes()} courses")
+        
+        print(f"✅ Removed {len(nodes_to_remove)} irrelevant courses (IS, EECE, etc.)")
+        print(f"   Original nodes: {original_count}")
+        print(f"   Remaining nodes: {self.graph.number_of_nodes()}")
 
     def fix_chains(self):
         """Adds critical prerequisite chains that might be missing."""
         print("\n🔗 Validating and fixing critical prerequisite chains...")
         
         critical_chains = {
+            # Foundations
             ("CS1800", "CS2800", "Discrete → Logic"),
             ("CS2500", "CS2510", "Fundies 1 → Fundies 2"),
+            # Core CS
             ("CS2510", "CS3500", "Fundies 2 → OOD"),
             ("CS2510", "CS3000", "Fundies 2 → Algorithms"),
-            ("CS3000", "CS4100", "Algorithms → AI"),  # NEW
-            ("MATH1341", "MATH1342", "Calc 1 → Calc 2"),
+            ("CS2800", "CS3000", "Logic → Algorithms"), 
+            
+            # --- THIS IS THE FIX ---
+            ("CS3000", "CS3650", "Algorithms -> Systems"), 
+            # ---------------------
+
+            # Core AI/ML
+            ("CS3000", "CS4100", "Algorithms → AI"),
+            ("CS3500", "CS4100", "OOD → AI"),
+            # Core DS Path
             ("DS2000", "DS2500", "Prog w/ Data → Intermediate"),
             ("DS2500", "DS3500", "Intermediate → Advanced"),
-            ("DS3500", "DS4400", "Advanced → ML1"),  # NEW
+            ("DS3500", "DS4400", "Advanced → ML1"),
+            ("CS3500", "DS4400", "OOD → ML1"),
+            # Math
+            ("MATH1341", "MATH1342", "Calc 1 → Calc 2"),
         }
         
         added = 0
@@ -80,11 +123,18 @@ class CurriculumAnalyzer:
             print("  ✅ All critical chains present")
 
     def remove_spurious_chains(self):
-        """Removes known incorrect prerequisite edges."""
+        """
+        --- FIX 3: REMOVE BAD DATA ---
+        Removes known incorrect prerequisite edges from scraper.
+        """
         print("\n🗑️ Removing spurious prerequisite chains...")
         
+        # Based on your inspect_graph output and catalog knowledge
         spurious_chains = {
-            ("MATH1365", "CS2800"),  # Not a real prereq
+            ("CS2500", "CS2800"),  # Fundies 1 is NOT a prereq for Logic
+            ("MATH1365", "CS2800"), # Not a real prereq
+            ("EECE2160", "CS3000"), # Irrelevant prereq
+            ("EECE2560", "CS3500"), # Irrelevant prereq
         }
         
         removed = 0
@@ -102,6 +152,7 @@ class CurriculumAnalyzer:
         print("\n🧮 Calculating complexity scores...")
         
         for node in self.graph.nodes():
+            # Use predecessors/successors on the *cleaned* graph
             in_degree = self.graph.in_degree(node)
             out_degree = self.graph.out_degree(node)
             
@@ -115,13 +166,14 @@ class CurriculumAnalyzer:
         """Check if all critical courses exist in the graph."""
         print("\n🎯 Validating critical course coverage...")
         
+        # This list MUST match the optimizer's requirements
         required_courses = {
             "foundations": {"CS1800", "CS2500", "CS2510", "CS2800"},
-            "core": {"CS3000", "CS3500", "CS3650", "CS3700", "CS3200"},
+            "core": {"CS3000", "CS3500", "CS3650", "CS3200", "CS5700"}, # Added CS5700
             "ai_ml": {"CS4100", "DS4400", "CS4120", "DS4420", "CS4180", "DS4440"},
-            "systems": {"CS4730", "CS4400", "CS4500"},  # Removed often-missing courses
+            "systems": {"CS4730", "CS4700", "CS4400", "CS4500"},
             "security": {"CY2550", "CY3740", "CY4740", "CY4760"},
-            "math": {"MATH1341", "MATH1342", "MATH2331", "MATH3081"},  # No STAT courses at NEU
+            "math": {"MATH1341", "MATH1342", "MATH2331", "MATH3081"},
         }
         
         missing = {}
@@ -150,14 +202,12 @@ class CurriculumAnalyzer:
             f.write(f"Total courses: {self.graph.number_of_nodes()}\n")
             f.write(f"Total prerequisites: {self.graph.number_of_edges()}\n\n")
             
-            # Subject breakdown
-            from collections import defaultdict
             subject_counts = defaultdict(int)
             for node in self.graph.nodes():
                 subject = self.graph.nodes[node].get('subject', 'UNKNOWN')
                 subject_counts[subject] += 1
             
-            f.write("Subject breakdown:\n")
+            f.write("Subject breakdown (Filtered):\n")
             for subject in sorted(subject_counts.keys()):
                 f.write(f"  {subject}: {subject_counts[subject]}\n")
         
@@ -183,8 +233,8 @@ def main(args):
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="NEU Curriculum Analyzer - Cleans and validates data")
-    parser.add_argument('--graph', required=True, help="Path to RAW curriculum graph")
-    parser.add_argument('--courses', required=True, help="Path to RAW courses data")
-    parser.add_argument('--output-graph', default='neu_graph_clean.pkl', help="Output path")
+    parser.add_argument('--graph', required=True, help="Path to RAW curriculum graph (e.g., neu_merged_graph_...pkl)")
+    parser.add_argument('--courses', required=True, help="Path to RAW courses data (e.g., neu_merged_courses_...pkl)")
+    parser.add_argument('--output-graph', default='neu_graph_clean.pkl', help="Output path for the new, clean graph")
     args = parser.parse_args()
     main(args)

src/curriculum_optimizer.py

@@ -1,513 +1,657 @@
-"""
-Fixed Hybrid Curriculum Optimizer
-WITH PROPER COURSE DISCOVERY, SUBJECT-AWARE SCORING, AND CONCENTRATION FOCUS
-"""
-import torch
-from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
-from sentence_transformers import SentenceTransformer, util
-import networkx as nx
-import numpy as np
-from typing import Dict, List, Set, Tuple, Optional
-from dataclasses import dataclass
-import re
-import json
-import random
-from datetime import datetime
-
-@dataclass
-class StudentProfile:
-    completed_courses: List[str]
-    time_commitment: int
-    preferred_difficulty: str
-    career_goals: str
-    interests: List[str]
-    current_gpa: float = 3.5
-    learning_style: str = "Visual"
-
-class HybridOptimizer:
-    """
-    Fixed optimizer with subject-aware scoring and concentration focus
-    """
-    
-    EQUIVALENCY_GROUPS = [
-        {"MATH1341", "MATH1241", "MATH1231"}, # Calculus 1
-        {"MATH1342", "MATH1242"},             # Calculus 2
-        {"PHYS1151", "PHYS1161", "PHYS1145"}, # Physics 1
-        {"PHYS1155", "PHYS1165", "PHYS1147"}, # Physics 2
-    ]
-    COURSE_TRACKS = {
-        "physics": {
-            "engineering": ["PHYS1151", "PHYS1155"],
-            "science": ["PHYS1161", "PHYS1165"], 
-            "life_sciences": ["PHYS1145", "PHYS1147"]
-        },
-        "calculus": {
-            "standard": ["MATH1341", "MATH1342"],
-            "computational": ["MATH156", "MATH256"]
-        }
-    }
-    
-    CONCENTRATION_REQUIREMENTS = {
-        "ai_ml": {
-            "foundations": {
-                "required": ["CS1800", "CS2500", "CS2510", "CS2800"],
-                "sequence": True
-            },
-            "core": {
-                "required": ["CS3000", "CS3500"],
-                "pick_1_from": ["CS3200", "CS3650", "CS5700"]
-            },
-            "concentration_specific": {
-                "required": ["CS4100", "DS4400"],
-                "pick_2_from": ["CS4120", "CS4180", "DS4420", "DS4440"],
-                "pick_1_systems": ["CS4730", "CS4700"]
-            },
-            "math": {
-                "required": ["MATH1341", "MATH1342"],
-                "pick_1_from": ["MATH2331", "MATH3081"]
-            }
-        },
-        "systems": {
-            "foundations": { "required": ["CS1800", "CS2500", "CS2510", "CS2800"] },
-            "core": { "required": ["CS3000", "CS3500", "CS3650"], "pick_1_from": ["CS5700", "CS3200"] },
-            "concentration_specific": { "required": ["CS4700"], "pick_2_from": ["CS4730"], "pick_1_from": ["CS4400", "CS4500", "CS4520"] },
-            "math": { "required": ["MATH1341", "MATH1342"] }
-        },
-        "security": {
-            "foundations": { "required": ["CS1800", "CS2500", "CS2510", "CS2800"] },
-            "core": { "required": ["CS3000", "CS3650", "CY2550"], "pick_1_from": ["CS5700", "CS3500"] },
-            "concentration_specific": { "required": ["CY3740"], "pick_2_from": ["CY4740", "CY4760", "CY4770"], "pick_1_from": ["CS4700", "CS4730"] },
-            "math": { "required": ["MATH1342"], "pick_1_from": ["MATH3527", "MATH3081"] }
-        }
-    }
-    
-    def __init__(self):
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        self.model_name = "meta-llama/Llama-3.1-8B-Instruct"
-        self.embedding_model_name = 'BAAI/bge-large-en-v1.5'
-        self.llm = None
-        self.tokenizer = None
-        self.embedding_model = None
-        self.curriculum_graph = None
-        self.courses = {}
-        self.current_student = None
-
-    def load_models(self):
-        print("Loading embedding model...")
-        self.embedding_model = SentenceTransformer(self.embedding_model_name, device=self.device)
-        
-    def load_llm(self):
-        if self.device.type == 'cuda' and self.llm is None:
-            print("Loading LLM for intelligent planning...")
-            quant_config = BitsAndBytesConfig(
-                load_in_4bit=True,
-                bnb_4bit_quant_type="nf4",
-                bnb_4bit_compute_dtype=torch.bfloat16
-            )
-            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
-            self.tokenizer.pad_token = self.tokenizer.eos_token
-            self.llm = AutoModelForCausalLM.from_pretrained(
-                self.model_name,
-                quantization_config=quant_config,
-                device_map="auto"
-            )
-            
-    def load_data(self, graph: nx.DiGraph):
-        self.curriculum_graph = graph
-        self.courses = dict(graph.nodes(data=True))
-        UNDERGRAD_ACCESSIBLE_GRAD = {"CS5700", "CY5700", "DS5110", "CS5010"}
-        self.valid_courses = []
-        course_texts = []
-        
-        concentration_courses = set()
-        for track_reqs in self.CONCENTRATION_REQUIREMENTS.values():
-            for category, reqs in track_reqs.items():
-                if isinstance(reqs, dict):
-                    for key, courses in reqs.items():
-                        if isinstance(courses, list):
-                            concentration_courses.update(courses)
-        
-        for cid, data in self.courses.items():
-            name = data.get('name', '')
-            if not name or name.strip() == '' or any(skip in name.lower() for skip in ['lab', 'recitation', 'seminar', 'practicum']):
-                continue
-            
-            course_level = self._get_level(cid)
-            if course_level >= 5000 and cid not in UNDERGRAD_ACCESSIBLE_GRAD:
-                continue
-                
-            self.valid_courses.append(cid)
-            course_texts.append(f"{name} {data.get('description', '')}")
-        
-        missing_required = concentration_courses - set(self.valid_courses)
-        if missing_required:
-            print(f"\n⚠️ WARNING: {len(missing_required)} required courses missing from graph: {sorted(missing_required)}\n")
-
-        print(f"Computing embeddings for {len(self.valid_courses)} courses...")
-        self.course_embeddings = self.embedding_model.encode(course_texts, convert_to_tensor=True, show_progress_bar=True)
-        print(f"\nTotal valid courses: {len(self.valid_courses)}")
-
-    def _get_level(self, course_id: str) -> int:
-        match = re.search(r'\d+', course_id)
-        return int(match.group()) if match else 9999
-
-    def _get_completed_with_equivalents(self, completed: Set[str]) -> Set[str]:
-        expanded_completed = completed.copy()
-        for course in completed:
-            for group in self.EQUIVALENCY_GROUPS:
-                if course in group:
-                    expanded_completed.update(group)
-        return expanded_completed
-
-    def _can_take_course(self, course_id: str, completed: Set[str]) -> bool:
-        effective_completed = self._get_completed_with_equivalents(completed)
-        if course_id not in self.curriculum_graph:
-            return True
-        prereqs = set(self.curriculum_graph.predecessors(course_id))
-        return prereqs.issubset(effective_completed)
-
-    def _validate_sequence(self, selected: List[str], candidate: str) -> bool:
-        for track_type, tracks in self.COURSE_TRACKS.items():
-            for track_name, sequence in tracks.items():
-                if candidate in sequence:
-                    for other_track, other_seq in tracks.items():
-                        if other_track != track_name and any(c in selected for c in other_seq):
-                            return False
-        return True
-
-    def _score_course(self, course_id: str, semantic_scores: Dict[str, float], required_set: Set[str], picklist_set: Set[str]) -> float:
-        """FIXED: Proper scoring with IS heavy penalty"""
-        
-        if course_id not in self.courses or not self.courses[course_id].get('name', '').strip():
-            return -10000.0
-        
-        course_data = self.courses[course_id]
-        subject = course_data.get('subject', '')
-        
-        score = 0.0
-        
-        # Subject bonuses/penalties
-        if subject in ["CS", "DS", "CY"]:
-            score += 300.0
-        elif subject == "MATH":
-            score += 100.0
-        else:
-            score -= 1000.0  # Heavy penalty for everything else (including IS)
-        
-        # Required courses: massive boost
-        if course_id in required_set:
-            score += 10000.0  # INCREASED from 1000
-        
-        # Pick-list courses: high boost
-        if course_id in picklist_set:
-            score += 5000.0  # INCREASED from 500
-        
-        # Unlocking factor (reduced weight)
-        if course_id in self.curriculum_graph:
-            unlocks = self.curriculum_graph.out_degree(course_id)
-            score += min(unlocks, 5) * 2.0  # REDUCED
-        
-        # Level preference
-        level = self._get_level(course_id)
-        score -= (level / 100.0)
-        
-        # Semantic alignment (reduced weight)
-        score += semantic_scores.get(course_id, 0.0) * 5.0  # REDUCED from 15
-        
-        return score
-
-    def generate_simple_plan(self, student: StudentProfile) -> Dict:
-        print("--- Generating Enhanced Rule-Based Plan ---")
-        self.current_student = student
-        return self.generate_enhanced_rule_plan(student)
-        
-    def generate_enhanced_rule_plan(self, student: StudentProfile) -> Dict:
-        self.current_student = student
-        track = self._identify_track(student)
-        plan = self._build_structured_plan(student, track, None)
-        validation = self.validate_plan(plan, student)
-        
-        if validation["errors"]:
-            plan = self._fix_plan_errors(plan, validation, student)
-            validation = self.validate_plan(plan, student)
-        
-        difficulty_level = self._map_difficulty(student.preferred_difficulty)
-        courses_per_semester = self._calculate_course_load(student.time_commitment)
-        explanation = f"Personalized {track} track ({difficulty_level} difficulty, {courses_per_semester} courses/semester)"
-        
-        return self._finalize_plan(plan, explanation, validation)
-
-    def generate_llm_plan(self, student: StudentProfile) -> Dict:
-        print("--- Generating AI-Optimized Plan ---")
-        self.current_student = student
-        self.load_llm()
-        if not self.llm:
-            return self.generate_enhanced_rule_plan(student)
-        
-        track = self._identify_track(student)
-        llm_suggestions = self._get_llm_course_suggestions(student, track)
-        plan = self._build_structured_plan(student, track, llm_suggestions)
-        validation = self.validate_plan(plan, student)
-        if validation["errors"]:
-            plan = self._fix_plan_errors(plan, validation, student)
-            validation = self.validate_plan(plan, student)
-        
-        explanation = self._generate_explanation(student, plan, track, "AI-optimized")
-        return self._finalize_plan(plan, explanation, validation)
-        
-    def _build_structured_plan(self, student: StudentProfile, track: str, llm_suggestions: Optional[List[str]] = None) -> Dict:
-        """FIXED with hardcoded Year 2 priorities"""
-        
-        completed = set(student.completed_courses)
-        plan = {}
-        requirements = self.CONCENTRATION_REQUIREMENTS.get(track, self.CONCENTRATION_REQUIREMENTS["ai_ml"])
-        
-        courses_per_semester = self._calculate_course_load(student.time_commitment)
-        
-        # Build required and pick sets
-        required_set = set()
-        picklist_set = set()
-        for category, reqs in requirements.items():
-            if "required" in reqs:
-                required_set.update(reqs["required"])
-            for key, courses in reqs.items():
-                if key.startswith("pick_"):
-                    picklist_set.update(courses)
-        
-        semantic_scores = self._compute_semantic_scores(student)
-        
-        # HARDCODED FIX: Force Year 2 to prioritize core courses
-        YEAR2_MUST_TAKE = ["CS3000", "CS3500", "DS2500", "MATH2331", "MATH3081"]
-        
-        for sem_num in range(1, 9):
-            year = ((sem_num - 1) // 2) + 1
-            
-            available_courses = self._get_available_courses(completed, year, sem_num, track)
-            
-            # Filter: must be takeable
-            schedulable = [
-                c for c in available_courses
-                if c not in completed and self._can_take_course(c, completed)
-            ]
-            
-            # HARDCODED: In Year 2, force core courses to the top
-            if year == 2:
-                priority_courses = [c for c in YEAR2_MUST_TAKE if c in schedulable]
-                other_courses = [c for c in schedulable if c not in YEAR2_MUST_TAKE]
-                
-                # Score priority courses separately
-                scored_priority = sorted(
-                    priority_courses,
-                    key=lambda c: self._score_course(c, semantic_scores, required_set, picklist_set),
-                    reverse=True
-                )
-                scored_others = sorted(
-                    other_courses,
-                    key=lambda c: self._score_course(c, semantic_scores, required_set, picklist_set),
-                    reverse=True
-                )
-                
-                scored_courses = scored_priority + scored_others
-            else:
-                # Normal scoring for other years
-                scored_courses = sorted(
-                    schedulable,
-                    key=lambda c: self._score_course(c, semantic_scores, required_set, picklist_set),
-                    reverse=True
-                )
-            
-            # Select top N courses
-            selected = []
-            for course in scored_courses:
-                if len(selected) >= courses_per_semester:
-                    break
-                if self._validate_sequence(selected, course):
-                    selected.append(course)
-            
-            # Add to plan
-            if selected:
-                year_key = f"year_{year}"
-                if year_key not in plan:
-                    plan[year_key] = {}
-                
-                sem_type = 'fall' if (sem_num % 2) == 1 else 'spring'
-                plan[year_key][sem_type] = selected
-                completed.update(selected)
-        
-        return plan
-
-    def _get_available_courses(self, completed: Set[str], year: int, sem_num: int = None, track: str = "ai_ml") -> List[str]:
-        """FIXED: Return ALL courses that COULD be taken in this year"""
-        
-        # Year 1: Hardcoded foundation
-        if year == 1:
-            if not completed or len(completed) < 2:
-                return [c for c in ["CS1800", "CS2500", "MATH1341", "ENGW1111"] if c in self.valid_courses]
-            else:
-                next_courses = []
-                for course, prereq in [("CS2800", "CS1800"), ("CS2510", "CS2500"), ("MATH1342", "MATH1341"), ("DS2000", None)]:
-                    if course in self.valid_courses and course not in completed:
-                        if prereq is None or prereq in completed:
-                            next_courses.append(course)
-                return next_courses
-        
-        # Years 2-4: Filter by subject and level
-        available = []
-        
-        # ONLY CS/DS/CY/MATH allowed
-        ALLOWED_SUBJECTS = {"CS", "DS", "CY", "MATH"}
-        
-        for cid in self.valid_courses:
-            if cid in completed:
-                continue
-            
-            course_data = self.courses.get(cid, {})
-            subject = course_data.get('subject')
-            
-            if subject not in ALLOWED_SUBJECTS:
-                continue
-            
-            course_level = self._get_level(cid)
-            
-            # Year-based level filtering
-            if year == 2 and course_level > 3999:
-                continue  # No 4000+ in Year 2
-            if year >= 3 and course_level < 2000:
-                continue  # No intro courses in Years 3-4
-            
-            available.append(cid)
-        
-        return available
-
-    def _fix_plan_errors(self, plan: Dict, validation: Dict, student: StudentProfile) -> Dict:
-        if any("Mixed" in error for error in validation["errors"]):
-            return self._build_structured_plan(student, self._identify_track(student), None)
-        return plan
-        
-    def _get_llm_course_suggestions(self, student: StudentProfile, track: str) -> List[str]:
-        requirements = self.CONCENTRATION_REQUIREMENTS.get(track, {})
-        all_options = set()
-        for reqs in requirements.values():
-            for key, courses in reqs.items():
-                if key.startswith("pick_"): all_options.update(courses)
-        
-        course_options_text = [f"{cid}: {self.courses[cid].get('name', cid)} - {self.courses[cid].get('description', '')[:100].strip()}"
-                               for cid in list(all_options)[:15] if cid in self.courses]
-        
-        prompt = f"""You are an expert curriculum advisor. Based on the student profile, rank the top 5 most relevant courses from the list below.
-### Student Profile:
-- **Career Goal:** {student.career_goals}
-- **Interests:** {', '.join(student.interests)}
-- **Preferred Difficulty:** {student.preferred_difficulty}
-### Available Elective Courses:
-{chr(10).join(course_options_text)}
-Return ONLY the top 5 course IDs, each on a new line.
-"""
-        try:
-            inputs = self.tokenizer(prompt, return_tensors="pt", truncation=True, max_length=4096).to(self.device)
-            with torch.no_grad():
-                outputs = self.llm.generate(**inputs, max_new_tokens=100, temperature=0.2, do_sample=True, pad_token_id=self.tokenizer.eos_token_id)
-            response = self.tokenizer.decode(outputs[0][len(inputs['input_ids'][0]):], skip_special_tokens=True)
-            suggested_courses = re.findall(r'([A-Z]{2,4}\d{4})', response)
-            return suggested_courses[:5]
-        except Exception as e:
-            print(f"LLM suggestion failed: {e}")
-            return list(all_options)[:5]
-
-    def _map_difficulty(self, preferred_difficulty: str) -> str:
-        return {"easy": "easy", "moderate": "medium", "challenging": "hard"}.get(preferred_difficulty.lower(), "medium")
-        
-    def _calculate_course_load(self, time_commitment: int) -> int:
-        if time_commitment <= 20: return 3
-        if time_commitment <= 40: return 4 # Setting hours to 40 will now correctly return 4.
-        return 5
-        
-    def _identify_track(self, student: StudentProfile) -> str:
-        if not hasattr(self, 'embedding_model') or self.embedding_model is None:
-            combined = f"{student.career_goals.lower()} {' '.join(student.interests).lower()}"
-            if any(word in combined for word in ['ai', 'ml', 'machine learning', 'data']): return "ai_ml"
-            if any(word in combined for word in ['systems', 'distributed', 'backend']): return "systems"
-            if any(word in combined for word in ['security', 'cyber']): return "security"
-            return "ai_ml"
-        profile_text = f"{student.career_goals} {' '.join(student.interests)}"
-        profile_emb = self.embedding_model.encode(profile_text, convert_to_tensor=True)
-        track_descriptions = {
-            "ai_ml": "artificial intelligence machine learning deep learning neural networks data science",
-            "systems": "operating systems distributed systems networks compilers databases performance backend",
-            "security": "cybersecurity cryptography network security ethical hacking vulnerabilities"
-        }
-        best_track, best_score = "ai_ml", -1.0
-        for track, description in track_descriptions.items():
-            track_emb = self.embedding_model.encode(description, convert_to_tensor=True)
-            score = float(util.cos_sim(profile_emb, track_emb))
-            if score > best_score:
-                best_score, best_track = score, track
-        return best_track
-        
-    def _compute_semantic_scores(self, student: StudentProfile) -> Dict[str, float]:
-        query_text = f"{student.career_goals} {' '.join(student.interests)}"
-        query_emb = self.embedding_model.encode(query_text, convert_to_tensor=True)
-        similarities = util.cos_sim(query_emb, self.course_embeddings)[0]
-        return {cid: float(similarities[idx]) for idx, cid in enumerate(self.valid_courses)}
-        
-    def _generate_explanation(self, student: StudentProfile, plan: Dict, track: str, plan_type: str) -> str:
-        return f"{plan_type.title()} plan for the {track} track, tailored to your goal of becoming a {student.career_goals}."
-
-    def validate_plan(self, plan: Dict, student: StudentProfile = None) -> Dict[str, List[str]]:
-        issues = {"errors": [], "warnings": [], "info": []}
-        all_courses = [course for year in plan.values() for sem in year.values() for course in sem if isinstance(sem, list)]
-        
-        for track_type, tracks in self.COURSE_TRACKS.items():
-            tracks_used = {name for name, courses in tracks.items() if any(c in all_courses for c in courses)}
-            if len(tracks_used) > 1:
-                issues["errors"].append(f"Mixed {track_type} tracks: {', '.join(tracks_used)}. Choose one sequence.")
-
-        completed_for_validation = set(student.completed_courses) if student else set()
-        for year in range(1, 5):
-            for sem in ["fall", "spring"]:
-                year_key = f"year_{year}"
-                sem_courses = plan.get(year_key, {}).get(sem, [])
-                for course in sem_courses:
-                    if course in self.curriculum_graph:
-                        prereqs = set(self.curriculum_graph.predecessors(course))
-                        if not prereqs.issubset(self._get_completed_with_equivalents(completed_for_validation)):
-                            missing = prereqs - completed_for_validation
-                            issues["errors"].append(f"{course} in Year {year} {sem} is missing prereqs: {', '.join(missing)}")
-                completed_for_validation.update(sem_courses)
-        return issues
-
-    def _finalize_plan(self, plan: Dict, explanation: str, validation: Dict = None) -> Dict:
-        structured_plan = {"reasoning": explanation, "validation": validation or {"errors": [], "warnings": [], "info": []}}
-        complexities = []
-        for year in range(1, 5):
-            year_key = f"year_{year}"
-            structured_plan[year_key] = {
-                "fall": plan.get(year_key, {}).get("fall", []),
-                "spring": plan.get(year_key, {}).get("spring", []),
-                "summer": "co-op" if year in [2, 3] else []
-            }
-            for sem in ["fall", "spring"]:
-                courses = structured_plan[year_key][sem]
-                if courses:
-                    sem_complexity = sum(self.courses.get(c, {}).get('complexity', 50) for c in courses)
-                    complexities.append(sem_complexity)
-        
-        structured_plan["complexity_analysis"] = {
-            "average_semester_complexity": float(np.mean(complexities)) if complexities else 0,
-            "peak_semester_complexity": float(np.max(complexities)) if complexities else 0,
-            "total_complexity": float(np.sum(complexities)) if complexities else 0,
-            "balance_score (std_dev)": float(np.std(complexities)) if complexities else 0
-        }
-        structured_plan["metadata"] = {
-            "generated": datetime.now().isoformat(),
-            "valid": len(validation.get("errors", [])) == 0 if validation else True,
-        }
-        return {"pathway": structured_plan}
-
-class CurriculumOptimizer(HybridOptimizer):
-    """Wrapper to maintain compatibility with older script calls."""
-    def __init__(self):
-        super().__init__()
-    
-    def generate_plan(self, student: StudentProfile) -> Dict:
-        return self.generate_enhanced_rule_plan(student)
+"""
+Curriculum Optimizer - PRODUCTION VERSION
+All redundant code removed, all critical issues fixed
+"""
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from sentence_transformers import SentenceTransformer, util
+import networkx as nx
+import numpy as np
+from typing import Dict, List, Set, Optional
+from dataclasses import dataclass
+import re
+from datetime import datetime
+
+@dataclass
+class StudentProfile:
+    completed_courses: List[str]
+    time_commitment: int
+    preferred_difficulty: str
+    career_goals: str
+    interests: List[str]
+    current_gpa: float = 3.5
+    learning_style: str = "Visual"
+
+class HybridOptimizer:
+    
+    EQUIVALENCY_GROUPS = [
+        {"MATH1341", "MATH1241", "MATH1231"},
+        {"MATH1342", "MATH1242"},
+        {"PHYS1151", "PHYS1161", "PHYS1145"},
+        {"PHYS1155", "PHYS1165", "PHYS1147"},
+    ]
+    
+    COURSE_TRACKS = {
+        "physics": {
+            "engineering": ["PHYS1151", "PHYS1155"],
+            "science": ["PHYS1161", "PHYS1165"], 
+            "life_sciences": ["PHYS1145", "PHYS1147"]
+        },
+        "calculus": {
+            "standard": ["MATH1341", "MATH1342"],
+            "computational": ["MATH156", "MATH256"]
+        }
+    }
+    
+    CONCENTRATION_REQUIREMENTS = {
+        "ai_ml": {
+            "foundations": {
+                "required": ["CS1800", "CS2500", "CS2510", "CS2800"],
+                "sequence": True
+            },
+            "core": {
+                "required": ["CS3000", "CS3500"],
+                "pick_1_from": ["CS3200", "CS3650", "CS5700"]
+            },
+            "concentration_specific": {
+                "required": ["CS4100", "DS4400"],
+                "pick_2_from": ["CS4120", "CS4180", "DS4420", "DS4440"],
+                "pick_1_systems": ["CS4730", "CS4700"]
+            },
+            "math": {
+                "required": ["MATH1341", "MATH1342"],
+                "pick_1_from": ["MATH2331", "MATH3081"]
+            }
+        },
+        "systems": {
+            "foundations": {"required": ["CS1800", "CS2500", "CS2510", "CS2800"]},
+            "core": {"required": ["CS3000", "CS3500", "CS3650"], "pick_1_from": ["CS5700", "CS3200"]},
+            "concentration_specific": {"required": ["CS4700"], "pick_2_from": ["CS4730"], "pick_1_from": ["CS4400", "CS4500", "CS4520"]},
+            "math": {"required": ["MATH1341", "MATH1342"]}
+        },
+        "security": {
+            "foundations": {"required": ["CS1800", "CS2500", "CS2510", "CS2800"]},
+            "core": {"required": ["CS3000", "CS3650", "CY2550"], "pick_1_from": ["CS5700", "CS3500"]},
+            "concentration_specific": {"required": ["CY3740"], "pick_2_from": ["CY4740", "CY4760", "CY4770"], "pick_1_from": ["CS4700", "CS4730"]},
+            "math": {"required": ["MATH1342"], "pick_1_from": ["MATH3527", "MATH3081"]}
+        }
+    }
+    
+    def __init__(self):
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model_name = "meta-llama/Llama-3.1-8B-Instruct"
+        self.embedding_model_name = 'BAAI/bge-large-en-v1.5'
+        self.llm = None
+        self.tokenizer = None
+        self.embedding_model = None
+        self.curriculum_graph = None
+        self.courses = {}
+        self.current_student = None
+
+    def load_models(self):
+        print("Loading embedding model...")
+        self.embedding_model = SentenceTransformer(self.embedding_model_name, device=self.device)
+        
+    def load_llm(self):
+        if self.device.type == 'cuda' and self.llm is None:
+            print("Loading LLM for intelligent planning...")
+            quant_config = BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_quant_type="nf4",
+                bnb_4bit_compute_dtype=torch.bfloat16
+            )
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+            self.llm = AutoModelForCausalLM.from_pretrained(
+                self.model_name,
+                quantization_config=quant_config,
+                device_map="auto"
+            )
+            
+    def load_data(self, graph: nx.DiGraph):
+        self.curriculum_graph = graph
+        self.courses = dict(graph.nodes(data=True))
+        UNDERGRAD_ACCESSIBLE_GRAD = {"CS5700", "CY5700", "DS5110", "CS5010"}
+        self.valid_courses = []
+        course_texts = []
+        
+        concentration_courses = set()
+        for track_reqs in self.CONCENTRATION_REQUIREMENTS.values():
+            for category, reqs in track_reqs.items():
+                if isinstance(reqs, dict):
+                    for key, courses in reqs.items():
+                        if isinstance(courses, list):
+                            concentration_courses.update(courses)
+        
+        for cid, data in self.courses.items():
+            name = data.get('name', '')
+            if not name or name.strip() == '' or any(skip in name.lower() for skip in ['lab', 'recitation', 'seminar', 'practicum']):
+                continue
+            
+            course_level = self._get_level(cid)
+            if course_level >= 5000 and cid not in UNDERGRAD_ACCESSIBLE_GRAD:
+                continue
+                
+            self.valid_courses.append(cid)
+            course_texts.append(f"{name} {data.get('description', '')}")
+        
+        missing_required = concentration_courses - set(self.valid_courses)
+        if missing_required:
+            print(f"\n⚠️ WARNING: {len(missing_required)} required courses missing from graph: {sorted(missing_required)}\n")
+
+        print(f"Computing embeddings for {len(self.valid_courses)} courses...")
+        self.course_embeddings = self.embedding_model.encode(course_texts, convert_to_tensor=True, show_progress_bar=True)
+        print(f"\nTotal valid courses: {len(self.valid_courses)}")
+
+    def _get_level(self, course_id: str) -> int:
+        match = re.search(r'\d+', course_id)
+        return int(match.group()) if match else 9999
+
+    def _get_completed_with_equivalents(self, completed: Set[str]) -> Set[str]:
+        expanded_completed = completed.copy()
+        for course in completed:
+            for group in self.EQUIVALENCY_GROUPS:
+                if course in group:
+                    expanded_completed.update(group)
+        return expanded_completed
+
+    def _can_take_course(self, course_id: str, completed: Set[str]) -> bool:
+        effective_completed = self._get_completed_with_equivalents(completed)
+        if course_id not in self.curriculum_graph:
+            return True
+        prereqs = set(self.curriculum_graph.predecessors(course_id))
+        return prereqs.issubset(effective_completed)
+
+    def _validate_sequence(self, selected: List[str], candidate: str) -> bool:
+        for track_type, tracks in self.COURSE_TRACKS.items():
+            for track_name, sequence in tracks.items():
+                if candidate in sequence:
+                    for other_track, other_seq in tracks.items():
+                        if other_track != track_name and any(c in selected for c in other_seq):
+                            return False
+        return True
+
+    def _score_course(self, course_id: str, semantic_scores: Dict[str, float], required_set: Set[str], picklist_set: Set[str], year: int, track: str) -> float:
+        """
+        PRODUCTION SCORING - NOW TRACK AWARE
+        Applies different boosts based on the selected track.
+        """
+        if course_id not in self.courses or not self.courses[course_id].get('name', '').strip():
+            return -10000.0
+        
+        course_data = self.courses[course_id]
+        subject = course_data.get('subject', '')
+        level = self._get_level(course_id)
+        name = course_data.get('name', '').lower()
+        
+        score = 0.0
+        
+        # --- SEMANTICS APPLIED FIRST ---
+        semantic_weight = 15.0 if year == 4 else 5.0
+        score += semantic_scores.get(course_id, 0.0) * semantic_weight
+        
+        # --- PENALTY APPLIED AFTER SEMANTICS ---
+        non_technical_keywords = ['society', 'ethics', 'law', 'policy', 'mobile', 'game', 'visualiz', 'web']
+        if any(keyword in name for keyword in non_technical_keywords):
+            # Exception: allow 'game' and 'mobile' if game_dev track is selected
+            if track == "game_dev" and any(k in name for k in ['game', 'mobile']):
+                pass # Do not penalize
+            else:
+                score -= 10000.0
+        
+        # Subject-aware scoring
+        if subject in ["CS", "DS"]:
+            score += 300.0
+        elif subject == "CY":
+            if level < 3000:
+                score -= 500.0
+            else:
+                score += 300.0 # Allow CY electives if not intro
+        elif subject == "MATH":
+            score += 100.0
+        else:
+            score -= 1000.0 
+        
+        # --- TRACK-AWARE CRITICAL PATH BOOSTS ---
+        if track == "ai_ml":
+            if course_id in ["DS2500", "DS3000", "DS3500"]:
+                score += 7000.0
+        elif track == "security":
+            if course_id in ["CY2550", "CY3740"]:
+                score += 7000.0
+        elif track == "systems":
+             if course_id == "CS3650":
+                score += 7000.0
+        elif track == "game_dev":
+             if course_id == "CS3540": # Game Programming
+                score += 8000.0 # Main course for this track
+        # "general" track gets no special boosts
+        
+        # Hard requirements
+        if course_id in required_set:
+            score += 10000.0
+        
+        # Pick-list courses
+        if course_id in picklist_set:
+            score += 5000.0
+        
+        # Unlocking factor
+        if course_id in self.curriculum_graph:
+            unlocks = self.curriculum_graph.out_degree(course_id)
+            score += min(unlocks, 5) * 2.0
+        
+        # Level preference
+        score -= (level / 100.0)
+        
+        # Year-specific penalties
+        if year == 4 and level < 4000:
+            score -= 3000.0
+        elif year == 3 and level < 3000:
+            score -= 2000.0
+        
+        return score
+
+    def generate_simple_plan(self, student: StudentProfile, track_override: Optional[str] = None) -> Dict:
+        print("--- Generating Enhanced Rule-Based Plan ---")
+        self.current_student = student
+        return self.generate_enhanced_rule_plan(student, track_override)
+        
+    def generate_enhanced_rule_plan(self, student: StudentProfile, track_override: Optional[str] = None) -> Dict:
+        self.current_student = student
+        
+        # --- FIX: Logic corrected to respect "general" override ---
+        if track_override:
+            track = track_override
+            print(f"--- Using user-selected track: {track} ---")
+        else:
+            track = self._identify_track(student)
+            print(f"--- Auto-identified track: {track} ---")
+            if not track:
+                track = "general"
+        
+        plan = self._build_structured_plan(student, track, None)
+        validation = self.validate_plan(plan, student)
+        
+        if validation["errors"]:
+            plan = self._fix_plan_errors(plan, validation, student)
+            validation = self.validate_plan(plan, student)
+        
+        difficulty_level = self._map_difficulty(student.preferred_difficulty)
+        courses_per_semester = self._calculate_course_load(student.time_commitment)
+        
+        track_name = track.replace("_", " ").title()
+        explanation = f"Personalized {track_name} track ({difficulty_level} difficulty, {courses_per_semester} courses/semester)"
+        
+        return self._finalize_plan(plan, explanation, validation)
+
+    def generate_llm_plan(self, student: StudentProfile, track_override: Optional[str] = None) -> Dict:
+        print("--- Generating AI-Optimized Plan ---")
+        self.current_student = student
+        self.load_llm()
+        if not self.llm:
+            return self.generate_enhanced_rule_plan(student, track_override) # Pass override
+        
+        # --- FIX: Use override if provided, otherwise identify ---
+        if track_override and track_override != "general":
+            track = track_override
+            print(f"--- Using user-selected track: {track} ---")
+        else:
+            track = self._identify_track(student)
+            print(f"--- Auto-identified track: {track} ---")
+            if not track:
+                track = "general"
+        
+        llm_suggestions = self._get_llm_course_suggestions(student, track)
+        plan = self._build_structured_plan(student, track, llm_suggestions)
+        validation = self.validate_plan(plan, student)
+        if validation["errors"]:
+            plan = self._fix_plan_errors(plan, validation, student)
+            validation = self.validate_plan(plan, student)
+        
+        track_name = track.replace("_", " ").title()
+        explanation = self._generate_explanation(student, plan, track, f"AI-optimized {track_name}")
+        return self._finalize_plan(plan, explanation, validation)
+
+
+        
+    def _build_structured_plan(self, student: StudentProfile, track: str, llm_suggestions: Optional[List[str]] = None) -> Dict:
+        """
+        PRODUCTION PLANNER - NOW FULLY TRACK-AWARE
+        Uses different priority lists based on the selected track.
+        """
+        completed = set(student.completed_courses)
+        plan = {}
+        
+        # --- FIX: TRACK-AWARE REQUIREMENTS ---
+        if track == "general":
+            print("--- Using General CS requirements ---")
+            requirements = {
+                "foundations": {"required": ["CS1800", "CS2500", "CS2510", "CS2800"]},
+                "core": {"required": ["CS3000", "CS3500", "CS3650"]},
+                "math": {"required": ["MATH1341", "MATH1342"], "pick_1_from": ["MATH2331", "MATH3081"]}
+            }
+        elif track == "game_dev":
+             print("--- Using Game Dev (AI/ML base) requirements ---")
+             # Use ai_ml as a base, scoring/priorities will handle the rest
+             requirements = self.CONCENTRATION_REQUIREMENTS["ai_ml"]
+        else:
+             requirements = self.CONCENTRATION_REQUIREMENTS.get(track, self.CONCENTRATION_REQUIREMENTS["ai_ml"])
+        
+        courses_per_semester = self._calculate_course_load(student.time_commitment)
+        
+        # Build required and pick sets
+        required_set = set()
+        picklist_set = set()
+        for category, reqs in requirements.items():
+            if "required" in reqs:
+                required_set.update(reqs["required"])
+            for key, courses in reqs.items():
+                if key.startswith("pick_"):
+                    picklist_set.update(courses)
+        
+        semantic_scores = self._compute_semantic_scores(student)
+        
+        # --- FIX: TRACK-AWARE PRIORITIES ---
+        TRACK_YEAR_PRIORITIES = {
+            "general": {
+                2: ["CS3000", "CS3500", "CS3650", "MATH2331", "MATH3081", "CS3200"],
+                3: ["CS4700", "CS4400", "CS4500", "CS4100"],
+                4: ["CS5700", "CS4730", "CS4530", "CS4550", "CS4410"]
+            },
+            "ai_ml": {
+                2: ["CS3000", "CS3500", "DS2500", "DS3000", "DS3500", "MATH2331", "MATH3081", "CS3650"],
+                3: ["CS4100", "DS4400", "CS4120", "DS4420", "DS4440", "CS4180"],
+                4: ["CS4730", "CS4700", "CS5700", "DS4300", "CS4400", "CS4500"]
+            },
+            "security": {
+                2: ["CS3000", "CS3650", "CY2550", "MATH2331", "MATH3081", "CS3500"],
+                3: ["CY3740", "CS4700", "CS5700", "CS4730"],
+                4: ["CY4740", "CY4760", "CS4400"] # CY4770 is missing from graph
+            },
+            "systems": {
+                2: ["CS3000", "CS3500", "CS3650", "MATH2331", "CS3200"],
+                3: ["CS4700", "CS5700", "CS4730", "CS4500", "CS4400"],
+                4: ["CS4520", "CS4410"]
+            },
+            "game_dev": {
+                2: ["CS3000", "CS3500", "CS3540", "MATH2331", "MATH3081", "CS3650"],
+                3: ["CS4520", "CS4300", "CS4100", "CS4700"],
+                4: ["CS4550", "CS4410", "CS4180"]
+            }
+        }
+        
+        for sem_num in range(1, 9):
+            year = ((sem_num - 1) // 2) + 1
+            
+            available_courses = self._get_available_courses(completed, year, sem_num, track)
+            
+            schedulable = [
+                c for c in available_courses
+                if c not in completed and self._can_take_course(c, completed)
+            ]
+            
+            # Use track-specific priorities, default to "general" if track is unknown
+            current_year_priorities = TRACK_YEAR_PRIORITIES.get(track, TRACK_YEAR_PRIORITIES["general"]).get(year)
+            
+            if current_year_priorities:
+                priority_courses = [c for c in current_year_priorities if c in schedulable]
+                other_courses = [c for c in schedulable if c not in current_year_priorities]
+                
+                scored_priority = sorted(
+                    priority_courses,
+                    # --- FIX: Pass 'track' to score_course ---
+                    key=lambda c: self._score_course(c, semantic_scores, required_set, picklist_set, year, track),
+                    reverse=True
+                )
+                scored_others = sorted(
+                    other_courses,
+                    key=lambda c: self._score_course(c, semantic_scores, required_set, picklist_set, year, track),
+                    reverse=True
+                )
+                
+                scored_courses = scored_priority + scored_others
+            else:
+                # Year 1: normal scoring
+                scored_courses = sorted(
+                    schedulable,
+                    key=lambda c: self._score_course(c, semantic_scores, required_set, picklist_set, year, track),
+                    reverse=True
+                )
+            
+            # Select top N courses
+            selected = []
+            for course in scored_courses:
+                if len(selected) >= courses_per_semester:
+                    break
+                if self._validate_sequence(selected, course):
+                    selected.append(course)
+            
+            if selected:
+                year_key = f"year_{year}"
+                if year_key not in plan:
+                    plan[year_key] = {}
+                
+                sem_type = 'fall' if (sem_num % 2) == 1 else 'spring'
+                plan[year_key][sem_type] = selected
+                completed.update(selected)
+        
+        return plan
+
+    def _get_available_courses(self, completed: Set[str], year: int, sem_num: int = None, track: str = "ai_ml") -> List[str]:
+        """
+        PRODUCTION COURSE FILTER - Strict level enforcement
+        """
+        # Year 1: Hardcoded foundation
+        if year == 1:
+            if not completed or len(completed) < 2:
+                return [c for c in ["CS1800", "CS2500", "MATH1341", "ENGW1111"] if c in self.valid_courses]
+            else:
+                next_courses = []
+                prereq_map = [
+                    ("CS2800", "CS1800"), 
+                    ("CS2510", "CS2500"), 
+                    ("MATH1342", "MATH1341"), 
+                    ("DS2000", None),
+                    ("DS2500", "DS2000")
+                ]
+                
+                for course, prereq in prereq_map:
+                    if course in self.valid_courses and course not in completed:
+                        if prereq is None or prereq in completed:
+                            next_courses.append(course)
+                return next_courses
+        
+        # Years 2-4: Strict filtering by subject and level
+        available = []
+        ALLOWED_SUBJECTS = {"CS", "DS", "CY", "MATH"}
+        
+        for cid in self.valid_courses:
+            if cid in completed:
+                continue
+            
+            course_data = self.courses.get(cid, {})
+            subject = course_data.get('subject')
+            
+            if subject not in ALLOWED_SUBJECTS:
+                continue
+            
+            course_level = self._get_level(cid)
+            
+            # FIX: Strict year-based level filtering
+            if year == 2:
+                if course_level < 2000 or course_level > 3999:
+                    continue  # Year 2: only 2000-3999
+            elif year == 3:
+                if course_level < 3000:
+                    continue  # Year 3: 3000+ only
+            elif year == 4:
+                if course_level < 4000:
+                    continue  # Year 4: 4000+ only (including CS5700)
+            
+            available.append(cid)
+        
+        return available
+
+    def _fix_plan_errors(self, plan: Dict, validation: Dict, student: StudentProfile) -> Dict:
+        if any("Mixed" in error for error in validation["errors"]):
+            return self._build_structured_plan(student, self._identify_track(student), None)
+        return plan
+        
+    def _get_llm_course_suggestions(self, student: StudentProfile, track: str) -> List[str]:
+        requirements = self.CONCENTRATION_REQUIREMENTS.get(track, {})
+        all_options = set()
+        for reqs in requirements.values():
+            for key, courses in reqs.items():
+                if key.startswith("pick_"):
+                    all_options.update(courses)
+        
+        course_options_text = [
+            f"{cid}: {self.courses[cid].get('name', cid)} - {self.courses[cid].get('description', '')[:100].strip()}"
+            for cid in list(all_options)[:15] if cid in self.courses
+        ]
+        
+        prompt = f"""Expert curriculum advisor ranking courses for student.
+
+Student Profile:
+- Career Goal: {student.career_goals}
+- Interests: {', '.join(student.interests)}
+- Difficulty: {student.preferred_difficulty}
+
+Available Courses:
+{chr(10).join(course_options_text)}
+
+Return ONLY top 5 course IDs, one per line."""
+
+        try:
+            inputs = self.tokenizer(prompt, return_tensors="pt", truncation=True, max_length=4096).to(self.device)
+            with torch.no_grad():
+                outputs = self.llm.generate(
+                    **inputs, 
+                    max_new_tokens=100, 
+                    temperature=0.2, 
+                    do_sample=True, 
+                    pad_token_id=self.tokenizer.eos_token_id
+                )
+            response = self.tokenizer.decode(outputs[0][len(inputs['input_ids'][0]):], skip_special_tokens=True)
+            suggested_courses = re.findall(r'([A-Z]{2,4}\d{4})', response)
+            return suggested_courses[:5]
+        except Exception as e:
+            print(f"LLM suggestion failed: {e}")
+            return list(all_options)[:5]
+
+    def _map_difficulty(self, preferred_difficulty: str) -> str:
+        return {"easy": "easy", "moderate": "medium", "challenging": "hard"}.get(preferred_difficulty.lower(), "medium")
+        
+    def _calculate_course_load(self, time_commitment: int) -> int:
+        if time_commitment <= 20:
+            return 3
+        if time_commitment <= 40:
+            return 4
+        return 5
+        
+    def _identify_track(self, student: StudentProfile) -> str:
+        if not hasattr(self, 'embedding_model') or self.embedding_model is None:
+            combined = f"{student.career_goals.lower()} {' '.join(student.interests).lower()}"
+            if any(word in combined for word in ['ai', 'ml', 'machine learning', 'data']):
+                return "ai_ml"
+            if any(word in combined for word in ['systems', 'distributed', 'backend']):
+                return "systems"
+            if any(word in combined for word in ['security', 'cyber']):
+                return "security"
+            return "ai_ml"
+        
+        profile_text = f"{student.career_goals} {' '.join(student.interests)}"
+        profile_emb = self.embedding_model.encode(profile_text, convert_to_tensor=True)
+        
+        track_descriptions = {
+            "ai_ml": "artificial intelligence machine learning deep learning neural networks data science",
+            "systems": "operating systems distributed systems networks compilers databases performance backend",
+            "security": "cybersecurity cryptography network security ethical hacking vulnerabilities"
+        }
+        
+        best_track, best_score = "ai_ml", -1.0
+        for track, description in track_descriptions.items():
+            track_emb = self.embedding_model.encode(description, convert_to_tensor=True)
+            score = float(util.cos_sim(profile_emb, track_emb))
+            if score > best_score:
+                best_score, best_track = score, track
+        
+        return best_track
+        
+    def _compute_semantic_scores(self, student: StudentProfile) -> Dict[str, float]:
+        query_text = f"{student.career_goals} {' '.join(student.interests)}"
+        query_emb = self.embedding_model.encode(query_text, convert_to_tensor=True)
+        similarities = util.cos_sim(query_emb, self.course_embeddings)[0]
+        return {cid: float(similarities[idx]) for idx, cid in enumerate(self.valid_courses)}
+        
+    def _generate_explanation(self, student: StudentProfile, plan: Dict, track: str, plan_type: str) -> str:
+        return f"{plan_type.title()} plan for the {track} track, tailored to your goal of becoming a {student.career_goals}."
+
+    def validate_plan(self, plan: Dict, student: StudentProfile = None) -> Dict[str, List[str]]:
+        issues = {"errors": [], "warnings": [], "info": []}
+        all_courses = [course for year in plan.values() for sem in year.values() for course in sem if isinstance(sem, list)]
+        
+        # Check for mixed tracks
+        for track_type, tracks in self.COURSE_TRACKS.items():
+            tracks_used = {name for name, courses in tracks.items() if any(c in all_courses for c in courses)}
+            if len(tracks_used) > 1:
+                issues["errors"].append(f"Mixed {track_type} tracks: {', '.join(tracks_used)}. Choose one sequence.")
+
+        # Validate prerequisites
+        completed_for_validation = set(student.completed_courses) if student else set()
+        for year in range(1, 5):
+            for sem in ["fall", "spring"]:
+                year_key = f"year_{year}"
+                sem_courses = plan.get(year_key, {}).get(sem, [])
+                for course in sem_courses:
+                    if course in self.curriculum_graph:
+                        prereqs = set(self.curriculum_graph.predecessors(course))
+                        if not prereqs.issubset(self._get_completed_with_equivalents(completed_for_validation)):
+                            missing = prereqs - completed_for_validation
+                            issues["errors"].append(f"{course} in Year {year} {sem} is missing prereqs: {', '.join(missing)}")
+                completed_for_validation.update(sem_courses)
+        
+        return issues
+
+    def _finalize_plan(self, plan: Dict, explanation: str, validation: Dict = None) -> Dict:
+        structured_plan = {
+            "reasoning": explanation, 
+            "validation": validation or {"errors": [], "warnings": [], "info": []}
+        }
+        
+        complexities = []
+        for year in range(1, 5):
+            year_key = f"year_{year}"
+            structured_plan[year_key] = {
+                "fall": plan.get(year_key, {}).get("fall", []),
+                "spring": plan.get(year_key, {}).get("spring", []),
+                "summer": "co-op" if year in [2, 3] else []
+            }
+            
+            for sem in ["fall", "spring"]:
+                courses = structured_plan[year_key][sem]
+                if courses:
+                    sem_complexity = sum(self.courses.get(c, {}).get('complexity', 50) for c in courses)
+                    complexities.append(sem_complexity)
+        
+        structured_plan["complexity_analysis"] = {
+            "average_semester_complexity": float(np.mean(complexities)) if complexities else 0,
+            "peak_semester_complexity": float(np.max(complexities)) if complexities else 0,
+            "total_complexity": float(np.sum(complexities)) if complexities else 0,
+            "balance_score (std_dev)": float(np.std(complexities)) if complexities else 0
+        }
+        
+        structured_plan["metadata"] = {
+            "generated": datetime.now().isoformat(),
+            "valid": len(validation.get("errors", [])) == 0 if validation else True,
+        }
+        
+        return {"pathway": structured_plan}
+
+class CurriculumOptimizer(HybridOptimizer):
+    """Compatibility wrapper"""
+    def __init__(self):
+        super().__init__()
+    
+    def generate_plan(self, student: StudentProfile, track_override: Optional[str] = None) -> Dict:
+        return self.generate_enhanced_rule_plan(student, track_override)

src/neu_graph_clean10.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9ebd3c024667aedd28338a61e7e87bdd78c7db3dce94fb1a920e11eb7bdc985d
+size 156590

src/ui.py

@@ -0,0 +1,621 @@
+import streamlit as st
+import pickle
+import os
+import time
+import json
+import yaml
+from datetime import datetime
+from typing import Dict, Set, Optional
+
+# Import the optimizer and visualizer
+from curriculum_optimizer import HybridOptimizer, StudentProfile
+from interactive_visualizer import CurriculumVisualizer
+
+# --- Page Configuration ---
+st.set_page_config(page_title="Curriculum Optimizer", layout="wide", initial_sidebar_state="expanded")
+
+# Initialize session state
+if "display_plan" not in st.session_state:
+    st.session_state.display_plan = None
+if "metrics" not in st.session_state:
+    st.session_state.metrics = None
+if "reasoning" not in st.session_state:
+    st.session_state.reasoning = ""
+if "graph_data_loaded" not in st.session_state:
+    st.session_state.graph_data_loaded = False
+if "last_profile" not in st.session_state:
+    st.session_state.last_profile = None
+if "visualizer" not in st.session_state:
+    st.session_state.visualizer = None
+if "selected_track" not in st.session_state:
+    st.session_state.selected_track = "general" # Default to general
+
+# Title
+st.title("🧑‍🎓 Next-Gen Curriculum Optimizer")
+
+# --- Caching and Initialization ---
+@st.cache_resource
+def get_optimizer():
+    """Loads and caches the main optimizer class and its models."""
+    try:
+        optimizer = HybridOptimizer()
+        optimizer.load_models()
+        return optimizer
+    except Exception as e:
+        st.error(f"Fatal error during model loading: {e}")
+        st.info("Please ensure you have the required libraries installed.")
+        st.stop()
+        return None
+
+optimizer = get_optimizer()
+
+# --- DYNAMIC HELPER FUNCTIONS ---
+
+def check_requirements_satisfaction(plan: Dict, track: str) -> Dict:
+    """
+    Check which requirements are satisfied by the plan.
+    This is now dynamic based on the optimizer's config.
+    """
+    if not optimizer:
+        return {}
+        
+    all_courses = []
+    for year_key, year_data in plan.items():
+        if year_key.startswith("year_"):
+            all_courses.extend(year_data.get("fall", []))
+            all_courses.extend(year_data.get("spring", []))
+    all_courses_set = set(all_courses)
+
+    # Get the correct requirements dictionary
+    if track == "general":
+        req_data = {
+            "foundations": {"required": ["CS1800", "CS2500", "CS2510", "CS2800"]},
+            "core": {"required": ["CS3000", "CS3500", "CS3650"]},
+            "math": {"required": ["MATH1341", "MATH1342"], "pick_1_from": ["MATH2331", "MATH3081"]}
+        }
+    elif track == "game_dev":
+         # Use ai_ml as a base for game_dev
+         req_data = optimizer.CONCENTRATION_REQUIREMENTS.get("ai_ml", {})
+    else:
+         req_data = optimizer.CONCENTRATION_REQUIREMENTS.get(track, {})
+
+    satisfaction_report = {}
+    for category, reqs in req_data.items():
+        report = {}
+        if "required" in reqs:
+            req_list = reqs["required"]
+            report["required"] = req_list
+            report["completed"] = list(all_courses_set & set(req_list))
+            report["is_satisfied"] = all_courses_set.issuperset(req_list)
+        
+        for key, courses in reqs.items():
+            if key.startswith("pick_"):
+                try:
+                    num_to_pick = int(key.split("_")[1])
+                except Exception:
+                    num_to_pick = 1
+                
+                completed_in_pick = list(all_courses_set & set(courses))
+                report[key] = {
+                    "options": courses,
+                    "completed": completed_in_pick,
+                    "count": f"{len(completed_in_pick)} of {num_to_pick}",
+                    "is_satisfied": len(completed_in_pick) >= num_to_pick
+                }
+        satisfaction_report[category] = report
+    
+    return satisfaction_report
+
+def export_plan_yaml(plan: Dict, profile: StudentProfile, validation: Dict = None, track: str = "general") -> str:
+    """Export plan in structured YAML format for verification"""
+    
+    # Build structured plan data
+    structured_plan = {
+        "student_profile": {
+            "name": profile.name if hasattr(profile, 'name') else "Student",
+            "gpa": profile.current_gpa,
+            "career_goal": profile.career_goals,
+            "interests": profile.interests,
+            "completed_courses": profile.completed_courses,
+            "time_commitment": profile.time_commitment,
+            "preferred_difficulty": profile.preferred_difficulty
+        },
+        "plan_metadata": {
+            "generated": datetime.now().isoformat(),
+            "track": track, # --- FIX: Now dynamic ---
+            "total_credits": 0,
+            "validation_status": "valid" if not validation.get("errors") else "has_errors"
+        },
+        "validation": validation if validation else {"errors": [], "warnings": []},
+        "semesters": [],
+        "course_details": {}
+    }
+    
+    # Build semester list with full details
+    total_credits = 0
+    for year in range(1, 5):
+        year_key = f"year_{year}"
+        if year_key in plan:
+            # Fall
+            fall_courses = plan[year_key].get("fall", [])
+            if fall_courses:
+                semester_data = {"year": year, "term": "fall", "courses": []}
+                for course_id in fall_courses:
+                    course_info = optimizer.courses.get(course_id, {})
+                    course_detail = {
+                        "id": course_id,
+                        "name": course_info.get("name", "Unknown"),
+                        "credits": course_info.get("maxCredits", 4),
+                        "complexity": course_info.get("complexity", 0),
+                        "prerequisites": list(optimizer.curriculum_graph.predecessors(course_id)) if course_id in optimizer.curriculum_graph else []
+                    }
+                    semester_data["courses"].append(course_detail)
+                    total_credits += course_detail["credits"]
+                    structured_plan["course_details"][course_id] = course_detail
+                
+                semester_data["semester_credits"] = sum(c["credits"] for c in semester_data["courses"])
+                semester_data["semester_complexity"] = sum(c["complexity"] for c in semester_data["courses"])
+                structured_plan["semesters"].append(semester_data)
+
+            # Spring
+            spring_courses = plan[year_key].get("spring", [])
+            if spring_courses:
+                semester_data = {"year": year, "term": "spring", "courses": []}
+                for course_id in spring_courses:
+                    course_info = optimizer.courses.get(course_id, {})
+                    course_detail = {
+                        "id": course_id,
+                        "name": course_info.get("name", "Unknown"),
+                        "credits": course_info.get("maxCredits", 4),
+                        "complexity": course_info.get("complexity", 0),
+                        "prerequisites": list(optimizer.curriculum_graph.predecessors(course_id)) if course_id in optimizer.curriculum_graph else []
+                    }
+                    semester_data["courses"].append(course_detail)
+                    total_credits += course_detail["credits"]
+                    structured_plan["course_details"][course_id] = course_detail
+                
+                semester_data["semester_credits"] = sum(c["credits"] for c in semester_data["courses"])
+                semester_data["semester_complexity"] = sum(c["complexity"] for c in semester_data["courses"])
+                structured_plan["semesters"].append(semester_data)
+        
+        # Add summer/co-op
+        if year in [2, 3]:
+            structured_plan["semesters"].append({
+                "year": year, "term": "summer", "activity": "co-op", "courses": []
+            })
+    
+    structured_plan["plan_metadata"]["total_credits"] = total_credits
+    
+    # Calculate requirement satisfaction
+    # --- FIX: Pass the dynamic track ---
+    requirements_met = check_requirements_satisfaction(plan, track=track)
+    structured_plan["requirements_satisfaction"] = requirements_met
+    
+    return yaml.dump(structured_plan, default_flow_style=False, sort_keys=False)
+
+
+# --- UI TABS ---
+tab1, tab2, tab3 = st.tabs(["📝 Plan Generator", "🗺️ Curriculum Map", "📊 Analytics"])
+
+with tab1:
+    # --- SIDEBAR FOR STUDENT PROFILE ---
+    with st.sidebar:
+        st.header("Student Profile")
+        name = st.text_input("Name", "John, son of Jane")
+        gpa = st.slider("GPA", 0.0, 4.0, 3.0, 0.1)
+        career_goal = st.text_area("Career Goal", " ")
+        interests = st.text_input("Interests (comma-separated)", " ")
+        learning_style = st.selectbox("Learning Style", ["Visual", "Hands-on", "Auditory"])
+        time_commit = st.number_input("Weekly Study Hours", 10, 60, 40, 5)
+        difficulty = st.selectbox("Preferred Difficulty", ["easy", "moderate", "challenging"])
+        completed_courses_input = st.text_area("Completed Courses (comma-separated)", " ")
+        
+        # Show profile impact
+        st.markdown("---")
+        st.markdown("**Profile Impact:**")
+        if time_commit < 20:
+            st.info("🕒 Part-time load (3 courses/semester)")
+        elif time_commit >= 40:
+            st.info("🔥 Intensive load (up to 5 courses/semester)")
+        else:
+            st.info("📚 Standard load (4 courses/semester)")
+        
+        if difficulty == "easy":
+            st.info("😌 Focuses on foundational courses")
+        elif difficulty == "challenging":
+            st.info("🚀 Includes advanced/specialized courses")
+        else:
+            st.info("⚖️ Balanced difficulty progression")
+    
+    # --- MAIN PAGE CONTENT ---
+    
+    # 1. LOAD DATA
+    st.subheader("1. Load Curriculum Data")
+    uploaded_file = st.file_uploader("Upload `.pkl` file in the files section of this project", type=["pkl"])
+    
+    if uploaded_file and not st.session_state.graph_data_loaded:
+        with st.spinner("Loading curriculum data and preparing embeddings..."):
+            try:
+                graph_data = pickle.load(uploaded_file)
+                optimizer.load_data(graph_data)
+                st.session_state.visualizer = CurriculumVisualizer(graph_data)
+                st.session_state.graph_data = graph_data
+                st.session_state.graph_data_loaded = True
+                st.success(f"Successfully loaded and processed '{uploaded_file.name}'!")
+                time.sleep(1)
+                st.rerun()
+            except Exception as e:
+                st.error(f"Error processing .pkl file: {e}")
+                st.session_state.graph_data_loaded = False
+    elif st.session_state.graph_data_loaded:
+        st.success("Curriculum data is loaded and ready.")
+    
+    # 2. SELECT TRACK (NEW SECTION)
+    st.subheader("2. Select a Specialization")
+    if not st.session_state.graph_data_loaded:
+        st.info("Please load a curriculum file first.")
+    else:
+        # Map user-friendly names to the internal keys
+        track_options = {
+            "general": "🤖 General CS (Broadest Focus)",
+            "ai_ml": "🧠 Artificial Intelligence & ML",
+            "security": "🔒 Cybersecurity",
+            "systems": "⚙️ Systems & Networks",
+            "game_dev": "🎮 Game Design & Development"
+        }
+        
+        selected_track_key = st.selectbox(
+            "Choose your focus area (optional):",
+            options=track_options.keys(),
+            format_func=lambda key: track_options[key], # Shows the friendly name
+            index=0  # Default to "General"
+        )
+        st.session_state.selected_track = selected_track_key
+
+    # 3. GENERATE PLAN
+    st.subheader("3. Generate a Plan")
+    if not st.session_state.graph_data_loaded:
+        st.info("Please load a curriculum file above to enable plan generation.")
+    else:
+        # Create student profile
+        profile = StudentProfile(
+            completed_courses=[c.strip().upper() for c in completed_courses_input.split(',') if c.strip()],
+            current_gpa=gpa, 
+            interests=[i.strip() for i in interests.split(',') if i.strip()],
+            career_goals=career_goal, 
+            learning_style=learning_style,
+            time_commitment=time_commit, 
+            preferred_difficulty=difficulty
+        )
+        
+        # Get the selected track from session state
+        selected_track = st.session_state.get("selected_track", "general")
+        
+        # Check if profile or track changed
+        profile_changed = (st.session_state.last_profile != profile) or \
+                          (st.session_state.last_track != selected_track)
+                          
+        if profile_changed:
+            st.session_state.last_profile = profile
+            st.session_state.last_track = selected_track
+        
+        col1, col2, col3 = st.columns(3)
+        
+        if col1.button("🧠 AI-Optimized Plan", use_container_width=True, type="primary"):
+            with st.spinner(f"🚀 Performing AI-optimization for '{track_options[selected_track]}' track..."):
+                start_time = time.time()
+                # --- FIX: Pass selected_track ---
+                result = optimizer.generate_llm_plan(profile, selected_track)
+                generation_time = time.time() - start_time
+                
+                plan_raw = result.get('pathway', {})
+                st.session_state.reasoning = plan_raw.get("reasoning", "")
+                st.session_state.metrics = plan_raw.get("complexity_analysis", {})
+                st.session_state.display_plan = plan_raw
+                st.session_state.plan_type = "AI-Optimized"
+                st.session_state.generation_time = generation_time
+                st.success(f"🎉 AI-optimized plan generated in {generation_time:.1f}s!")
+        
+        if col2.button("⚡ Smart Rule-Based Plan", use_container_width=True):
+            with st.spinner(f"Generating rule-based plan for '{track_options[selected_track]}' track..."):
+                start_time = time.time()
+                # --- FIX: Pass selected_track ---
+                result = optimizer.generate_simple_plan(profile, selected_track)
+                generation_time = time.time() - start_time
+                
+                plan_raw = result.get('pathway', {})
+                st.session_state.reasoning = plan_raw.get("reasoning", "")
+                st.session_state.metrics = plan_raw.get("complexity_analysis", {})
+                st.session_state.display_plan = plan_raw
+                st.session_state.plan_type = "Smart Rule-Based"
+                st.session_state.generation_time = generation_time
+                st.success(f"🎉 Smart rule-based plan generated in {generation_time:.1f}s!")
+        
+        if col3.button("🔄 Clear Plan", use_container_width=True):
+            st.session_state.display_plan = None
+            st.session_state.metrics = None
+            st.session_state.reasoning = ""
+            st.rerun()
+    
+    # Show profile change notification
+    if st.session_state.display_plan and profile_changed:
+        st.warning("⚠️ Student profile or track changed! Generate a new plan to see updated recommendations.")
+    
+    # DISPLAY RESULTS
+    if st.session_state.display_plan:
+        st.subheader(f"📚 {st.session_state.get('plan_type', 'Optimized')} Degree Plan")
+        
+        # Display generation info
+        col_info1, col_info2, col_info3 = st.columns(3)
+        with col_info1:
+            st.metric("Generation Time", f"{st.session_state.get('generation_time', 0):.1f}s")
+        with col_info2:
+            st.metric("Plan Type", st.session_state.get('plan_type', 'Unknown'))
+        with col_info3:
+            if time_commit < 20:
+                load_type = "Part-time"
+            elif time_commit >= 40:
+                load_type = "Intensive"
+            else:
+                load_type = "Standard"
+            st.metric("Course Load", load_type)
+        
+        # Display reasoning and metrics
+        if st.session_state.reasoning or st.session_state.metrics:
+            st.markdown("##### 📊 Plan Analysis")
+            
+            if st.session_state.reasoning:
+                st.info(f"**Strategy:** {st.session_state.reasoning}")
+            
+            if st.session_state.metrics:
+                m = st.session_state.metrics
+                c1, c2, c3, c4 = st.columns(4)
+                
+                c1.metric("Avg Complexity", f"{m.get('average_semester_complexity', 0):.1f}")
+                c2.metric("Peak Complexity", f"{m.get('peak_semester_complexity', 0):.1f}")
+                c3.metric("Total Complexity", f"{m.get('total_complexity', 0):.0f}")
+                c4.metric("Balance Score", f"{m.get('balance_score (std_dev)', 0):.2f}")
+            
+            st.divider()
+        
+        # Display the actual plan
+        plan = st.session_state.display_plan
+        total_courses = 0
+        
+        for year_num in range(1, 5):
+            year_key = f"year_{year_num}"
+            year_data = plan.get(year_key, {})
+            
+            st.markdown(f"### Year {year_num}")
+            col_fall, col_spring, col_summer = st.columns(3)
+            
+            # Fall semester
+            with col_fall:
+                fall_courses = year_data.get("fall", [])
+                st.markdown("**🍂 Fall Semester**")
+                if fall_courses:
+                    for course_id in fall_courses:
+                        if course_id in optimizer.courses:
+                            course_data = optimizer.courses[course_id]
+                            course_name = course_data.get("name", course_id)
+                            st.write(f"• **{course_id}**: {course_name}")
+                            total_courses += 1
+                        else:
+                            st.write(f"• {course_id}")
+                            total_courses += 1
+                else:
+                    st.write("*No courses scheduled*")
+            
+            # Spring semester
+            with col_spring:
+                spring_courses = year_data.get("spring", [])
+                st.markdown("**🌸 Spring Semester**")
+                if spring_courses:
+                    for course_id in spring_courses:
+                        if course_id in optimizer.courses:
+                            course_data = optimizer.courses[course_id]
+                            course_name = course_data.get("name", course_id)
+                            st.write(f"• **{course_id}**: {course_name}")
+                            total_courses += 1
+                        else:
+                            st.write(f"• {course_id}")
+                            total_courses += 1
+                else:
+                    st.write("*No courses scheduled*")
+            
+            # Summer
+            with col_summer:
+                summer = year_data.get("summer", [])
+                st.markdown("**☀️ Summer**")
+                if summer == "co-op":
+                    st.write("🏢 *Co-op Experience*")
+                elif summer:
+                    # This case isn't really used by the optimizer, but good to have
+                    st.write("*Summer Classes*")
+                else:
+                    st.write("*Break*")
+        
+        # Summary and export
+        st.divider()
+        col_export1, col_export2 = st.columns(2)
+        
+        with col_export1:
+            st.metric("Total Courses", total_courses)
+        
+        with col_export2:
+            col_yaml, col_json = st.columns(2)
+            
+            with col_yaml:
+                # --- FIX: Get validation from the plan object, DO NOT re-run validate_plan() ---
+                validation = st.session_state.display_plan.get("validation", {"errors": [], "warnings": []})
+                
+                yaml_data = export_plan_yaml(
+                    st.session_state.display_plan,
+                    profile,
+                    validation,
+                    st.session_state.get("selected_track", "general") # Pass track
+                )
+                st.download_button(
+                    label="📥 Export as YAML",
+                    data=yaml_data,
+                    file_name=f"curriculum_plan_{name.replace(' ', '_')}.yaml",
+                    mime="text/yaml",
+                    use_container_width=True
+                )
+            
+            with col_json:
+                export_data = {
+                    "student_profile": {
+                        "name": name, "gpa": gpa, "career_goals": career_goal,
+                        "interests": interests, "learning_style": learning_style,
+                        "time_commitment": time_commit, "preferred_difficulty": difficulty,
+                        "completed_courses": completed_courses_input
+                    },
+                    "plan": st.session_state.display_plan,
+                    "metrics": st.session_state.metrics,
+                    "generation_info": {
+                        "plan_type": st.session_state.get('plan_type', 'Unknown'),
+                        "generation_time": st.session_state.get('generation_time', 0),
+                        "selected_track": st.session_state.get("selected_track", "general")
+                    }
+                }
+                plan_json = json.dumps(export_data, indent=2)
+                st.download_button(
+                    label="📥 Export as JSON",
+                    data=plan_json,
+                    file_name=f"curriculum_plan_{name.replace(' ', '_')}.json",
+                    mime="application/json",
+                    use_container_width=True
+                )
+
+# --- TAB 2: CURRICULUM MAP ---
+with tab2:
+    st.subheader("🗺️ Interactive Curriculum Dependency Graph")
+    
+    if not st.session_state.graph_data_loaded:
+        st.info("Please load curriculum data in the Plan Generator tab first.")
+    else:
+        # Create visualization
+        if st.session_state.visualizer:
+            critical_path = st.session_state.visualizer.find_critical_path()
+            if critical_path:
+                st.info(f"Global Critical Path ({len(critical_path)} courses): {' → '.join(critical_path[:7])}...")
+            
+            # Create the plot
+            fig = st.session_state.visualizer.create_interactive_plot(critical_path)
+            st.plotly_chart(fig, use_container_width=True)
+            
+            # Legend
+            with st.expander("📖 How to Read This Graph"):
+                st.markdown("""
+                **Node (Circle) Size**: Blocking factor - larger circles block more future courses  
+                **Node Color**: Complexity score - darker = more complex  
+                **Lines**: Prerequisite relationships  
+                **Red Path**: Critical path (longest chain)  
+                **Hover over nodes**: See detailed metrics for each course
+                """)
+
+# --- TAB 3: ANALYTICS ---
+with tab3:
+    st.subheader("📊 Curriculum Analytics Dashboard")
+    
+    if not st.session_state.graph_data_loaded:
+        st.info("Please load curriculum data in the Plan Generator tab first.")
+    else:
+        # Overall metrics
+        col1, col2, col3, col4 = st.columns(4)
+        
+        graph = st.session_state.graph_data
+        total_courses = graph.number_of_nodes()
+        total_prereqs = graph.number_of_edges()
+        
+        col1.metric("Total Courses", total_courses)
+        col2.metric("Total Prerequisites", total_prereqs)
+        col3.metric("Avg Prerequisites", f"{total_prereqs/total_courses:.1f}")
+        
+        if st.session_state.visualizer:
+            total_complexity = sum(
+                st.session_state.visualizer.calculate_metrics(n)['complexity']
+                for n in graph.nodes()
+            )
+            col4.metric("Curriculum Complexity", f"{total_complexity:,.0f}")
+        
+        st.divider()
+        
+        # Most complex courses
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.subheader("Most Complex Courses")
+            if st.session_state.visualizer:
+                complexities = []
+                for node in graph.nodes():
+                    metrics = st.session_state.visualizer.calculate_metrics(node)
+                    complexities.append({
+                        'course': node,
+                        'name': graph.nodes[node].get('name', ''),
+                        'complexity': metrics['complexity'],
+                        'blocking': metrics['blocking']
+                    })
+                
+                complexities.sort(key=lambda x: x['complexity'], reverse=True)
+                
+                for item in complexities[:10]:
+                    st.write(f"**{item['course']}**: {item['name']}")
+                    prog_col1, prog_col2 = st.columns([3, 1])
+                    with prog_col1:
+                        st.progress(min(item['complexity']/100, 1.0)) # Adjusted scale
+                    with prog_col2:
+                        st.caption(f"Blocks: {item['blocking']}")
+        
+        with col2:
+            st.subheader("Bottleneck Courses")
+            st.caption("(High blocking factor)")
+            
+            if st.session_state.visualizer:
+                bottlenecks = sorted(complexities, key=lambda x: x['blocking'], reverse=True)
+                
+                for item in bottlenecks[:10]:
+                    st.write(f"**{item['course']}**: {item['name']}")
+                    st.info(f"Blocks {item['blocking']} future courses")
+        
+        # Plan vs Global Comparison
+        if st.session_state.display_plan:
+            st.divider()
+            st.subheader("📊 Metric System Comparison")
+            st.caption("Comparing metrics for the entire curriculum vs. metrics only within your generated plan.")
+            
+            plan_courses: Set[str] = set()
+            for year_key, year_data in st.session_state.display_plan.items():
+                if year_key.startswith("year_"):
+                    plan_courses.update(year_data.get("fall", []))
+                    plan_courses.update(year_data.get("spring", []))
+            
+            comparison = st.session_state.visualizer.compare_metric_systems(plan_courses)
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.metric(
+                    "Critical Path Match", 
+                    "✅ Yes" if comparison['critical_path_match'] else "❌ No"
+                )
+                st.caption("Global critical path (first 5):")
+                st.code(' → '.join(comparison['global_critical']))
+            
+            with col2:
+                st.metric(
+                    "Major Metric Differences",
+                    len(comparison['major_differences'])
+                )
+                st.caption("Plan-specific critical path (first 5):")
+                st.code(' → '.join(comparison['plan_critical']))
+            
+            if comparison['major_differences']:
+                with st.expander(f"View {len(comparison['major_differences'])} courses with >50% metric difference"):
+                    for diff in comparison['major_differences']:
+                        st.write(f"**{diff['course']}**: Global blocking={diff['global_blocking']}, Plan blocking={diff['plan_blocking']}")
+
+# Footer
+st.divider()
+st.caption("🚀 Powered by Students, For Students")