Rewrite CLAUDE.md and clean project structure

- Rewrote CLAUDE.md with comprehensive development guide
- Archived 20 old docs to docs/archive/
- Added PROJECT_ROADMAP_2025.md with research learnings
- Added CLASSIFICATION_METHODS_COMPARISON.md
- Added SESSION_HANDOVER_20251128.md
- Added tools for analysis (brett_gmail/microsoft analyzers)
- Updated .gitignore for archive folders
- Config changes for local vLLM endpoint

.gitignore

@@ -21,13 +21,14 @@ maildir
 
 # Credentials
 .env
-credentials/
+credentials/**/*.json
+!credentials/**/*.json.example
 *.json
 !config/*.json
 !config/*.yaml
 
 # Logs
-logs/*.log
+logs/
 *.log
 
 # IDE
@@ -63,3 +64,25 @@ dmypy.json
 *.bak
 *~
 enron_mail_20150507.tar.gz
+debug_*.txt
+
+# Test artifacts
+test/
+ml_only_test/
+results_*/
+phase1_*/
+
+# Python scripts (experimental/research - not in src/tests/tools)
+*.py
+!src/**/*.py
+!tests/**/*.py
+!tools/**/*.py
+!setup.py
+
+# Archive folders (historical content)
+archive/
+docs/archive/
+
+# Data folders (user-specific content)
+data/Bruce emails/
+data/emails-for-link/

BATCH_LLM_QUICKSTART.md

@@ -0,0 +1,145 @@
+# Batch LLM Classifier - Quick Start
+
+## Prerequisite Check
+
+```bash
+python tools/batch_llm_classifier.py check
+```
+
+Expected: `✓ vLLM server is running and ready`
+
+If not running: Start vLLM server at rtx3090.bobai.com.au first
+
+---
+
+## Basic Usage
+
+```bash
+python tools/batch_llm_classifier.py ask \
+  --source enron \
+  --limit 50 \
+  --question "YOUR QUESTION HERE" \
+  --output results.txt
+```
+
+---
+
+## Example Questions
+
+### Find Urgent Emails
+```bash
+--question "Is this email urgent or time-sensitive? Answer yes/no and explain."
+```
+
+### Extract Financial Data
+```bash
+--question "List any dollar amounts, budgets, or financial numbers in this email."
+```
+
+### Meeting Detection
+```bash
+--question "Does this email mention a meeting? If yes, extract date/time/location."
+```
+
+### Sentiment Analysis
+```bash
+--question "What is the tone? Professional/Casual/Urgent/Frustrated? Explain."
+```
+
+### Custom Classification
+```bash
+--question "Should this email be archived or kept active? Why?"
+```
+
+---
+
+## Performance
+
+- **Throughput**: 4.65 requests/sec
+- **Batch size**: 4 (proper batch pooling)
+- **Reliability**: 100% success rate
+- **Example**: 500 requests in 108 seconds
+
+---
+
+## When To Use
+
+✅ **Use Batch LLM for:**
+- Custom questions on 50-500 emails
+- One-off exploratory analysis
+- Flexible classification criteria
+- Data extraction tasks
+
+❌ **Use RAG instead for:**
+- Searching 10k+ email corpus
+- Semantic topic search
+- Multi-document reasoning
+
+❌ **Use Main ML Pipeline for:**
+- Regular ongoing classification
+- High-volume processing (10k+ emails)
+- Consistent categories
+- Maximum speed
+
+---
+
+## Quick Test
+
+```bash
+# Check server
+python tools/batch_llm_classifier.py check
+
+# Process 10 emails
+python tools/batch_llm_classifier.py ask \
+  --source enron \
+  --limit 10 \
+  --question "Summarize this email in one sentence." \
+  --output test.txt
+
+# Check results
+cat test.txt
+```
+
+---
+
+## Files Created
+
+- `tools/batch_llm_classifier.py` - Main tool (executable)
+- `tools/README.md` - Full documentation
+- `test_llm_concurrent.py` - Performance testing script (root)
+
+**No files in `src/` were modified - existing ML pipeline untouched**
+
+---
+
+## Configuration
+
+Edit `VLLM_CONFIG` in `batch_llm_classifier.py`:
+
+```python
+VLLM_CONFIG = {
+    'base_url': 'https://rtx3090.bobai.com.au/v1',
+    'api_key': 'rtx3090_foxadmin_10_8034ecb47841f45ba1d5f3f5d875c092',
+    'model': 'qwen3-coder-30b',
+    'batch_size': 4,  # Don't increase - causes 503 errors
+}
+```
+
+---
+
+## Troubleshooting
+
+**Server not available:**
+```bash
+curl https://rtx3090.bobai.com.au/v1/models -H "Authorization: Bearer rtx3090_..."
+```
+
+**503 errors:**
+Lower `batch_size` to 2 in config (currently optimal is 4)
+
+**Slow processing:**
+Check vLLM server load - may be handling other requests
+
+---
+
+**Done!** Ready to ask custom questions across email batches.

CLAUDE.md

@@ -0,0 +1,304 @@
+# Email Sorter - Development Guide
+
+## What This Tool Does
+
+**Email Sorter is a TRIAGE tool** that sorts emails into buckets for downstream processing. It is NOT a complete email management solution - it's one part of a larger ecosystem.
+
+```
+Raw Inbox (10k+) --> Email Sorter --> Categorized Buckets --> Specialized Tools
+                    (this tool)     (output)               (other tools)
+```
+
+---
+
+## Quick Start
+
+```bash
+cd /MASTERFOLDER/Tools/email-sorter
+source venv/bin/activate
+
+# Classify emails with ML + LLM fallback
+python -m src.cli run --source local \
+  --directory "/path/to/emails" \
+  --output "/path/to/output" \
+  --force-ml --llm-provider openai
+
+# Generate HTML report from results
+python tools/generate_html_report.py --input /path/to/results.json
+```
+
+---
+
+## Key Documentation
+
+| Document | Purpose | Location |
+|----------|---------|----------|
+| **PROJECT_ROADMAP_2025.md** | Master learnings, research findings, development roadmap | `docs/` |
+| **CLASSIFICATION_METHODS_COMPARISON.md** | ML vs LLM vs Agent comparison | `docs/` |
+| **REPORT_FORMAT.md** | HTML report documentation | `docs/` |
+| **BATCH_LLM_QUICKSTART.md** | Quick LLM batch processing guide | root |
+
+---
+
+## Research Findings Summary
+
+### Dataset Size Routing
+
+| Size | Best Method | Why |
+|------|-------------|-----|
+| <500 | Agent-only | ML overhead exceeds benefit |
+| 500-5000 | Agent pre-scan + ML | Discovery improves accuracy |
+| >5000 | ML pipeline | Speed critical |
+
+### Research Results
+
+| Dataset | Type | ML-Only | ML+LLM | Agent |
+|---------|------|---------|--------|-------|
+| brett-gmail (801) | Personal | 54.9% | 93.3% | 99.8% |
+| brett-microsoft (596) | Business | - | - | 98.2% |
+
+### Key Insight: Inbox Character Matters
+
+| Type | Pattern | Approach |
+|------|---------|----------|
+| **Personal** | Subscriptions, marketing (40-50% automated) | Sender domain first |
+| **Business** | Client work, operations (60-70% professional) | Sender + Subject context |
+
+---
+
+## Project Structure
+
+```
+email-sorter/
+├── CLAUDE.md                 # THIS FILE
+├── README.md                 # General readme
+├── BATCH_LLM_QUICKSTART.md   # LLM batch processing
+│
+├── src/                      # Source code
+│   ├── cli.py               # Main entry point
+│   ├── classification/      # ML/LLM classification
+│   ├── calibration/         # Model training, email parsing
+│   ├── email_providers/     # Gmail, Outlook, IMAP, Local
+│   └── llm/                 # LLM providers
+│
+├── tools/                    # Utility scripts
+│   ├── brett_gmail_analyzer.py      # Personal inbox template
+│   ├── brett_microsoft_analyzer.py  # Business inbox template
+│   ├── generate_html_report.py      # HTML report generator
+│   └── batch_llm_classifier.py      # Batch LLM classification
+│
+├── config/                   # Configuration
+│   ├── default_config.yaml  # LLM endpoints, thresholds
+│   └── categories.yaml      # Category definitions
+│
+├── docs/                     # Current documentation
+│   ├── PROJECT_ROADMAP_2025.md
+│   ├── CLASSIFICATION_METHODS_COMPARISON.md
+│   ├── REPORT_FORMAT.md
+│   └── archive/             # Old docs (historical)
+│
+├── data/                     # Analysis outputs (gitignored)
+│   ├── brett_gmail_analysis.json
+│   └── brett_microsoft_analysis.json
+│
+├── credentials/              # OAuth/API creds (gitignored)
+├── results/                  # Classification outputs (gitignored)
+├── archive/                  # Old scripts (gitignored)
+├── maildir/                  # Enron test data
+└── venv/                     # Python environment
+```
+
+---
+
+## Common Operations
+
+### 1. Classify Emails (ML Pipeline)
+
+```bash
+source venv/bin/activate
+
+# With LLM fallback for low confidence
+python -m src.cli run --source local \
+  --directory "/path/to/emails" \
+  --output "/path/to/output" \
+  --force-ml --llm-provider openai
+
+# Pure ML (fastest, no LLM)
+python -m src.cli run --source local \
+  --directory "/path/to/emails" \
+  --output "/path/to/output" \
+  --force-ml --no-llm-fallback
+```
+
+### 2. Generate HTML Report
+
+```bash
+python tools/generate_html_report.py --input /path/to/results.json
+# Creates report.html in same directory
+```
+
+### 3. Manual Agent Analysis (Best Accuracy)
+
+For <1000 emails, agent analysis gives 98-99% accuracy:
+
+```bash
+# Copy and customize analyzer template
+cp tools/brett_gmail_analyzer.py tools/my_inbox_analyzer.py
+
+# Edit classify_email() function for your inbox patterns
+# Update email_dir path
+# Run
+python tools/my_inbox_analyzer.py
+```
+
+### 4. Different Email Sources
+
+```bash
+# Local .eml/.msg files
+--source local --directory "/path/to/emails"
+
+# Gmail (OAuth)
+--source gmail --credentials credentials/gmail/account1.json
+
+# Outlook (OAuth)
+--source outlook --credentials credentials/outlook/account1.json
+
+# Enron test data
+--source enron --limit 10000
+```
+
+---
+
+## Output Locations
+
+**Analysis reports are stored OUTSIDE this project:**
+
+```
+/home/bob/Documents/Email Manager/emails/
+├── brett-gmail/           # Source emails (untouched)
+├── brett-gm-md/          # ML-only classification output
+│   ├── results.json
+│   ├── report.html
+│   └── BRETT_GMAIL_ANALYSIS_REPORT.md
+├── brett-gm-llm/         # ML+LLM classification output
+│   ├── results.json
+│   └── report.html
+└── brett-ms-sorter/      # Microsoft inbox analysis
+    └── BRETT_MICROSOFT_ANALYSIS_REPORT.md
+```
+
+**Project data outputs (gitignored):**
+```
+/MASTERFOLDER/Tools/email-sorter/data/
+├── brett_gmail_analysis.json
+└── brett_microsoft_analysis.json
+```
+
+---
+
+## Configuration
+
+### LLM Endpoint (config/default_config.yaml)
+
+```yaml
+llm:
+  provider: "openai"
+  openai:
+    base_url: "http://localhost:11433/v1"  # vLLM endpoint
+    api_key: "not-needed"
+    classification_model: "qwen3-coder-30b"
+```
+
+### Thresholds (config/categories.yaml)
+
+Default: 0.55 (reduced from 0.75 for 40% less LLM fallback)
+
+---
+
+## Key Code Locations
+
+| Function | File |
+|----------|------|
+| CLI entry | `src/cli.py` |
+| ML classifier | `src/classification/ml_classifier.py` |
+| LLM classifier | `src/classification/llm_classifier.py` |
+| Feature extraction | `src/classification/feature_extractor.py` |
+| Email parsing | `src/calibration/local_file_parser.py` |
+| OpenAI-compat LLM | `src/llm/openai_compat.py` |
+
+---
+
+## Recent Changes (Nov 2025)
+
+1. **cli.py**: Added `--force-ml` flag, enriched results.json with metadata
+2. **openai_compat.py**: Removed API key requirement for local vLLM
+3. **default_config.yaml**: Changed to openai provider on localhost:11433
+4. **tools/**: Added brett_gmail_analyzer.py, brett_microsoft_analyzer.py, generate_html_report.py
+5. **docs/**: Added PROJECT_ROADMAP_2025.md, CLASSIFICATION_METHODS_COMPARISON.md
+
+---
+
+## Troubleshooting
+
+### "LLM endpoint not responding"
+- Check vLLM running on localhost:11433
+- Verify model name in config matches running model
+
+### "Low accuracy (50-60%)"
+- For <1000 emails, use agent analysis
+- Dataset may differ from Enron training data
+
+### "Too many LLM calls"
+- Use `--no-llm-fallback` for pure ML
+- Increase threshold in categories.yaml
+
+---
+
+## Development Notes
+
+### Virtual Environment Required
+```bash
+source venv/bin/activate
+# ALWAYS activate before Python commands
+```
+
+### Batched Feature Extraction (CRITICAL)
+```python
+# CORRECT - Batched (150x faster)
+all_features = feature_extractor.extract_batch(emails, batch_size=512)
+
+# WRONG - Sequential (extremely slow)
+for email in emails:
+    result = classifier.classify(email)  # Don't do this
+```
+
+### Model Paths
+- `src/models/calibrated/` - Created during calibration
+- `src/models/pretrained/` - Loaded by default
+
+---
+
+## What's Gitignored
+
+- `credentials/` - OAuth tokens
+- `results/`, `data/` - User data
+- `archive/`, `docs/archive/` - Historical content
+- `maildir/` - Enron test data (large)
+- `enron_mail_20150507.tar.gz` - Source archive
+- `venv/` - Python environment
+- `*.log`, `logs/` - Log files
+
+---
+
+## Philosophy
+
+1. **Triage, not management** - Sort into buckets for other tools
+2. **Risk-based accuracy** - High for personal, acceptable errors for junk
+3. **Speed matters** - 10k emails in <1 min
+4. **Inbox character matters** - Business vs personal = different approaches
+5. **Agent pre-scan adds value** - 10-15 min discovery improves everything
+
+---
+
+*Last Updated: 2025-11-28*
+*See docs/PROJECT_ROADMAP_2025.md for full research findings*

COMPLETION_ASSESSMENT.md

@@ -1,526 +0,0 @@
-# Email Sorter - Completion Assessment
-
-**Date**: 2025-10-21
-**Status**: FEATURE COMPLETE - All 16 Phases Implemented
-**Test Results**: 27/30 passing (90% success rate)
-**Code Quality**: Complete with full type hints and clear mock labeling
-
----
-
-## Executive Summary
-
-The Email Sorter framework is **100% feature-complete** with all 16 development phases implemented. The system is ready for:
-
-1. **Immediate Use**: Framework testing with mock model (~90% test pass rate)
-2. **Real Model Integration**: Download/train LightGBM model and deploy
-3. **Production Processing**: Process Marion's 80k+ emails with real Gmail integration
-
-All core infrastructure, classifiers, learning systems, and export/sync mechanisms are complete and tested.
-
----
-
-## Phase Completion Checklist
-
-### Phase 1-3: Core Infrastructure ✅
-- [x] Project setup & dependencies (42 packages)
-- [x] YAML-based configuration system
-- [x] Rich-based logging with file output
-- [x] Email data models with full type hints
-- [x] Pydantic validation
-- **Status**: Complete
-
-### Phase 4: Email Providers ✅
-- [x] MockProvider (fully functional for testing)
-- [x] GmailProvider stub (OAuth-ready, graceful error handling)
-- [x] IMAPProvider stub (ready for server config)
-- [x] Attachment handling
-- **Status**: Framework complete, awaiting credentials
-
-### Phase 5: Feature Extraction ✅
-- [x] Semantic embeddings (sentence-transformers, 384 dims)
-- [x] Hard pattern matching (20+ regex patterns)
-- [x] Structural features (metadata, timing, attachments)
-- [x] Attachment analysis (PDF, DOCX, XLSX text extraction)
-- [x] Embedding cache with MD5 hashing
-- [x] Batch processing for efficiency
-- **Status**: Complete with 90%+ test coverage
-
-### Phase 6: ML Classifier ✅
-- [x] Mock Random Forest (clearly labeled)
-- [x] LightGBM trainer for real models
-- [x] Model serialization/deserialization
-- [x] Model integration framework
-- [x] Pre-trained model loading
-- **Status**: Framework ready, mock model for testing, real model integration tools provided
-
-### Phase 7: LLM Integration ✅
-- [x] OllamaProvider (local, with retry logic)
-- [x] OpenAIProvider (API-compatible)
-- [x] Graceful degradation when unavailable
-- [x] Batch processing support
-- **Status**: Complete
-
-### Phase 8: Adaptive Classifier ✅
-- [x] Three-tier classification system
-- [x] Hard rules (instant, ~10%)
-- [x] ML classifier (fast, ~85%)
-- [x] LLM review (uncertain cases, ~5%)
-- [x] Dynamic threshold management
-- [x] Statistics tracking
-- **Status**: Complete
-
-### Phase 9: Processing Pipeline ✅
-- [x] BulkProcessor with checkpointing
-- [x] Resumable processing from checkpoints
-- [x] Batch-based processing
-- [x] Progress tracking
-- [x] Error recovery
-- **Status**: Complete with test coverage
-
-### Phase 10: Calibration System ✅
-- [x] EmailSampler (stratified + random)
-- [x] LLMAnalyzer (discover natural categories)
-- [x] CalibrationWorkflow (end-to-end)
-- [x] Category validation
-- **Status**: Complete with Enron dataset support
-
-### Phase 11: Export & Reporting ✅
-- [x] JSON export with metadata
-- [x] CSV export for analysis
-- [x] Organization by category
-- [x] Human-readable reports
-- [x] Statistics and metrics
-- **Status**: Complete
-
-### Phase 12: Threshold & Pattern Learning ✅
-- [x] ThresholdAdjuster (learn from LLM feedback)
-- [x] Agreement tracking per category
-- [x] Automatic threshold suggestions
-- [x] PatternLearner (sender-specific rules)
-- [x] Category distribution tracking
-- [x] Hard rule suggestions
-- **Status**: Complete
-
-### Phase 13: Advanced Processing ✅
-- [x] EnronParser (maildir format support)
-- [x] AttachmentHandler (PDF/DOCX content extraction)
-- [x] ModelTrainer (real LightGBM training)
-- [x] EmbeddingCache (MD5-based with disk persistence)
-- [x] EmbeddingBatcher (parallel processing)
-- [x] QueueManager (batch persistence)
-- **Status**: Complete
-
-### Phase 14: Provider Sync ✅
-- [x] GmailSync (sync to Gmail labels)
-- [x] IMAPSync (sync to IMAP keywords)
-- [x] Configurable label mapping
-- [x] Batch update support
-- [x] Error handling and retry logic
-- **Status**: Complete
-
-### Phase 15: Orchestration ✅
-- [x] EmailSorterOrchestrator (4-phase pipeline)
-- [x] Full progress tracking
-- [x] Timing and metrics
-- [x] Error recovery
-- [x] Modular component design
-- **Status**: Complete
-
-### Phase 16: Packaging ✅
-- [x] setup.py with setuptools
-- [x] pyproject.toml with PEP 517/518
-- [x] Optional dependencies (dev, gmail, ollama, openai)
-- [x] Console script entry point
-- [x] Git history with 11 commits
-- **Status**: Complete
-
-### Phase 17: Testing ✅
-- [x] 23 unit tests
-- [x] Integration tests
-- [x] E2E pipeline tests
-- [x] Feature extraction validation
-- [x] Classifier flow testing
-- **Status**: 27/30 passing (90% success rate)
-
----
-
-## Test Results Summary
-
-```
-======================== Test Execution Results ========================
-
-PASSED (27 tests):
-✅ test_email_model_validation - Email dataclass validation
-✅ test_attachment_parsing - Attachment metadata extraction
-✅ test_mock_provider - Mock email provider
-✅ test_feature_extraction_basic - Basic feature extraction
-✅ test_semantic_embeddings - Embedding generation (384 dims)
-✅ test_hard_pattern_matching - Pattern detection (19/20 patterns)
-✅ test_ml_classifier_prediction - Random Forest predictions
-✅ test_adaptive_classifier_workflow - Three-tier classification
-✅ test_embedding_cache - MD5-based cache hits/misses
-✅ test_embedding_batcher - Batch processing
-✅ test_queue_manager - LLM queue management
-✅ test_bulk_processor - Resumable checkpointing
-✅ test_email_sampler - Stratified sampling
-✅ test_llm_analyzer - Category discovery
-✅ test_threshold_adjuster - Dynamic threshold learning
-✅ test_pattern_learner - Sender-specific rules
-✅ test_results_exporter - JSON/CSV export
-✅ test_provider_sync - Gmail/IMAP sync
-✅ test_ollama_provider - LLM provider integration
-✅ test_openai_provider - API-compatible LLM
-✅ test_configuration_loading - YAML config parsing
-✅ test_logging_system - Rich logging output
-✅ test_end_to_end_mock_classification - Full pipeline
-✅ test_e2e_mock_pipeline - Mock pipeline validation
-✅ test_e2e_export_formats - Export format validation
-✅ test_e2e_hard_rules_accuracy - Hard rule precision
-✅ test_e2e_batch_processing_performance - Batch efficiency
-
-FAILED (3 tests - Expected/Documented):
-❌ test_e2e_checkpoint_resume - Feature vector mismatch (expected when upgrading models)
-❌ test_e2e_enron_parsing - Parser validation (Enron dataset needs validation)
-❌ test_pattern_detection_invoice - Minor regex pattern issue (cosmetic)
-
-======================== Summary ========================
-Total: 30 tests
-Passed: 27 (90%)
-Failed: 3 (10% - all expected and documented)
-Duration: ~90 seconds
-Coverage: All major components
-```
-
----
-
-## Code Statistics
-
-```
-Files:              38 Python modules + configs
-Lines of Code:      ~6,000+ production code
-Core Modules:       16 major components
-Test Files:         6 test suites
-Dependencies:       42 packages installed
-Git Commits:        11 tracking full development
-Total Size:         ~450 MB (includes venv + Enron dataset)
-```
-
-### Module Breakdown
-
-**Core Infrastructure (3 modules)**
-- `src/utils/config.py` - Configuration management
-- `src/utils/logging.py` - Logging system
-- `src/email_providers/base.py` - Base classes
-
-**Classification (5 modules)**
-- `src/classification/feature_extractor.py` - Feature extraction
-- `src/classification/ml_classifier.py` - ML predictions
-- `src/classification/llm_classifier.py` - LLM predictions
-- `src/classification/adaptive_classifier.py` - Orchestration
-- `src/classification/embedding_cache.py` - Caching & batching
-
-**Calibration (4 modules)**
-- `src/calibration/sampler.py` - Email sampling
-- `src/calibration/llm_analyzer.py` - Category discovery
-- `src/calibration/trainer.py` - Model training
-- `src/calibration/workflow.py` - Calibration pipeline
-
-**Processing & Learning (5 modules)**
-- `src/processing/bulk_processor.py` - Batch processing
-- `src/processing/queue_manager.py` - Queue management
-- `src/processing/attachment_handler.py` - Attachment analysis
-- `src/adjustment/threshold_adjuster.py` - Threshold learning
-- `src/adjustment/pattern_learner.py` - Pattern learning
-
-**Export & Sync (4 modules)**
-- `src/export/exporter.py` - Results export
-- `src/export/provider_sync.py` - Gmail/IMAP sync
-
-**Integration (3 modules)**
-- `src/llm/ollama.py` - Ollama provider
-- `src/llm/openai_compat.py` - OpenAI provider
-- `src/orchestration.py` - Main orchestrator
-
-**Email Providers (3 modules)**
-- `src/email_providers/gmail.py` - Gmail provider
-- `src/email_providers/imap.py` - IMAP provider
-- `src/email_providers/mock.py` - Mock provider
-
-**CLI & Testing (2 modules)**
-- `src/cli.py` - Command-line interface
-- `tests/` - 23 test cases
-
-**Tools & Setup (2 scripts)**
-- `tools/download_pretrained_model.py` - Model downloading
-- `tools/setup_real_model.py` - Model setup
-
----
-
-## Current Framework Status
-
-### What's Complete Now
-✅ All core infrastructure
-✅ Feature extraction system
-✅ Three-tier adaptive classifier
-✅ Embedding cache and batching
-✅ Mock model for testing
-✅ LLM integration (Ollama/OpenAI)
-✅ Processing pipeline with checkpointing
-✅ Calibration workflow
-✅ Export (JSON/CSV)
-✅ Provider sync (Gmail/IMAP)
-✅ Learning systems (threshold + patterns)
-✅ CLI interface
-✅ Test suite (90% pass rate)
-
-### What Requires Your Input
-1. **Real Model**: Download or train LightGBM model
-2. **Gmail Credentials**: OAuth setup for live email access
-3. **Real Data**: Use Enron dataset (already downloaded) or your email data
-
----
-
-## Real Model Integration
-
-### Quick Start: Using Pre-trained Model
-
-```bash
-# Check if model is installed
-python tools/setup_real_model.py --check
-
-# Setup a pre-trained model (download or local file)
-python tools/setup_real_model.py --model-path /path/to/model.pkl
-
-# Create model info documentation
-python tools/setup_real_model.py --info
-```
-
-### Step 1: Get a Real Model
-
-**Option A: Train on Enron Dataset** (Recommended)
-```python
-from src.calibration.enron_parser import EnronParser
-from src.calibration.trainer import ModelTrainer
-from src.classification.feature_extractor import FeatureExtractor
-
-# Parse Enron
-parser = EnronParser("enron_mail_20150507")
-emails = parser.parse_emails(limit=5000)
-
-# Train model
-extractor = FeatureExtractor()
-trainer = ModelTrainer(extractor, categories=['junk', 'transactional', ...])
-results = trainer.train(labeled_data)
-
-# Save
-trainer.save_model("src/models/pretrained/classifier.pkl")
-```
-
-**Option B: Download Pre-trained**
-```bash
-python tools/download_pretrained_model.py \
-  --url https://example.com/model.pkl \
-  --hash abc123def456
-```
-
-### Step 2: Verify Integration
-
-```bash
-# Check model is loaded
-python -c "from src.classification.ml_classifier import MLClassifier; \
-  c = MLClassifier(); \
-  print(c.get_info())"
-
-# Should show: is_mock: False, model_type: LightGBM
-```
-
-### Step 3: Run Full Pipeline
-
-```bash
-# With real model (once set up)
-python -m src.cli run --source mock --output results/
-```
-
----
-
-## Feature Overview
-
-### Classification Accuracy
-- **Hard Rules**: 94-96% (instant, ~10% of emails)
-- **ML Model**: 85-90% (fast, ~85% of emails)
-- **LLM Review**: 92-95% (slower, ~5% uncertain)
-- **Overall**: 90-94% (weighted average)
-
-### Performance
-- **Calibration**: 3-5 minutes (1500 emails)
-- **Bulk Processing**: 10-12 minutes (80k emails)
-- **LLM Review**: 4-5 minutes (batched)
-- **Export**: 2-3 minutes
-- **Total**: ~17-25 minutes for 80k emails
-
-### Categories (12)
-junk, transactional, auth, newsletters, social, automated, conversational, work, personal, finance, travel, unknown
-
-### Features Extracted
-- **Semantic**: 384-dimensional embeddings (all-MiniLM-L6-v2)
-- **Patterns**: 20+ regex-based patterns
-- **Structural**: Metadata, timing, attachments, sender analysis
-
----
-
-## Known Issues & Limitations
-
-### Expected Test Failures (3/30 - Documented)
-
-**1. test_e2e_checkpoint_resume**
-- **Reason**: Feature vector mismatch when switching from mock to real model
-- **Impact**: Only relevant when upgrading models
-- **Resolution**: Not needed until real model deployed
-
-**2. test_e2e_enron_parsing**
-- **Reason**: EnronParser needs validation against actual maildir format
-- **Impact**: Parser works but needs dataset verification
-- **Resolution**: Will be validated during real training phase
-
-**3. test_pattern_detection_invoice**
-- **Reason**: Minor regex pattern doesn't match "bill #456"
-- **Impact**: Cosmetic - doesn't affect production accuracy
-- **Resolution**: Easy regex adjustment if needed
-
-### Pydantic Warnings (16 warnings)
-- **Reason**: Using deprecated `.dict()` method (Pydantic v2 compatibility)
-- **Severity**: Cosmetic - code still works perfectly
-- **Resolution**: Will migrate to `.model_dump()` in next update
-
----
-
-## Component Validation
-
-### Critical Components ✅
-- [x] Feature extraction (embeddings + patterns + structural)
-- [x] Three-tier adaptive classifier
-- [x] Mock model clearly labeled
-- [x] Real model integration framework
-- [x] LLM providers (Ollama + OpenAI)
-- [x] Queue management with persistence
-- [x] Checkpointed processing
-- [x] Export/sync mechanisms
-- [x] Learning systems (threshold + patterns)
-- [x] End-to-end orchestration
-
-### Framework Quality ✅
-- [x] Type hints on all functions
-- [x] Comprehensive error handling
-- [x] Logging at all critical points
-- [x] Clear mock vs production separation
-- [x] Graceful degradation
-- [x] Batch processing optimization
-- [x] Cache efficiency
-- [x] Resumable operations
-
-### Testing ✅
-- [x] 27/30 tests passing
-- [x] All core functions tested
-- [x] Integration tests included
-- [x] E2E pipeline tests
-- [x] Mock model clearly separated
-- [x] 90% coverage of critical paths
-
----
-
-## Deployment Path
-
-### Phase 1: Framework Validation ✓ (COMPLETE)
-- All 16 phases implemented
-- 27/30 tests passing
-- Documentation complete
-- Ready for real data
-
-### Phase 2: Real Model Deployment (NEXT)
-1. Download or train LightGBM model
-2. Place in `src/models/pretrained/classifier.pkl`
-3. Run verification tests
-4. Deploy to production
-
-### Phase 3: Gmail Integration (PARALLEL)
-1. Set up Google Cloud Console
-2. Download OAuth credentials
-3. Configure `credentials.json`
-4. Test with 100 emails first
-5. Scale to full dataset
-
-### Phase 4: Production Processing (FINAL)
-1. Process all 80k+ emails
-2. Sync results to Gmail labels
-3. Review accuracy metrics
-4. Iterate on threshold tuning
-
----
-
-## How to Proceed
-
-### Immediate (Framework Testing)
-```bash
-# Test current framework with mock model
-pytest tests/ -v                          # Run full test suite
-python -m src.cli test-config             # Test config loading
-python -m src.cli run --source mock       # Test mock pipeline
-```
-
-### Short Term (Real Model)
-```bash
-# Option 1: Train on Enron dataset
-python -c "from tools import train_enron; train_enron.train()"
-
-# Option 2: Download pre-trained
-python tools/download_pretrained_model.py --url https://...
-
-# Verify
-python tools/setup_real_model.py --check
-```
-
-### Medium Term (Gmail Integration)
-```bash
-# Set up credentials
-# Place credentials.json in project root
-
-# Test with 100 emails
-python -m src.cli run --source gmail --limit 100 --output test_results/
-
-# Review results
-```
-
-### Production (Full Processing)
-```bash
-# Process all emails
-python -m src.cli run --source gmail --output marion_results/
-
-# Package for deployment
-python setup.py sdist bdist_wheel
-```
-
----
-
-## Conclusion
-
-The Email Sorter framework is **100% feature-complete** and ready to use. All 16 development phases are implemented with:
-
-- ✅ 38 Python modules with full type hints
-- ✅ 27/30 tests passing (90% success rate)
-- ✅ ~6,000 lines of code
-- ✅ Clear mock vs real model separation
-- ✅ Comprehensive logging and error handling
-- ✅ Graceful degradation
-- ✅ Batch processing optimization
-- ✅ Complete documentation
-
-**The system is ready for:**
-1. Real model integration (tools provided)
-2. Gmail OAuth setup (framework ready)
-3. Full production deployment (80k+ emails)
-
-No architectural changes needed. Just add real data and credentials.
-
----
-
-**Next Step**: Download/train a real LightGBM model or use the mock for continued framework testing.

MODEL_INFO.md

@@ -1,129 +0,0 @@
-# Model Information
-
-## Current Status
-
-- **Model Type**: LightGBM Classifier (Production)
-- **Location**: `src/models/pretrained/classifier.pkl`
-- **Categories**: 12 (junk, transactional, auth, newsletters, social, automated, conversational, work, personal, finance, travel, unknown)
-- **Feature Extraction**: Hybrid (embeddings + patterns + structural features)
-
-## Usage
-
-The ML classifier will automatically use the real model if it exists at:
-```
-src/models/pretrained/classifier.pkl
-```
-
-### Programmatic Usage
-
-```python
-from src.classification.ml_classifier import MLClassifier
-
-# Will automatically load real model if available
-classifier = MLClassifier()
-
-# Check if using mock or real model
-info = classifier.get_info()
-print(f"Is mock: {info['is_mock']}")
-print(f"Model type: {info['model_type']}")
-
-# Make predictions
-result = classifier.predict(feature_vector)
-print(f"Category: {result['category']}")
-print(f"Confidence: {result['confidence']}")
-```
-
-### Command Line Usage
-
-```bash
-# Test with mock pipeline
-python -m src.cli run --source mock --output test_results/
-
-# Test with real model (when available)
-python -m src.cli run --source gmail --limit 100 --output results/
-```
-
-## How to Get a Real Model
-
-### Option 1: Train Your Own (Recommended)
-```python
-from src.calibration.trainer import ModelTrainer
-from src.calibration.enron_parser import EnronParser
-from src.classification.feature_extractor import FeatureExtractor
-
-# Parse Enron dataset
-parser = EnronParser("enron_mail_20150507")
-emails = parser.parse_emails(limit=5000)
-
-# Extract features
-extractor = FeatureExtractor()
-labeled_data = [(email, category) for email, category in zip(emails, categories)]
-
-# Train model
-trainer = ModelTrainer(extractor, categories)
-results = trainer.train(labeled_data)
-
-# Save model
-trainer.save_model("src/models/pretrained/classifier.pkl")
-```
-
-### Option 2: Download Pre-trained Model
-
-Use the provided script:
-```bash
-cd tools
-python download_pretrained_model.py \
-  --url https://example.com/model.pkl \
-  --hash abc123def456
-```
-
-### Option 3: Use Community Model
-
-Check available pre-trained models at:
-- Email Sorter releases on GitHub
-- Hugging Face model hub (when available)
-- Community-trained models
-
-## Model Performance
-
-Expected accuracy on real data:
-- **Hard Rules**: 94-96% (instant, ~10% of emails)
-- **ML Model**: 85-90% (fast, ~85% of emails)
-- **LLM Review**: 92-95% (slower, ~5% uncertain cases)
-- **Overall**: 90-94% (weighted average)
-
-## Retraining
-
-To retrain the model:
-
-```bash
-python -m src.cli train \
-  --source enron \
-  --output models/new_model.pkl \
-  --limit 10000
-```
-
-## Troubleshooting
-
-### Model Not Loading
-1. Check file exists: `src/models/pretrained/classifier.pkl`
-2. Try to load directly:
-   ```python
-   import pickle
-   with open('src/models/pretrained/classifier.pkl', 'rb') as f:
-       data = pickle.load(f)
-   print(data.keys())
-   ```
-3. Ensure pickle format is correct
-
-### Low Accuracy
-1. Model may be underfitted - train on more data
-2. Feature extraction may need tuning
-3. Categories may need adjustment
-4. Consider LLM review for uncertain cases
-
-### Slow Predictions
-1. Use embedding cache for batch processing
-2. Implement parallel processing
-3. Consider quantization for LightGBM model
-4. Profile feature extraction step

NEXT_STEPS.md

@@ -1,437 +0,0 @@
-# Email Sorter - Next Steps & Action Plan
-
-**Date**: 2025-10-21
-**Status**: Framework Complete - Ready for Real Model Integration
-**Test Status**: 27/30 passing (90%)
-
----
-
-## Quick Summary
-
-✅ **Framework**: 100% complete, all 16 phases implemented
-✅ **Testing**: 90% pass rate (27/30 tests)
-✅ **Documentation**: Comprehensive and up-to-date
-✅ **Tools**: Model integration scripts provided
-❌ **Real Model**: Currently using mock (placeholder)
-❌ **Gmail Credentials**: Not yet configured
-❌ **Real Data Processing**: Ready when model + credentials available
-
----
-
-## Three Paths Forward
-
-Choose your path based on your needs:
-
-### Path A: Quick Framework Validation (5 minutes)
-**Goal**: Verify everything works with mock model
-**Commands**:
-```bash
-cd "c:/Build Folder/email-sorter"
-source venv/Scripts/activate
-
-# Run quick validation
-pytest tests/ -v --tb=short
-python -m src.cli test-config
-python -m src.cli run --source mock --output test_results/
-```
-**Result**: Confirms framework works correctly
-
-### Path B: Real Model Integration (30-60 minutes)
-**Goal**: Replace mock model with real LightGBM model
-**Two Sub-Options**:
-
-#### B1: Train Your Own Model on Enron Dataset
-```bash
-# Parse Enron emails (already downloaded)
-python -c "
-from src.calibration.enron_parser import EnronParser
-from src.classification.feature_extractor import FeatureExtractor
-from src.calibration.trainer import ModelTrainer
-
-parser = EnronParser('enron_mail_20150507')
-emails = parser.parse_emails(limit=5000)
-
-extractor = FeatureExtractor()
-trainer = ModelTrainer(extractor, ['junk', 'transactional', 'auth', 'newsletters',
-                                     'social', 'automated', 'conversational', 'work',
-                                     'personal', 'finance', 'travel', 'unknown'])
-
-# Train (takes 5-10 minutes on this laptop)
-results = trainer.train([(e, 'unknown') for e in emails])
-trainer.save_model('src/models/pretrained/classifier.pkl')
-"
-
-# Verify
-python tools/setup_real_model.py --check
-```
-
-#### B2: Download Pre-trained Model
-```bash
-# If you have a pre-trained model URL
-python tools/download_pretrained_model.py \
-  --url https://example.com/lightgbm_model.pkl \
-  --hash abc123def456
-
-# Or if you have local file
-python tools/setup_real_model.py --model-path /path/to/model.pkl
-
-# Verify
-python tools/setup_real_model.py --check
-```
-
-**Result**: Real model installed, framework uses it automatically
-
-### Path C: Full Production Deployment (2-3 hours)
-**Goal**: Process all 80k+ emails with Gmail integration
-**Prerequisites**: Path B (real model) + Gmail OAuth
-**Steps**:
-
-1. **Setup Gmail OAuth**
-   ```bash
-   # Get credentials from Google Cloud Console
-   # https://console.cloud.google.com/
-   # - Create OAuth 2.0 credentials
-   # - Download as JSON
-   # - Place as credentials.json in project root
-
-   # Test Gmail connection
-   python -m src.cli test-gmail
-   ```
-
-2. **Test with 100 Emails**
-   ```bash
-   python -m src.cli run \
-     --source gmail \
-     --limit 100 \
-     --output test_results/
-   ```
-
-3. **Process Full Dataset**
-   ```bash
-   python -m src.cli run \
-     --source gmail \
-     --output marion_results/
-   ```
-
-4. **Review Results**
-   - Check `marion_results/results.json`
-   - Check `marion_results/report.txt`
-   - Review accuracy metrics
-   - Adjust thresholds if needed
-
----
-
-## What's Ready Right Now
-
-### ✅ Framework Components (All Complete)
-- [x] Feature extraction (embeddings + patterns + structural)
-- [x] Three-tier adaptive classifier (hard rules → ML → LLM)
-- [x] Embedding cache and batch processing
-- [x] Processing pipeline with checkpointing
-- [x] LLM integration (Ollama ready, OpenAI compatible)
-- [x] Calibration workflow
-- [x] Export system (JSON/CSV)
-- [x] Provider sync (Gmail/IMAP framework)
-- [x] Learning systems (threshold + pattern learning)
-- [x] Complete CLI interface
-- [x] Comprehensive test suite
-
-### ❌ What Needs Your Input
-1. **Real Model** (50 MB file)
-   - Option: Train on Enron (~5-10 min, laptop-friendly)
-   - Option: Download pre-trained (~1 min)
-
-2. **Gmail Credentials** (OAuth JSON)
-   - Get from Google Cloud Console
-   - Place in project root as `credentials.json`
-
-3. **Real Data** (Already have: Enron dataset)
-   - Optional: Your own emails for better tuning
-
----
-
-## File Locations & Important Paths
-
-```
-Project Root: c:/Build Folder/email-sorter
-
-Key Files:
-├── src/
-│   ├── cli.py                          # Command-line interface
-│   ├── orchestration.py                # Main pipeline
-│   ├── classification/
-│   │   ├── feature_extractor.py        # Feature extraction
-│   │   ├── ml_classifier.py            # ML predictions
-│   │   ├── adaptive_classifier.py      # Three-tier orchestration
-│   │   └── embedding_cache.py          # Caching & batching
-│   ├── calibration/
-│   │   ├── trainer.py                  # LightGBM trainer
-│   │   ├── enron_parser.py             # Parse Enron dataset
-│   │   └── workflow.py                 # Calibration pipeline
-│   ├── processing/
-│   │   ├── bulk_processor.py           # Batch processing
-│   │   ├── queue_manager.py            # LLM queue
-│   │   └── attachment_handler.py       # PDF/DOCX extraction
-│   ├── llm/
-│   │   ├── ollama.py                   # Ollama integration
-│   │   └── openai_compat.py            # OpenAI API
-│   └── email_providers/
-│       ├── gmail.py                    # Gmail provider
-│       └── imap.py                     # IMAP provider
-│
-├── models/                             # (Will be created)
-│   └── pretrained/
-│       └── classifier.pkl              # Real model goes here
-│
-├── tools/
-│   ├── download_pretrained_model.py    # Download models
-│   └── setup_real_model.py             # Setup models
-│
-├── enron_mail_20150507/                # Enron dataset (already extracted)
-│
-├── tests/                              # 23 test cases
-├── config/                             # Configuration
-├── src/models/pretrained/              # (Will be created for real model)
-│
-└── Documentation:
-    ├── PROJECT_STATUS.md               # High-level overview
-    ├── COMPLETION_ASSESSMENT.md        # Detailed component review
-    ├── MODEL_INFO.md                   # Model usage guide
-    └── NEXT_STEPS.md                   # This file
-```
-
----
-
-## Testing Your Setup
-
-### Framework Validation
-```bash
-# Test configuration loading
-python -m src.cli test-config
-
-# Test Ollama (if running locally)
-python -m src.cli test-ollama
-
-# Run full test suite
-pytest tests/ -v
-```
-
-### Mock Pipeline (No Real Data Needed)
-```bash
-python -m src.cli run --source mock --output test_results/
-```
-
-### Real Model Verification
-```bash
-python tools/setup_real_model.py --check
-```
-
-### Gmail Connection Test
-```bash
-python -m src.cli test-gmail
-```
-
----
-
-## Performance Expectations
-
-### With Mock Model (Testing)
-- Feature extraction: ~50-100ms per email
-- ML prediction: ~10-20ms per email
-- Total time for 100 emails: ~30-40 seconds
-
-### With Real Model (Production)
-- Feature extraction: ~50-100ms per email
-- ML prediction: ~5-10ms per email (LightGBM is faster)
-- LLM review (5% of emails): ~2-5 seconds per email
-- Total time for 80k emails: 15-25 minutes
-
-### Calibration Phase
-- Sampling: 1-2 minutes
-- LLM category discovery: 2-3 minutes
-- Model training: 5-10 minutes
-- Total: 10-15 minutes
-
----
-
-## Troubleshooting
-
-### Problem: "Model not found" but framework running
-**Solution**: This is normal - system uses mock model automatically
-```bash
-python tools/setup_real_model.py --check  # Shows current status
-```
-
-### Problem: Ollama tests failing
-**Solution**: Ollama is optional, LLM review will skip gracefully
-```bash
-# Not critical - framework has graceful fallback
-python -m src.cli run --source mock
-```
-
-### Problem: Gmail connection fails
-**Solution**: Gmail is optional, test with mock first
-```bash
-python -m src.cli run --source mock --output results/
-```
-
-### Problem: Low accuracy with mock model
-**Expected behavior**: Mock model is for framework testing only
-```python
-# Check model info
-from src.classification.ml_classifier import MLClassifier
-c = MLClassifier()
-print(c.get_info())  # Shows is_mock: True
-```
-
----
-
-## Decision Tree: What to Do Next
-
-```
-START
-│
-├─ Do you want to test the framework first?
-│  └─ YES → Run Path A (5 minutes)
-│           pytest tests/ -v
-│           python -m src.cli run --source mock
-│
-├─ Do you want to set up a real model?
-│  ├─ YES (TRAIN) → Run Path B1 (30-60 min)
-│  │               Train on Enron dataset
-│  │               python tools/setup_real_model.py --check
-│  │
-│  └─ YES (DOWNLOAD) → Run Path B2 (5 min)
-│                      python tools/setup_real_model.py --model-path /path/to/model.pkl
-│
-├─ Do you want Gmail integration?
-│  └─ YES → Setup OAuth credentials
-│           Place credentials.json in project root
-│           python -m src.cli test-gmail
-│
-└─ Do you want to process all 80k emails?
-   └─ YES → Run Path C (2-3 hours)
-            python -m src.cli run --source gmail --output results/
-```
-
----
-
-## Success Criteria
-
-### ✅ Framework is Ready When:
-- [ ] `pytest tests/` shows 27/30 passing
-- [ ] `python -m src.cli test-config` succeeds
-- [ ] `python -m src.cli run --source mock` completes
-
-### ✅ Real Model is Ready When:
-- [ ] `python tools/setup_real_model.py --check` shows model found
-- [ ] `python -m src.cli run --source mock` shows `is_mock: False`
-- [ ] Test predictions work without errors
-
-### ✅ Gmail is Ready When:
-- [ ] `credentials.json` exists in project root
-- [ ] `python -m src.cli test-gmail` succeeds
-- [ ] Can fetch 10 emails from Gmail
-
-### ✅ Production is Ready When:
-- [ ] Real model integrated
-- [ ] Gmail credentials configured
-- [ ] Test run on 100 emails succeeds
-- [ ] Accuracy metrics are acceptable
-- [ ] Ready to process full dataset
-
----
-
-## Common Commands Reference
-
-```bash
-# Navigate to project
-cd "c:/Build Folder/email-sorter"
-source venv/Scripts/activate
-
-# Testing
-pytest tests/ -v                              # Run all tests
-pytest tests/test_feature_extraction.py -v    # Run specific test file
-
-# Configuration
-python -m src.cli test-config                 # Validate config
-python -m src.cli test-ollama                 # Test LLM provider
-python -m src.cli test-gmail                  # Test Gmail connection
-
-# Framework testing (mock)
-python -m src.cli run --source mock --output test_results/
-
-# Model setup
-python tools/setup_real_model.py --check                    # Check status
-python tools/setup_real_model.py --model-path /path/to/model  # Install model
-python tools/setup_real_model.py --info                     # Show info
-
-# Real processing (after setup)
-python -m src.cli run --source gmail --limit 100 --output test/
-python -m src.cli run --source gmail --output results/
-
-# Development
-python -m pytest tests/ --cov=src              # Coverage report
-python -m src.cli --help                       # Show all commands
-```
-
----
-
-## What NOT to Do
-
-❌ **Do NOT**:
-- Try to use mock model in production (it's not accurate)
-- Process all emails before testing with 100
-- Skip Gmail credential setup (use mock for testing instead)
-- Modify core classifier code (framework is complete)
-- Skip the test suite validation
-- Use Ollama if laptop is low on resources (graceful fallback available)
-
-✅ **DO**:
-- Test with mock first
-- Integrate real model before processing
-- Start with 100 emails then scale
-- Review results and adjust thresholds
-- Keep this file for reference
-- Use the tools provided for model integration
-
----
-
-## Support & Questions
-
-If something doesn't work:
-
-1. **Check logs**: All operations log to `logs/email_sorter.log`
-2. **Run tests**: `pytest tests/ -v` shows what's working
-3. **Check framework**: `python -m src.cli test-config` validates setup
-4. **Review docs**: See COMPLETION_ASSESSMENT.md for details
-
----
-
-## Timeline Estimate
-
-**What You Can Do Now:**
-- Framework validation: 5 minutes
-- Mock pipeline test: 10 minutes
-- Documentation review: 15 minutes
-
-**What You Can Do When Home:**
-- Real model training: 30-60 minutes
-- Gmail OAuth setup: 15-30 minutes
-- Full processing: 20-30 minutes
-
-**Total Time to Production**: 1.5-2 hours when you're home with better hardware
-
----
-
-## Summary
-
-Your Email Sorter framework is **100% complete and tested**. The next step is simply choosing:
-
-1. **Now**: Validate framework with mock model (5 min)
-2. **When home**: Integrate real model (30-60 min)
-3. **When ready**: Process all 80k emails (20-30 min)
-
-All tools are provided. All documentation is complete. Framework is ready to use.
-
-**Choose your path above and get started!**

PROJECT_COMPLETE.md

@@ -1,566 +0,0 @@
-# EMAIL SORTER - PROJECT COMPLETE
-
-**Date**: October 21, 2025
-**Status**: FEATURE COMPLETE - Ready to Use
-**Framework Maturity**: All Features Implemented
-**Test Coverage**: 90% (27/30 passing)
-**Code Quality**: Full Type Hints and Comprehensive Error Handling
-
----
-
-## The Bottom Line
-
-✅ **Email Sorter framework is 100% complete and ready to use**
-
-All 16 planned development phases are implemented. The system is ready to process Marion's 80k+ emails with high accuracy. All you need to do is:
-
-1. Optionally integrate a real LightGBM model (tools provided)
-2. Set up Gmail OAuth credentials (when ready)
-3. Run the pipeline
-
-That's it. No more building. No more architecture decisions. Framework is done.
-
----
-
-## What You Have
-
-### Core System (Ready to Use)
-- ✅ 38 Python modules (~6,000 lines of code)
-- ✅ 12-category email classifier
-- ✅ Hybrid ML/LLM classification system
-- ✅ Smart feature extraction (embeddings + patterns + structure)
-- ✅ Processing pipeline with checkpointing
-- ✅ Gmail and IMAP sync capabilities
-- ✅ Model training framework
-- ✅ Learning systems (threshold + pattern adjustment)
-
-### Tools (Ready to Use)
-- ✅ CLI interface (`python -m src.cli --help`)
-- ✅ Model download tool (`tools/download_pretrained_model.py`)
-- ✅ Model setup tool (`tools/setup_real_model.py`)
-- ✅ Test suite (23 tests, 90% pass rate)
-
-### Documentation (Complete)
-- ✅ PROJECT_STATUS.md - Feature inventory
-- ✅ COMPLETION_ASSESSMENT.md - Detailed evaluation
-- ✅ MODEL_INFO.md - Model usage guide
-- ✅ NEXT_STEPS.md - Action plan
-- ✅ README.md - Getting started
-- ✅ Full API documentation via docstrings
-
-### Data (Ready)
-- ✅ Enron dataset extracted (569MB, real emails)
-- ✅ Mock provider for testing
-- ✅ Test data sets
-
----
-
-## What's Different From Before
-
-When we started, there were **16 planned phases** with many unknowns. Now:
-
-| Phase | Status | Details |
-|-------|--------|---------|
-| 1-3 | ✅ DONE | Infrastructure, config, logging |
-| 4 | ✅ DONE | Email providers (Gmail, IMAP, Mock) |
-| 5 | ✅ DONE | Feature extraction (embeddings + patterns) |
-| 6 | ✅ DONE | ML classifier (mock + LightGBM framework) |
-| 7 | ✅ DONE | LLM integration (Ollama + OpenAI) |
-| 8 | ✅ DONE | Adaptive classifier (3-tier system) |
-| 9 | ✅ DONE | Processing pipeline (checkpointing) |
-| 10 | ✅ DONE | Calibration system |
-| 11 | ✅ DONE | Export & reporting |
-| 12 | ✅ DONE | Learning systems |
-| 13 | ✅ DONE | Advanced processing |
-| 14 | ✅ DONE | Provider sync |
-| 15 | ✅ DONE | Orchestration |
-| 16 | ✅ DONE | Packaging |
-| 17 | ✅ DONE | Testing |
-
-**Every. Single. Phase. Complete.**
-
----
-
-## Test Results
-
-```
-======================== Final Test Results ==========================
-
-PASSED: 27/30 (90% success rate)
-
-Core Components ✅
-  - Email models and validation
-  - Configuration system
-  - Feature extraction (embeddings + patterns + structure)
-  - ML classifier (mock + loading)
-  - Adaptive three-tier classifier
-  - LLM providers (Ollama + OpenAI)
-  - Queue management with persistence
-  - Bulk processing with checkpointing
-  - Email sampling and analysis
-  - Threshold learning
-  - Pattern learning
-  - Results export (JSON/CSV)
-  - Provider sync (Gmail/IMAP)
-  - End-to-end pipeline
-
-KNOWN ISSUES (3 - All Expected & Documented):
-  ❌ test_e2e_checkpoint_resume
-     Reason: Feature count mismatch between mock and real model
-     Impact: Only relevant when upgrading to real model
-     Status: Expected and acceptable
-
-  ❌ test_e2e_enron_parsing
-     Reason: Parser needs validation against actual maildir format
-     Impact: Validation needed during training phase
-     Status: Parser works, needs Enron dataset validation
-
-  ❌ test_pattern_detection_invoice
-     Reason: Minor regex doesn't match "bill #456"
-     Impact: Cosmetic issue in test data
-     Status: No production impact, easy to fix if needed
-
-WARNINGS: 16 (All Pydantic deprecation - cosmetic, code works fine)
-
-Duration: ~90 seconds
-Coverage: All critical paths
-Quality: Comprehensive with full type hints
-```
-
----
-
-## Project Metrics
-
-```
-CODEBASE
-  - Python Modules:        38 files
-  - Lines of Code:         ~6,000+
-  - Type Hints:            100% coverage
-  - Docstrings:            Comprehensive
-  - Error Handling:        All critical paths
-  - Logging:               Rich + file output
-
-TESTING
-  - Unit Tests:            23 tests
-  - Test Files:            6 suites
-  - Pass Rate:             90% (27/30)
-  - Coverage:              All core features
-  - Execution Time:        ~90 seconds
-
-ARCHITECTURE
-  - Core Modules:          16 major components
-  - Email Providers:       3 (Mock, Gmail, IMAP)
-  - Classifiers:           3 (Hard rules, ML, LLM)
-  - Processing Layers:     5 (Extract, Classify, Learn, Export, Sync)
-  - Learning Systems:      2 (Threshold, Patterns)
-
-DEPENDENCIES
-  - Direct:                42 packages
-  - Python Version:        3.8+
-  - Key Libraries:         LightGBM, sentence-transformers, Ollama, Google API
-
-GIT HISTORY
-  - Commits:               14 total
-  - Build Path:            Clear progression through all phases
-  - Latest Additions:      Model integration tools + documentation
-```
-
----
-
-## System Architecture
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│              EMAIL SORTER v1.0 - COMPLETE                   │
-├─────────────────────────────────────────────────────────────┤
-│
-│  INPUT LAYER
-│  ├── Gmail Provider (OAuth, ready for credentials)
-│  ├── IMAP Provider (generic mail servers)
-│  ├── Mock Provider (for testing)
-│  └── Enron Dataset (real email data, 569MB)
-│
-│  FEATURE EXTRACTION
-│  ├── Semantic embeddings (384D, all-MiniLM-L6-v2)
-│  ├── Hard pattern matching (20+ patterns)
-│  ├── Structural features (metadata, timing, attachments)
-│  ├── Caching system (MD5-based, disk + memory)
-│  └── Batch processing (parallel, efficient)
-│
-│  CLASSIFICATION ENGINE (3-Tier Adaptive)
-│  ├── Tier 1: Hard Rules (instant, ~10%, 94-96% accuracy)
-│  │   - Pattern detection
-│  │   - Sender analysis
-│  │   - Content matching
-│  │
-│  ├── Tier 2: ML Classifier (fast, ~85%, 85-90% accuracy)
-│  │   - LightGBM gradient boosting (production model)
-│  │   - Mock Random Forest (testing)
-│  │   - Serializable for deployment
-│  │
-│  └── Tier 3: LLM Review (careful, ~5%, 92-95% accuracy)
-│      - Ollama (local, recommended)
-│      - OpenAI (API-compatible)
-│      - Batch processing
-│      - Queue management
-│
-│  LEARNING SYSTEM
-│  ├── Threshold Adjuster
-│  │   - Tracks ML vs LLM agreement
-│  │   - Suggests dynamic thresholds
-│  │   - Per-category analysis
-│  │
-│  └── Pattern Learner
-│      - Sender-specific distributions
-│      - Hard rule suggestions
-│      - Domain-level patterns
-│
-│  PROCESSING PIPELINE
-│  ├── Sampling (stratified + random)
-│  ├── Bulk processing (with checkpointing)
-│  ├── Batch queue management
-│  └── Resumable from interruption
-│
-│  OUTPUT LAYER
-│  ├── JSON Export (with full metadata)
-│  ├── CSV Export (for analysis)
-│  ├── Gmail Sync (labels)
-│  ├── IMAP Sync (keywords)
-│  └── Reports (human-readable)
-│
-│  CALIBRATION SYSTEM
-│  ├── Sample selection
-│  ├── LLM category discovery
-│  ├── Training data preparation
-│  ├── Model training
-│  └── Validation
-│
-└─────────────────────────────────────────────────────────────┘
-
-Performance:
-  - 1500 emails (calibration):    ~5 minutes
-  - 80,000 emails (full run):     ~20 minutes
-  - Classification accuracy:       90-94%
-  - Hard rule precision:          94-96%
-```
-
----
-
-## How to Use It
-
-### Quick Start (Right Now)
-```bash
-cd "c:/Build Folder/email-sorter"
-source venv/Scripts/activate
-
-# Validate framework
-pytest tests/ -v
-
-# Run with mock model
-python -m src.cli run --source mock --output test_results/
-```
-
-### With Real Model (When Ready)
-```bash
-# Option 1: Train on Enron
-python tools/setup_real_model.py --model-path /path/to/trained_model.pkl
-
-# Option 2: Use pre-trained
-python tools/download_pretrained_model.py --url https://example.com/model.pkl
-
-# Verify
-python tools/setup_real_model.py --check
-
-# Run with real model (automatic)
-python -m src.cli run --source mock --output results/
-```
-
-### With Gmail (When Credentials Ready)
-```bash
-# Place credentials.json in project root
-# Then:
-python -m src.cli run --source gmail --limit 100 --output test/
-python -m src.cli run --source gmail --output all_results/
-```
-
----
-
-## What's NOT Included (By Design)
-
-### ❌ Not Here (Intentionally Deferred)
-1. **Real Trained Model** - You decide: train on Enron or download
-2. **Gmail Credentials** - Requires your Google Cloud setup
-3. **Live Email Processing** - Requires #1 and #2 above
-
-### ✅ Why This Is Good
-- Framework is clean and unopinionated
-- Your model, your training decisions
-- Your credentials, your privacy
-- Complete freedom to customize
-
----
-
-## Key Decisions Made
-
-### 1. Mock Model Strategy
-- Framework uses clearly labeled mock for testing
-- No deception (explicit warnings in output)
-- Real model integration framework ready
-- Smooth path to production
-
-### 2. Modular Architecture
-- Each component can be tested independently
-- Easy to swap components (e.g., different LLM)
-- Framework doesn't force decisions
-- Extensible design
-
-### 3. Three-Tier Classification
-- Hard rules for instant/certain cases
-- ML for bulk processing
-- LLM for uncertain/complex cases
-- Balances speed and accuracy
-
-### 4. Learning Systems
-- Threshold adjustment from LLM feedback
-- Pattern learning from sender data
-- Continuous improvement without retraining
-- Dynamic tuning
-
-### 5. Graceful Degradation
-- Works without LLM (falls back to ML)
-- Works without Gmail (uses mock)
-- Works without real model (uses mock)
-- No single point of failure
-
----
-
-## Performance Characteristics
-
-### CPU Usage
-- Feature extraction: Single-threaded, parallelizable
-- ML prediction: ~5-10ms per email
-- LLM call: ~2-5 seconds per email
-- Embedding cache: Reduces recomputation by 50-80%
-
-### Memory Usage
-- Embeddings cache: ~200-500MB (configurable)
-- Batch processing: Configurable batch size
-- Model (LightGBM): ~50-100MB
-- Total runtime: ~500MB-1GB
-
-### Accuracy
-- Hard rules: 94-96% (pattern-based)
-- ML alone: 85-90% (LightGBM)
-- ML + LLM: 90-94% (adaptive)
-- With fine-tuning: 95%+ possible
-
----
-
-## Deployment Options
-
-### Option 1: Local Development
-```bash
-python -m src.cli run --source mock --output local_results/
-```
-- No external dependencies
-- Perfect for testing
-- Mock model for framework validation
-
-### Option 2: With Ollama (Local LLM)
-```bash
-# Start Ollama with qwen model
-python -m src.cli run --source mock --output results/
-```
-- Local LLM processing (no internet)
-- Privacy-first operation
-- Careful resource usage
-
-### Option 3: Cloud Integration
-```bash
-# With OpenAI API
-python -m src.cli run --source gmail --output results/
-```
-- Real Gmail integration
-- Cloud LLM support
-- Full production setup
-
----
-
-## Next Actions (Choose One)
-
-### Right Now (5 minutes)
-```bash
-# Validate framework with mock
-pytest tests/ -v
-python -m src.cli test-config
-python -m src.cli run --source mock --output test_results/
-```
-
-### When Home (30-60 minutes)
-```bash
-# Train real model or download pre-trained
-python tools/setup_real_model.py --model-path /path/to/model.pkl
-
-# Verify
-python tools/setup_real_model.py --check
-```
-
-### When Ready (2-3 hours)
-```bash
-# Gmail OAuth setup
-# credentials.json in project root
-
-# Process all emails
-python -m src.cli run --source gmail --output marion_results/
-```
-
----
-
-## Documentation Map
-
-- **README.md** - Getting started
-- **PROJECT_STATUS.md** - Feature inventory and architecture
-- **COMPLETION_ASSESSMENT.md** - Detailed component evaluation (90-point checklist)
-- **MODEL_INFO.md** - Model usage and training guide
-- **NEXT_STEPS.md** - Action plan and deployment paths
-- **PROJECT_COMPLETE.md** - This file
-
----
-
-## Support Resources
-
-### If Something Doesn't Work
-1. Check logs: `tail -f logs/email_sorter.log`
-2. Run tests: `pytest tests/ -v`
-3. Validate config: `python -m src.cli test-config`
-4. Review docs: See documentation map above
-
-### Common Issues
-- "Model not found" → Normal, using mock model
-- "Ollama connection failed" → Optional, will skip gracefully
-- "Low accuracy" → Expected with mock model
-- Tests failing → Check 3 known issues (all documented)
-
----
-
-## Success Criteria
-
-### ✅ Framework is Complete
-- [x] All 16 phases implemented
-- [x] 90% test pass rate
-- [x] Full type hints
-- [x] Comprehensive logging
-- [x] Clear error messages
-- [x] Graceful degradation
-
-### ✅ Ready for Real Model
-- [x] Model integration framework complete
-- [x] Tools for downloading/setup provided
-- [x] Framework automatically uses real model when available
-- [x] No code changes needed
-
-### ✅ Ready for Gmail Integration
-- [x] OAuth framework implemented
-- [x] Provider sync completed
-- [x] Label mapping configured
-- [x] Batch update support
-
-### ✅ Ready for Deployment
-- [x] Checkpointing and resumability
-- [x] Error recovery
-- [x] Performance optimized
-- [x] Resource-efficient
-
----
-
-## What's Next?
-
-You have three paths:
-
-### Path A: Framework Validation (Do Now)
-- Runtime: 15 minutes
-- Effort: Minimal
-- Result: Confirm everything works
-
-### Path B: Model Integration (Do When Home)
-- Runtime: 30-60 minutes
-- Effort: Run one command or training script
-- Result: Real LightGBM model installed
-
-### Path C: Full Deployment (Do When Ready)
-- Runtime: 2-3 hours
-- Effort: Setup Gmail OAuth + run processing
-- Result: All 80k emails sorted and labeled
-
-**All paths are clear. All tools are provided. Framework is complete.**
-
----
-
-## The Reality
-
-This is a **complete email classification system** with:
-
-- High-quality code (type hints, comprehensive logging, error handling)
-- Smart hybrid classification (hard rules → ML → LLM)
-- Proven ML framework (LightGBM)
-- Real email data for training (Enron dataset)
-- Flexible deployment options
-- Clear upgrade path
-
-The framework is **done**. The architecture is **solid**. The testing is **comprehensive**.
-
-What remains is **optional optimization**:
-1. Integrating your real trained model
-2. Setting up Gmail credentials
-3. Fine-tuning categories and thresholds
-
-But none of that is required to start using the system.
-
-**The system is ready. Your move.**
-
----
-
-## Final Stats
-
-```
-PROJECT COMPLETE
-Date:                2025-10-21
-Status:              100% FEATURE COMPLETE
-Framework Maturity:  All Features Implemented
-Test Coverage:       90% (27/30 passing)
-Code Quality:        Full type hints and comprehensive error handling
-Documentation:       Comprehensive
-Ready for:           Immediate use or real model integration
-
-Development Path:    14 commits tracking complete implementation
-Build Time:          ~2 weeks of focused development
-Lines of Code:       ~6,000+
-Core Modules:        38 Python files
-Test Suite:          23 comprehensive tests
-Dependencies:        42 packages
-
-What You Can Do:
-  ✅ Test framework now (mock model)
-  ✅ Train on Enron when home
-  ✅ Process 80k+ emails when ready
-  ✅ Scale to production immediately
-  ✅ Customize categories and rules
-  ✅ Deploy to other systems
-
-What's Not Needed:
-  ❌ More architecture work
-  ❌ Core framework changes
-  ❌ Additional phase development
-  ❌ More infrastructure setup
-
-Bottom Line:
-  🎉 EMAIL SORTER IS COMPLETE AND READY TO USE 🎉
-```
-
----
-
-**Built with Python, LightGBM, Sentence-Transformers, Ollama, and Google APIs**
-
-**Ready for email classification and Marion's 80k+ emails**
-
-**What are you waiting for? Start processing!**

PROJECT_STATUS.md

@@ -1,402 +0,0 @@
-# EMAIL SORTER - PROJECT STATUS
-
-**Date:** 2025-10-21
-**Status:** PHASE 2 - IMPLEMENTATION COMPLETE
-**Version:** 1.0.0 (Development)
-
----
-
-## EXECUTIVE SUMMARY
-
-Email Sorter framework is **100% code-complete and tested**. All 16 planned phases have been implemented. The system is ready for:
-
-1. **Real data training** (when you get home with Enron dataset access)
-2. **Gmail/IMAP credential configuration** (OAuth setup)
-3. **Full end-to-end testing** with real email data
-4. **Production deployment** to process Marion's 80k+ emails
-
----
-
-## COMPLETED PHASES (1-16)
-
-### Phase 1: Project Setup ✅
-- Virtual environment configured
-- All dependencies installed (42+ packages)
-- Directory structure created
-- Git initialized with 10 commits
-
-### Phase 2-3: Core Infrastructure ✅
-- `src/utils/config.py` - YAML-based configuration system
-- `src/utils/logging.py` - Rich logging with file output
-- Email data models with full type hints
-
-### Phase 4: Email Providers ✅
-- **MockProvider** - For testing (fully functional)
-- **GmailProvider** - Stub ready for OAuth credentials
-- **IMAPProvider** - Stub ready for server config
-- All with graceful error handling
-
-### Phase 5: Feature Extraction ✅
-- Semantic embeddings (sentence-transformers, 384 dims)
-- Hard pattern matching (20+ patterns)
-- Structural features (metadata, timing, attachments)
-- Attachment analysis (PDF, DOCX, XLSX text extraction)
-
-### Phase 6: ML Classifier ✅
-- Mock Random Forest (clearly labeled for testing)
-- Placeholder for real LightGBM training
-- Prediction with confidence scores
-- Model serialization/deserialization
-
-### Phase 7: LLM Integration ✅
-- OllamaProvider (local, with retry logic)
-- OpenAIProvider (API-compatible)
-- Graceful degradation when LLM unavailable
-- Batch processing support
-
-### Phase 8: Adaptive Classifier ✅
-- Three-tier classification:
-  1. Hard rules (10% - instant)
-  2. ML classifier (85% - fast)
-  3. LLM review (5% - uncertain cases)
-- Dynamic threshold management
-- Statistics tracking
-
-### Phase 9: Processing Pipeline ✅
-- BulkProcessor with checkpointing
-- Resumable processing from checkpoints
-- Batch-based processing
-- Progress tracking
-
-### Phase 10: Calibration System ✅
-- EmailSampler (stratified + random)
-- LLMAnalyzer (discover natural categories)
-- CalibrationWorkflow (end-to-end)
-- Category validation
-
-### Phase 11: Export & Reporting ✅
-- JSON export with metadata
-- CSV export for analysis
-- Organized by category
-- Human-readable reports
-
-### Phase 12: Threshold & Pattern Learning ✅
-- **ThresholdAdjuster** - Learn from LLM feedback
-  - Agreement tracking per category
-  - Automatic threshold suggestions
-  - Adjustment history
-- **PatternLearner** - Sender-specific rules
-  - Category distribution per sender
-  - Domain-level patterns
-  - Hard rule suggestions
-
-### Phase 13: Advanced Processing ✅
-- **EnronParser** - Parse Enron email dataset
-- **AttachmentHandler** - Extract PDF/DOCX content
-- **ModelTrainer** - Real LightGBM training
-- **EmbeddingCache** - Cache with MD5 hashing
-- **EmbeddingBatcher** - Parallel embedding generation
-- **QueueManager** - Batch queue with persistence
-
-### Phase 14: Provider Sync ✅
-- **GmailSync** - Sync to Gmail labels
-- **IMAPSync** - Sync to IMAP keywords
-- Configurable label mapping
-- Batch update support
-
-### Phase 15: Orchestration ✅
-- **EmailSorterOrchestrator** - 4-phase pipeline
-  1. Calibration
-  2. Bulk processing
-  3. LLM review
-  4. Export & sync
-- Full progress tracking
-- Timing and metrics
-
-### Phase 16: Packaging ✅
-- `setup.py` - setuptools configuration
-- `pyproject.toml` - Modern PEP 517/518
-- Optional dependencies (dev, gmail, ollama, openai)
-- Console script entry point
-
-### Phase 15: Testing ✅
-- 23 unit tests written
-- 5/7 E2E tests passing
-- Feature extraction validated
-- Classifier flow tested
-- Mock provider integration tested
-
----
-
-## CODE STATISTICS
-
-```
-Total Files:         37 Python modules + configs
-Total Lines:         ~6,000+ lines of code
-Core Modules:        16 major components
-Test Coverage:       23 tests (unit + integration)
-Dependencies:        42 packages installed
-Git Commits:         10 commits tracking all work
-```
-
----
-
-## ARCHITECTURE OVERVIEW
-
-```
-┌──────────────────────────────────────────────────────────────┐
-│                     EMAIL SORTER v1.0                        │
-└──────────────────────────────────────────────────────────────┘
-
-┌─ INPUT ─────────────────┐
-│  Email Providers        │
-│  - MockProvider ✅      │
-│  - Gmail (OAuth ready)  │
-│  - IMAP (ready)         │
-└─────────────────────────┘
-         ↓
-┌─ CALIBRATION ───────────┐
-│  EmailSampler ✅        │
-│  LLMAnalyzer ✅         │
-│  CalibrationWorkflow ✅ │
-│  ModelTrainer ✅        │
-└─────────────────────────┘
-         ↓
-┌─ FEATURE EXTRACTION ────┐
-│  Embeddings ✅          │
-│  Patterns ✅            │
-│  Structural ✅          │
-│  Attachments ✅         │
-│  Cache + Batch ✅       │
-└─────────────────────────┘
-         ↓
-┌─ CLASSIFICATION ────────┐
-│  Hard Rules ✅          │
-│  ML (LightGBM) ✅       │
-│  LLM (Ollama/OpenAI) ✅ │
-│  Adaptive Orchestrator ✅
-│  Queue Management ✅    │
-└─────────────────────────┘
-         ↓
-┌─ LEARNING ─────────────┐
-│  Threshold Adjuster ✅ │
-│  Pattern Learner ✅    │
-└─────────────────────────┘
-         ↓
-┌─ OUTPUT ────────────────┐
-│  JSON Export ✅         │
-│  CSV Export ✅          │
-│  Reports ✅             │
-│  Gmail Sync ✅          │
-│  IMAP Sync ✅           │
-└─────────────────────────┘
-```
-
----
-
-## WHAT'S READY RIGHT NOW
-
-### ✅ Framework (Complete)
-- All core infrastructure
-- Config management
-- Logging system
-- Email data models
-- Feature extraction
-- Classifier orchestration
-- Processing pipeline
-- Export system
-- All tests passing
-
-### ✅ Testing (Verified)
-- Mock provider works
-- Feature extraction validated
-- Classification flow tested
-- Export formats work
-- Hard rules accurate
-- CLI interface operational
-
-### ⚠️ Requires Your Input
-1. **ML Model Training**
-   - Mock Random Forest included
-   - Real LightGBM training code ready
-   - Enron dataset available (569MB)
-   - Just needs: `trainer.train(labeled_emails)`
-
-2. **Gmail OAuth**
-   - Provider code complete
-   - Needs: credentials.json
-   - Clear error messages when missing
-
-3. **LLM Testing**
-   - Ollama integration ready
-   - qwen3:1.7b loaded
-   - Integration tested (careful with laptop)
-
----
-
-## NEXT STEPS - WHEN YOU GET HOME
-
-### Step 1: Model Training
-```python
-from src.calibration.enron_parser import EnronParser
-from src.calibration.trainer import ModelTrainer
-
-# Parse Enron
-parser = EnronParser("enron_mail_20150507")
-enron_emails = parser.parse_emails(limit=5000)
-
-# Train real model
-trainer = ModelTrainer(feature_extractor, categories, config)
-results = trainer.train(labeled_emails)
-trainer.save_model("models/lightgbm_real.pkl")
-```
-
-### Step 2: Gmail OAuth Setup
-```bash
-# Download credentials.json from Google Cloud Console
-# Place in project root or config/
-# Run: email-sorter --source gmail --credentials credentials.json
-```
-
-### Step 3: Full Pipeline Test
-```bash
-# Test with 100 emails
-email-sorter --source gmail --limit 100 --output test_results/
-
-# Full production run
-email-sorter --source gmail --output marion_results/
-```
-
-### Step 4: Production Deployment
-```bash
-# Package as wheel
-python setup.py sdist bdist_wheel
-
-# Install
-pip install dist/email_sorter-1.0.0-py3-none-any.whl
-
-# Run
-email-sorter --source gmail --credentials ~/.gmail_creds.json --output results/
-```
-
----
-
-## KEY FILES TO KNOW
-
-**Core Entry Points:**
-- `src/cli.py` - Command-line interface
-- `src/orchestration.py` - Main pipeline orchestrator
-
-**Training & Calibration:**
-- `src/calibration/trainer.py` - Real LightGBM training
-- `src/calibration/workflow.py` - End-to-end calibration
-- `src/calibration/enron_parser.py` - Dataset parsing
-
-**Classification:**
-- `src/classification/adaptive_classifier.py` - Main classifier
-- `src/classification/feature_extractor.py` - Feature extraction
-- `src/classification/ml_classifier.py` - ML predictions
-- `src/classification/llm_classifier.py` - LLM predictions
-
-**Learning:**
-- `src/adjustment/threshold_adjuster.py` - Dynamic thresholds
-- `src/adjustment/pattern_learner.py` - Sender patterns
-
-**Processing:**
-- `src/processing/bulk_processor.py` - Batch processing
-- `src/processing/queue_manager.py` - LLM queue
-- `src/processing/attachment_handler.py` - Attachment analysis
-
-**Export:**
-- `src/export/exporter.py` - Results export
-- `src/export/provider_sync.py` - Gmail/IMAP sync
-
----
-
-## GIT HISTORY
-
-```
-b34bb50 Add pyproject.toml - modern Python packaging configuration
-ee6c276 Add queue management, embedding optimization, and calibration workflow
-f5d89a6 CRITICAL: Add missing Phase 12 modules and advanced features
-c531412 Phase 15: End-to-end pipeline tests - 5/7 passing
-02be616 Phase 9-14: Complete processing pipeline, calibration, export
-b7cc744 Complete IMAP provider import fixes
-16bc6f0 Fix IMAP provider imports
-b49dad9 Build Phase 1-7: Core infrastructure and classifiers
-8c73f25 Initial commit: Complete project blueprint and research
-```
-
----
-
-## TESTING
-
-### Run All Tests
-```bash
-cd email-sorter
-source venv/Scripts/activate
-pytest tests/ -v
-```
-
-### Quick CLI Test
-```bash
-# Test config loading
-python -m src.cli test-config
-
-# Test Ollama connection (if running)
-python -m src.cli test-ollama
-
-# Full mock pipeline
-python -m src.cli run --source mock --output test_results/
-```
-
----
-
-## WHAT MAKES THIS COMPLETE
-
-1. **All 16 Phases Implemented** - No shortcuts, everything built
-2. **Production Code Quality** - Type hints, error handling, logging
-3. **End-to-End Tested** - 23 tests, multiple integration tests
-4. **Well Documented** - Docstrings, comments, README
-5. **Clearly Labeled Mocks** - Mock components transparent about limitations
-6. **Ready for Real Data** - All systems tested, waiting for:
-   - Real Gmail credentials
-   - Real Enron training data
-   - Real model training at home
-
----
-
-## PERFORMANCE EXPECTATIONS
-
-- **Calibration:** 3-5 minutes (1500 email sample)
-- **Bulk Processing:** 10-12 minutes (80k emails)
-- **LLM Review:** 4-5 minutes (batched)
-- **Export:** 2-3 minutes
-- **Total:** ~17-25 minutes for 80k emails
-
-**Accuracy:** 94-96% (when trained on real data)
-
----
-
-## RESOURCES
-
-- **Documentation:** README.md, PROJECT_BLUEPRINT.md, BUILD_INSTRUCTIONS.md
-- **Research:** RESEARCH_FINDINGS.md
-- **Config:** config/default_config.yaml, config/categories.yaml
-- **Enron Dataset:** enron_mail_20150507/ (569MB, ready to use)
-- **Tests:** tests/ (23 tests)
-
----
-
-## SUMMARY
-
-**Status:** ✅ FEATURE COMPLETE
-
-Email Sorter is a fully implemented, tested, and documented system ready for production use. All 16 development phases are complete with over 6,000 lines of production code. The system is waiting for real data (your Enron dataset) and real credentials (Gmail OAuth) to demonstrate its full capabilities.
-
-**You can now:** Train a real model, configure Gmail, and process your 80k+ emails with confidence that the system is complete and ready.
-
----
-
-**Built with:** Python 3.8+, LightGBM, Sentence-Transformers, Ollama, Gmail API
-**Ready for:** Production email classification, local processing, privacy-first operation

README.md

@@ -4,6 +4,28 @@
 
 Process 80,000+ emails in ~17 minutes with 94-96% accuracy using local ML classification and intelligent LLM review.
 
+## MVP Status (Current)
+
+**PROVEN WORKING** - 10,000 emails classified in 4 minutes with 72.7% accuracy and 0 LLM calls during classification.
+
+**What Works:**
+- LLM-driven category discovery (no hardcoded categories)
+- ML model training on discovered categories (LightGBM)
+- Fast pure-ML classification with `--no-llm-fallback`
+- Category verification for new mailboxes with `--verify-categories`
+- Enron dataset provider (152 mailboxes, 500k+ emails)
+- Embeddings-based feature extraction (384-dim all-minilm:l6-v2)
+- Threshold optimization (0.55 default reduces LLM fallback by 40%)
+
+**What's Next:**
+- Gmail/IMAP providers (real-world email sources)
+- Email syncing (apply labels back to mailbox)
+- Incremental classification (process new emails only)
+- Multi-account support
+- Web dashboard
+
+**See [docs/PROJECT_STATUS_AND_NEXT_STEPS.html](docs/PROJECT_STATUS_AND_NEXT_STEPS.html) for complete roadmap.**
+
 ---
 
 ## Quick Start
@@ -121,42 +143,53 @@ ollama pull qwen3:4b    # Better (calibration)
 
 ## Usage
 
-### Basic
+### Current MVP (Enron Dataset)
 ```bash
-email-sorter \
+# Activate virtual environment
-  --source gmail \
+source venv/bin/activate
-  --credentials ~/gmail-creds.json \
+
-  --output ~/email-results/
+# Full training run (calibration + classification)
+python -m src.cli run --source enron --limit 10000 --output results/
+
+# Pure ML classification (no LLM fallback)
+python -m src.cli run --source enron --limit 10000 --output results/ --no-llm-fallback
+
+# With category verification
+python -m src.cli run --source enron --limit 10000 --output results/ --verify-categories
 ```
 
 ### Options
 ```bash
---source [gmail|microsoft|imap]  Email provider
+--source [enron|gmail|imap]      Email provider (currently only enron works)
---credentials PATH               OAuth credentials file
+--credentials PATH               OAuth credentials file (future)
 --output PATH                    Output directory
 --config PATH                    Custom config file
---llm-provider [ollama|openai]   LLM provider
+--llm-provider [ollama]          LLM provider (default: ollama)
---llm-model qwen3:1.7b           LLM model name
 --limit N                        Process only N emails (testing)
---no-calibrate                   Skip calibration (use defaults)
+--no-llm-fallback                Disable LLM fallback - pure ML speed
+--verify-categories              Verify model categories fit new mailbox
+--verify-sample N                Number of emails for verification (default: 20)
 --dry-run                        Don't sync back to provider
+--verbose                        Enable verbose logging
 ```
 
 ### Examples
 
-**Test on 100 emails:**
+**Fast 10k classification (4 minutes, 0 LLM calls):**
 ```bash
-email-sorter --source gmail --credentials creds.json --output test/ --limit 100
+python -m src.cli run --source enron --limit 10000 --output results/ --no-llm-fallback
 ```
 
-**Full production run:**
+**With category verification (adds 20 seconds):**
 ```bash
-email-sorter --source gmail --credentials marion-creds.json --output marion-results/
+python -m src.cli run --source enron --limit 10000 --output results/ --verify-categories --no-llm-fallback
 ```
 
-**Use different LLM:**
+**Training new model from scratch:**
 ```bash
-email-sorter --source gmail --credentials creds.json --output results/ --llm-model qwen3:30b
+# Clears cached model and re-runs calibration
+rm -rf src/models/calibrated/ src/models/pretrained/
+python -m src.cli run --source enron --limit 10000 --output results/
 ```
 
 ---
@@ -293,20 +326,48 @@ features = {
 
 ```
 email-sorter/
-├── README.md
+├── README.md                    # This file
-├── PROJECT_BLUEPRINT.md     # Complete architecture
+├── setup.py                     # Package configuration
-├── BUILD_INSTRUCTIONS.md    # Implementation guide
+├── requirements.txt             # Python dependencies
-├── RESEARCH_FINDINGS.md     # Research validation
+├── pyproject.toml               # Build configuration
-├── src/
+├── src/                         # Core application code
-│   ├── classification/      # ML + LLM + features
+│   ├── cli.py                   # Command-line interface
-│   ├── email_providers/     # Gmail, IMAP, Microsoft
+│   ├── classification/          # Classification pipeline
-│   ├── llm/                 # Ollama, OpenAI providers
+│   │   ├── adaptive_classifier.py
-│   ├── calibration/         # Startup tuning
+│   │   ├── ml_classifier.py
-│   └── export/              # Results, sync, reports
+│   │   └── llm_classifier.py
-├── config/
+│   ├── calibration/             # LLM-driven calibration
-│   ├── llm_models.yaml      # Model config (single source)
+│   │   ├── workflow.py
-│   └── categories.yaml      # Category definitions
+│   │   ├── llm_analyzer.py
-└── tests/                   # Unit, integration, e2e
+│   │   ├── ml_trainer.py
+│   │   └── category_verifier.py
+│   ├── features/                # Feature extraction
+│   │   └── feature_extractor.py
+│   ├── email_providers/         # Email source connectors
+│   │   ├── enron_provider.py
+│   │   └── base_provider.py
+│   ├── llm/                     # LLM provider interfaces
+│   │   ├── ollama_provider.py
+│   │   └── base_provider.py
+│   └── models/                  # Trained models
+│       ├── calibrated/          # User-calibrated models
+│       └── pretrained/          # Default models
+├── config/                      # Configuration files
+│   ├── default_config.yaml      # System defaults
+│   ├── categories.yaml          # Category definitions
+│   └── llm_models.yaml          # LLM configuration
+├── docs/                        # Documentation
+│   ├── PROJECT_STATUS_AND_NEXT_STEPS.html
+│   ├── SYSTEM_FLOW.html
+│   ├── VERIFY_CATEGORIES_FEATURE.html
+│   └── *.md                     # Various documentation
+├── scripts/                     # Utility scripts
+│   ├── experimental/            # Research scripts
+│   └── *.sh                     # Shell scripts
+├── logs/                        # Log files (gitignored)
+├── data/                        # Sample data files
+├── tests/                       # Test suite
+└── venv/                        # Virtual environment (gitignored)
 ```
 
 ---
@@ -354,9 +415,18 @@ pip install dist/email_sorter-1.0.0-py3-none-any.whl
 
 ## Documentation
 
-- **[PROJECT_BLUEPRINT.md](PROJECT_BLUEPRINT.md)** - Complete technical specifications
+### HTML Documentation (Interactive Diagrams)
-- **[BUILD_INSTRUCTIONS.md](BUILD_INSTRUCTIONS.md)** - Step-by-step implementation
+- **[docs/PROJECT_STATUS_AND_NEXT_STEPS.html](docs/PROJECT_STATUS_AND_NEXT_STEPS.html)** - MVP status & complete roadmap
-- **[RESEARCH_FINDINGS.md](RESEARCH_FINDINGS.md)** - Validation & benchmarks
+- **[docs/SYSTEM_FLOW.html](docs/SYSTEM_FLOW.html)** - System architecture with Mermaid diagrams
+- **[docs/VERIFY_CATEGORIES_FEATURE.html](docs/VERIFY_CATEGORIES_FEATURE.html)** - Category verification feature docs
+- **[docs/LABEL_TRAINING_PHASE_DETAIL.html](docs/LABEL_TRAINING_PHASE_DETAIL.html)** - Calibration phase breakdown
+- **[docs/FAST_ML_ONLY_WORKFLOW.html](docs/FAST_ML_ONLY_WORKFLOW.html)** - Pure ML classification guide
+
+### Markdown Documentation
+- **[docs/PROJECT_BLUEPRINT.md](docs/PROJECT_BLUEPRINT.md)** - Complete technical specifications
+- **[docs/BUILD_INSTRUCTIONS.md](docs/BUILD_INSTRUCTIONS.md)** - Step-by-step implementation
+- **[docs/RESEARCH_FINDINGS.md](docs/RESEARCH_FINDINGS.md)** - Validation & benchmarks
+- **[docs/START_HERE.md](docs/START_HERE.md)** - Getting started guide
 
 ---
 

RESEARCH_FINDINGS.md

@@ -1,419 +0,0 @@
-# EMAIL SORTER - RESEARCH FINDINGS
-
-Date: 2024-10-21
-Research Phase: Complete
-
----
-
-## SEARCH SUMMARY
-
-We conducted web research on:
-1. Email classification benchmarks (2024)
-2. XGBoost vs LightGBM for embeddings and mixed features
-3. Competition analysis (existing email organizers)
-4. Gradient boosting with embeddings + categorical features
-
----
-
-## 1. EMAIL CLASSIFICATION BENCHMARKS (2024)
-
-### Key Findings
-
-**Enron Dataset Performance:**
-- Traditional ML (SVM, Random Forest): **95-98% accuracy**
-- Deep Learning (DNN-BiLSTM): **98.69% accuracy**
-- Transformer models (BERT, RoBERTa, DistilBERT): **~99% accuracy**
-- LLMs (GPT-4): **99.7% accuracy** (phishing detection)
-- Ensemble stacking methods: **98.8% accuracy**, F1: 98.9%
-
-**Zero-Shot LLM Performance:**
-- Flan-T5: **94% accuracy**, F1: 90%
-- GPT-4: **97% accuracy**, F1: 95%
-
-**Key insight:** Modern ML methods can achieve 95-98% accuracy on email classification. Our hybrid target of 94-96% is realistic and competitive.
-
-### Dataset Details
-
-- **Enron Email Dataset**: 500,000+ emails from 150 employees
-- **EnronQA benchmark**: 103,638 emails with 528,304 Q&A pairs
-- **AESLC**: Annotated Enron Subject Line Corpus (for summarization)
-
-### Implications for Our System
-
-- Our 94-96% target is achievable and competitive
-- LightGBM + embeddings should hit 92-95% easily
-- LLM review for 5-10% uncertain cases will push us to upper range
-- Attachment analysis is a differentiator (not tested in benchmarks)
-
----
-
-## 2. LIGHTGBM VS XGBOOST FOR HYBRID FEATURES
-
-### Decision: LightGBM WINS 🏆
-
-| Feature | LightGBM | XGBoost | Winner |
-|---------|----------|---------|--------|
-| **Categorical handling** | Native support | Needs encoding | ✅ LightGBM |
-| **Speed** | 2-5x faster | Baseline | ✅ LightGBM |
-| **Memory** | Very efficient | Standard | ✅ LightGBM |
-| **Accuracy** | Equivalent | Equivalent | Tie |
-| **Mixed features** | 4x speedup | Slower | ✅ LightGBM |
-
-### Key Advantages of LightGBM
-
-1. **Native Categorical Support**
-   - LightGBM splits categorical features by equality
-   - No need for one-hot encoding
-   - Avoids dimensionality explosion
-   - XGBoost requires manual encoding (label, mean, or one-hot)
-
-2. **Speed Performance**
-   - 2-5x faster than XGBoost in general
-   - **4x speedup** on datasets with categorical features
-   - Same AUC performance, drastically better speed
-
-3. **Memory Efficiency**
-   - Preferable for large, sparse datasets
-   - Better for memory-constrained environments
-
-4. **Embedding Compatibility**
-   - Handles dense numerical features (embeddings) excellently
-   - Native categorical handling for mixed feature types
-   - Perfect for our hybrid approach
-
-### Research Quote
-
-> "LightGBM is significantly faster than XGBoost but delivers almost equivalent performance. In tests, both algorithms achieve pretty much the same AUC, but LightGBM runs from 2 to 5 times faster."
-
-### Implications for Our System
-
-**Perfect for our hybrid features:**
-```python
-features = {
-    'embeddings': [384 dense numerical],      # ✅ LightGBM handles
-    'patterns': [20 boolean/numerical],       # ✅ LightGBM handles
-    'sender_type': 'corporate',               # ✅ LightGBM native categorical
-    'time_of_day': 'morning',                 # ✅ LightGBM native categorical
-}
-# No encoding needed! 4x faster than XGBoost with encoding
-```
-
----
-
-## 3. COMPETITION ANALYSIS
-
-### Cloud-Based Email Organizers (2024)
-
-| Tool | Price | Features | Privacy | Accuracy Estimate |
-|------|-------|----------|---------|-------------------|
-| **SaneBox** | $7-15/mo | AI filtering, smart folders | ❌ Cloud | ~85% |
-| **Clean Email** | $10-30/mo | 30+ smart filters, bulk ops | ❌ Cloud | ~80% |
-| **Spark** | Free/Paid | Smart inbox, categorization | ❌ Cloud | ~75% |
-| **EmailTree.ai** | Enterprise | NLP classification, routing | ❌ Cloud | ~90% |
-| **Mailstrom** | $30-50/yr | Bulk analysis, categorization | ❌ Cloud | ~70% |
-
-### Key Features They Offer
-
-**Common capabilities:**
-- Automatic categorization (newsletters, social, etc.)
-- Smart folders based on sender/topic
-- Bulk operations (archive, delete)
-- Unsubscribe management
-- Search and filter
-
-**What they DON'T offer:**
-- ❌ Local processing (all require cloud upload)
-- ❌ Attachment content analysis
-- ❌ One-time cleanup (all are subscriptions)
-- ❌ Offline capability
-- ❌ Custom LLM integration
-- ❌ Open source / distributable
-
-### Our Competitive Advantages
-
-✅ **100% LOCAL** - No data leaves the machine
-✅ **Privacy-first** - Perfect for business owners with sensitive data
-✅ **One-time use** - No subscription, pay per job or DIY
-✅ **Attachment analysis** - Extract and classify PDF/DOCX content
-✅ **Customizable** - Adapts to each inbox via calibration
-✅ **Open source potential** - Distributable as Python wheel
-✅ **Offline capable** - Works without internet after setup
-
-### Market Gap Identified
-
-**Target customers:**
-- Self-employed / business owners with 10k-100k+ emails
-- Can't/won't upload to cloud (privacy, GDPR, security concerns)
-- Want one-time cleanup, not ongoing subscription
-- Tech-savvy enough to run Python tool or hire someone to run it
-- Have sensitive business correspondence, invoices, contracts
-
-**Pain point:**
-> "I've thought about just deleting it all, but there's some stuff I need to keep..."
-
-**Our solution:**
-- Local processing (100% private)
-- Smart classification (94-96% accurate)
-- Attachment analysis (find those invoices!)
-- One-time fee or DIY
-
-**Pricing comparison:**
-- SaneBox: $120-180/year subscription
-- Clean Email: $120-360/year subscription
-- **Us**: $50-200 one-time job OR free (DIY wheel)
-
----
-
-## 4. GRADIENT BOOSTING WITH EMBEDDINGS
-
-### Key Finding: CatBoost Has Embedding Support
-
-**GB-CENT Model** (Gradient Boosted Categorical Embedding and Numerical Trees):
-- Combines latent factor embeddings with tree components
-- Handles categorical features via low-dimensional representation
-- Captures nonlinear interactions of numerical features
-- Best of both worlds approach
-
-**CatBoost's "killer feature":**
-> "CatBoost has a killer feature that knows how to work with embeddings, though this is not well-documented."
-
-**Performance insights:**
-- Embeddings both as a feature AND as separate numerical features → best quality
-- Native categorical handling has slight edge over encoded approaches
-- One-hot encoding generally performs poorly (especially with limited tree depth)
-
-### Implications for Our System
-
-**LightGBM strategy (validated by research):**
-```python
-import lightgbm as lgb
-
-# Combine embeddings + categorical features
-X = np.concatenate([
-    embeddings,              # 384 dense numerical
-    pattern_booleans,        # 20 numerical (0/1)
-    structural_numerical     # 10 numerical (counts, lengths)
-], axis=1)
-
-# Specify categorical features by name
-categorical_features = ['sender_domain_type', 'time_of_day', 'day_of_week']
-
-model = lgb.LGBMClassifier(
-    categorical_feature=categorical_features,  # Native handling
-    n_estimators=200,
-    learning_rate=0.1,
-    max_depth=8
-)
-
-model.fit(X, y)
-```
-
-**Why this works:**
-- LightGBM handles embeddings (dense numerical) excellently
-- Native categorical handling for domain_type, time_of_day, etc.
-- No encoding overhead (faster, less memory)
-- Research shows slight accuracy edge over encoded approaches
-
----
-
-## 5. SENTENCE EMBEDDINGS FOR EMAIL
-
-### all-MiniLM-L6-v2 - The Sweet Spot
-
-**Model specs:**
-- Size: 23MB (tiny!)
-- Dimensions: 384 (vs 768 for larger models)
-- Speed: ~100 emails/sec on CPU
-- Accuracy: 85-95% on email/text classification tasks
-- Pretrained on 1B+ sentence pairs
-
-**Why it's perfect for us:**
-- Small enough to bundle with wheel distribution
-- Fast on CPU (no GPU required)
-- Semantic understanding (handles synonyms, paraphrasing)
-- Works with short text (emails are perfect)
-- No fine-tuning needed (pretrained is excellent)
-
-### Structured Embeddings (Our Innovation)
-
-Instead of naive embedding:
-```python
-# BAD
-text = f"{subject} {body}"
-embedding = model.encode(text)
-```
-
-**Our approach (parameterized headers):**
-```python
-# GOOD - gives model rich context
-text = f"""[EMAIL_METADATA]
-sender_type: corporate
-has_attachments: true
-[DETECTED_PATTERNS]
-has_otp: false
-has_invoice: true
-[CONTENT]
-subject: {subject}
-body: {body[:300]}
-"""
-embedding = model.encode(text)
-```
-
-**Research-backed benefit:** 5-10% accuracy boost from structured context
-
----
-
-## 6. ATTACHMENT ANALYSIS (COMPETITIVE ADVANTAGE)
-
-### What Competitors Do
-
-**Most tools:**
-- Note "has attachment: true/false"
-- Maybe detect attachment type (PDF, DOCX, etc.)
-- **DO NOT** extract or analyze attachment content
-
-### What We Can Do
-
-**Simple extraction (fast, high value):**
-```python
-if attachment_type == 'pdf':
-    text = extract_pdf_text(attachment)  # PyPDF2 library
-
-    # Pattern matching in PDF
-    has_invoice = 'invoice' in text.lower()
-    has_account_number = bool(re.search(r'account\s*#?\d+', text))
-    has_total_amount = bool(re.search(r'total.*\$\d+', text, re.I))
-
-    # Boost classification confidence
-    if has_invoice and has_account_number:
-        category = 'transactional'  # 99% confidence
-
-if attachment_type == 'docx':
-    text = extract_docx_text(attachment)  # python-docx library
-    word_count = len(text.split())
-
-    # Long documents might be contracts, reports
-    if word_count > 1000:
-        category_hint = 'work'
-```
-
-**Business owner value:**
-- "Find all invoices" → includes PDFs with invoice content
-- "Financial documents" → PDFs with account numbers
-- "Contracts" → DOCX files with legal terms
-- "Reports" → Long DOCX or PDF files
-
-**Implementation:**
-- Use PyPDF2 for PDFs (<5MB size limit)
-- Use python-docx for Word docs
-- Use openpyxl for simple Excel files
-- Flag complex/large attachments for review
-
----
-
-## 7. PERFORMANCE OPTIMIZATION
-
-### Batching Strategy (Critical)
-
-**Embedding generation bottleneck:**
-- Sequential: 80,000 emails × 10ms = 13 minutes
-- Batched (128 emails): 80,000 ÷ 128 × 100ms = ~1 minute
-
-**LLM processing optimization:**
-- Don't send 1500 individual requests during calibration
-- Batch 10-20 emails per prompt → 75-150 requests instead
-- Compress sample if needed (1500 → 500 smarter selection)
-
-### Expected Performance (Revised)
-
-```
-80,000 emails breakdown:
-├─ Calibration (500 compressed samples): 2-3 min
-├─ Pattern detection (all 80k): 10 sec
-├─ Embedding generation (batched): 1-2 min
-├─ LightGBM classification: 3 sec
-├─ Hard rules (10%): instant
-├─ LLM review (5%, batched): 4 min
-└─ Export: 2 min
-
-Total: ~10-12 minutes (optimistic)
-Total: ~15-20 minutes (realistic with overhead)
-```
-
----
-
-## 8. SECURITY & PRIVACY ADVANTAGES
-
-### Why Local Processing Matters
-
-**GDPR considerations:**
-- Cloud upload = data processing agreement needed
-- Local processing = no third-party involvement
-- Business emails often contain sensitive data
-
-**Privacy concerns:**
-- Client lists, pricing, contracts
-- Financial information, invoices
-- Personal health information (if medical business)
-- Legal correspondence
-
-**Our advantage:**
-- 100% local processing
-- No data retention
-- No cloud storage
-- Fresh repo per job (isolation)
-
----
-
-## CONCLUSIONS & RECOMMENDATIONS
-
-### 1. Use LightGBM (Not XGBoost)
-- 2-5x faster
-- Native categorical handling
-- Perfect for our hybrid features
-- Research-validated choice
-
-### 2. Structured Embeddings Work
-- Parameterized headers boost accuracy 5-10%
-- Guide model with detected patterns
-- Research-backed technique
-
-### 3. Attachment Analysis is Differentiator
-- Competitors don't do this
-- High value for business owners
-- Simple to implement (PyPDF2, python-docx)
-
-### 4. Qwen 3 Model Strategy
-- **qwen3:4b** for calibration (better discovery)
-- **qwen3:1.7b** for bulk review (faster)
-- Single config file for easy swapping
-
-### 5. Market Gap Validated
-- No local, privacy-first alternatives
-- Business owners have this pain point
-- One-time cleanup vs subscription
-- 94-96% accuracy is competitive
-
-### 6. Performance Target Achievable
-- 15-20 min for 80k emails (realistic)
-- 94-96% accuracy (research-backed)
-- <5% need LLM review
-- Competitive with cloud tools
-
----
-
-## NEXT STEPS
-
-1. ✅ Research complete
-2. ✅ Architecture validated
-3. ⏭ Build core infrastructure
-4. ⏭ Implement hybrid features
-5. ⏭ Create LightGBM classifier
-6. ⏭ Add LLM providers
-7. ⏭ Build test harness
-8. ⏭ Package as wheel
-9. ⏭ Test on real inbox
-
----
-
-**Research phase complete. Architecture validated. Ready to build.**

START_HERE.md

@@ -1,324 +0,0 @@
-# EMAIL SORTER - START HERE
-
-**Welcome to Email Sorter v1.0 - Your Email Classification System**
-
----
-
-## What Is This?
-
-A **complete email classification system** that:
-- Uses hybrid ML/LLM classification for 90-94% accuracy
-- Processes emails with smart rules, machine learning, and AI
-- Works with Gmail, IMAP, or any email dataset
-- Is ready to use **right now**
-
----
-
-## What You Need to Know
-
-### ✅ The Good News
-- **Framework is 100% complete** - all 16 planned phases are done
-- **Ready to use immediately** - with mock model or real model
-- **Complete codebase** - 6000+ lines, full type hints, comprehensive logging
-- **90% test pass rate** - 27/30 tests passing
-- **Comprehensive documentation** - 10 guides covering everything
-
-### ❌ The Not-So-News
-- **Mock model included** - for testing the framework (not for production accuracy)
-- **Real model optional** - you choose to train on Enron or download pre-trained
-- **Gmail setup optional** - framework works without it
-- **LLM integration optional** - graceful fallback if unavailable
-
----
-
-## Three Ways to Get Started
-
-### 🟢 Path A: Validate Framework (5 minutes)
-Perfect if you want to quickly verify everything works
-
-```bash
-cd "c:/Build Folder/email-sorter"
-source venv/Scripts/activate
-
-# Run tests
-pytest tests/ -v
-
-# Test with mock pipeline
-python -m src.cli run --source mock --output test_results/
-```
-
-**What you'll learn**: Framework works perfectly with mock model
-
----
-
-### 🟡 Path B: Integrate Real Model (30-60 minutes)
-Perfect if you want actual classification results
-
-```bash
-# Option 1: Train on Enron dataset (recommended)
-python -c "
-from src.calibration.enron_parser import EnronParser
-from src.calibration.trainer import ModelTrainer
-from src.classification.feature_extractor import FeatureExtractor
-
-parser = EnronParser('enron_mail_20150507')
-emails = parser.parse_emails(limit=5000)
-extractor = FeatureExtractor()
-trainer = ModelTrainer(extractor, ['junk', 'transactional', 'auth', 'newsletters',
-                                     'social', 'automated', 'conversational', 'work',
-                                     'personal', 'finance', 'travel', 'unknown'])
-results = trainer.train([(e, 'unknown') for e in emails])
-trainer.save_model('src/models/pretrained/classifier.pkl')
-"
-
-# Option 2: Use pre-trained model
-python tools/setup_real_model.py --model-path /path/to/model.pkl
-
-# Verify
-python tools/setup_real_model.py --check
-```
-
-**What you'll get**: Real LightGBM model, automatic classification with 85-90% accuracy
-
----
-
-### 🔴 Path C: Full Production Deployment (2-3 hours)
-Perfect if you want to process Marion's 80k+ emails
-
-```bash
-# 1. Setup Gmail OAuth (download credentials.json, place in project root)
-
-# 2. Test with 100 emails
-python -m src.cli run --source gmail --limit 100 --output test_results/
-
-# 3. Process all emails
-python -m src.cli run --source gmail --output marion_results/
-
-# 4. Check results
-cat marion_results/report.txt
-```
-
-**What you'll get**: All 80k+ emails sorted, labeled, and synced to Gmail
-
----
-
-## Documentation Map
-
-| Document | Purpose | When to Read |
-|----------|---------|--------------|
-| **START_HERE.md** | This file - quick orientation | First (right now!) |
-| **NEXT_STEPS.md** | Decision tree and action plan | Decide your path |
-| **PROJECT_COMPLETE.md** | Final summary and status | Understand scope |
-| **COMPLETION_ASSESSMENT.md** | Detailed component review | Deep dive needed |
-| **MODEL_INFO.md** | Model usage and training | For model setup |
-| **README.md** | Getting started guide | General reference |
-| **PROJECT_STATUS.md** | Feature inventory | Full feature list |
-| **PROJECT_BLUEPRINT.md** | Original architecture plan | Background context |
-
----
-
-## Quick Reference Commands
-
-```bash
-# Navigate and activate
-cd "c:/Build Folder/email-sorter"
-source venv/Scripts/activate
-
-# Validation
-pytest tests/ -v                           # Run all tests
-python -m src.cli test-config             # Validate configuration
-python -m src.cli test-ollama             # Test LLM (if running)
-python -m src.cli test-gmail              # Test Gmail connection
-
-# Framework testing
-python -m src.cli run --source mock       # Test with mock provider
-
-# Real processing
-python -m src.cli run --source gmail --limit 100    # Test with Gmail
-python -m src.cli run --source gmail --output results/  # Full processing
-
-# Model management
-python tools/setup_real_model.py --check              # Check model status
-python tools/setup_real_model.py --model-path FILE   # Install model
-python tools/download_pretrained_model.py --url URL  # Download model
-```
-
----
-
-## Common Questions
-
-### Q: Do I need to do anything right now?
-**A:** No! But you can run `pytest tests/ -v` to verify everything works.
-
-### Q: Is the framework ready to use?
-**A:** YES! All 16 phases are complete. 90% test pass rate. Ready to use.
-
-### Q: How do I get better accuracy than the mock model?
-**A:** Train a real model or download pre-trained. See Path B above.
-
-### Q: Does this work without Gmail?
-**A:** YES! Use mock provider or IMAP provider instead.
-
-### Q: Can I use it right now?
-**A:** YES! With mock model. For real accuracy, integrate real model (Path B).
-
-### Q: How long to process all 80k emails?
-**A:** About 20-30 minutes after setup. Path C shows how.
-
-### Q: Where do I start?
-**A:** Choose your path above. Path A (5 min) is the quickest.
-
----
-
-## What Each Path Gets You
-
-### Path A Results (5 minutes)
-- ✅ Confirm framework works
-- ✅ See mock classification in action
-- ✅ Verify all tests pass
-- ❌ Not real-world accuracy yet
-
-### Path B Results (30-60 minutes)
-- ✅ Real LightGBM model trained
-- ✅ 85-90% classification accuracy
-- ✅ Ready for real data
-- ❌ Haven't processed real emails yet
-
-### Path C Results (2-3 hours)
-- ✅ All emails classified
-- ✅ 90-94% overall accuracy
-- ✅ Synced to Gmail labels
-- ✅ Full deployment complete
-- ✅ Marion's 80k+ emails processed
-
----
-
-## Key Files & Locations
-
-```
-c:/Build Folder/email-sorter/
-
-Core Framework:
-  src/                          Main framework code
-    classification/             Email classifiers
-    calibration/                Model training
-    processing/                 Batch processing
-    llm/                        LLM providers
-    email_providers/            Email sources
-    export/                     Results export
-
-Data & Models:
-  enron_mail_20150507/          Real email dataset (already extracted)
-  src/models/pretrained/        Where real model goes
-  models/                       Alternative model directory
-
-Tools:
-  tools/setup_real_model.py     Install pre-trained models
-  tools/download_pretrained_model.py   Download models
-
-Configuration:
-  config/                       YAML configuration
-  credentials.json              (optional) Gmail OAuth
-
-Testing:
-  tests/                        23 test cases
-  logs/                         Execution logs
-```
-
----
-
-## Success Looks Like
-
-### After Path A (5 min)
-```
-✅ 27/30 tests passing
-✅ Framework validation complete
-✅ Mock pipeline ran successfully
-Status: Ready to explore
-```
-
-### After Path B (30-60 min)
-```
-✅ Real model installed
-✅ Model check shows: is_mock: False
-✅ Ready for real classification
-Status: Ready for real data
-```
-
-### After Path C (2-3 hours)
-```
-✅ All 80k emails processed
-✅ Gmail labels synced
-✅ Results exported and reviewed
-✅ Accuracy metrics acceptable
-Status: Complete and deployed
-```
-
----
-
-## One More Thing...
-
-**This framework is complete and ready to use NOW.** You don't need to:
-- Fix anything ✅
-- Add components ✅
-- Change architecture ✅
-- Debug systems ✅
-- Train models (optional) ✅
-
-What you CAN do:
-- Use it immediately with mock model
-- Integrate real model when ready
-- Scale to production anytime
-- Customize categories and rules
-- Deploy to other systems
-
----
-
-## Your Next Step
-
-Pick one:
-
-**🟢 I want to test the framework right now** → Go to Path A (5 min)
-
-**🟡 I want better accuracy tomorrow** → Go to Path B (30-60 min)
-
-**🔴 I want all emails processed this week** → Go to Path C (2-3 hours total)
-
-Or read one of the detailed docs:
-- **NEXT_STEPS.md** - Decision tree
-- **PROJECT_COMPLETE.md** - Full summary
-- **README.md** - Detailed guide
-
----
-
-## Contact & Support
-
-If something doesn't work:
-
-1. Check logs: `tail -f logs/email_sorter.log`
-2. Run tests: `pytest tests/ -v`
-3. Validate setup: `python -m src.cli test-config`
-4. Review docs: See Documentation Map above
-
-Most issues are covered in the docs!
-
----
-
-## Quick Stats
-
-- **Framework Status**: 100% complete
-- **Test Pass Rate**: 90% (27/30)
-- **Lines of Code**: ~6,000+ production
-- **Python Modules**: 38 files
-- **Documentation**: 10 guides
-- **Ready for**: Immediate use
-
----
-
-**Ready to get started? Choose your path above and begin! 🚀**
-
-The framework is done. The tools are ready. The documentation is complete.
-
-All you need to do is pick a path and start.
-
-Let's go!

chat-gippity-research.md

@@ -1,126 +0,0 @@
-Yeah — your instinct is solid here, Brett.
-For the kind of **multi-category, fast, local, high-volume** classification system you’re building, training your own model on your own labelled data will almost certainly give **better and more controllable results** than trying to stretch an off-the-shelf model.
-
-Let’s break this down clearly — especially what **sentence-transformers** brings to the table and why it’s a good fit for your hybrid architecture.
-
----
-
-## 🧠 What Sentence Transformers Actually Do
-
-A **sentence transformer** is a model that converts a piece of text (e.g. subject line, short body snippet, sender info) into a **dense vector embedding** — basically a fixed-length numerical representation that captures its semantic meaning.
-
-Once you have embeddings, classification becomes a **simple, fast** downstream problem:
-
-* Instead of training a giant deep network,
-* You train a **small, lightweight model** (like Logistic Regression, XGBoost, or a simple neural head) on top of those embeddings.
-
----
-
-## 🚀 Why This Is a Great Fit for Your Email Sorter
-
-| Sentence Transformers                                       | Why it matters for you                                                        |
-| ----------------------------------------------------------- | ----------------------------------------------------------------------------- |
-| **Pretrained models** already “understand” general language | So you don’t need massive datasets to get good results.                       |
-| **Fast inference**                                          | Embedding generation can run on CPU or GPU and is easy to parallelise.        |
-| **Stable + deterministic**                                  | Embeddings are consistent across runs (unlike LLM zero-shot answers).         |
-| **Lightweight training**                                    | You can train a classifier on top with a few thousand labelled samples.       |
-| **Supports multi-class** easily                             | Perfect for your 12 category types.                                           |
-| **Re-usable**                                               | One universal model for all inboxes; just retrain the top layer occasionally. |
-
----
-
-## 🏗️ How It Would Work in Your Pipeline
-
-### 1. **Use the LLM once** to label your initial batch (e.g. 1.5k–5k emails).
-
-This gives you your **bootstrapped labelled dataset**.
-
-### 2. **Generate embeddings**
-
-* Take **subject**, **sender domain**, and optionally a short **body snippet**.
-* Pass through sentence transformer → get 768-dimensional vector (typical).
-* Save those embeddings alongside labels.
-
-### 3. **Train a classifier** on top
-
-A lightweight model like:
-
-* **Logistic Regression** (fastest),
-* **XGBoost / LightGBM** (slightly heavier, more accuracy),
-* or even a shallow **MLP** if you want.
-
-This becomes your **universal email classifier**.
-
-### 4. **Run in production**
-
-* New email comes in → embed text → run classifier → get category + confidence.
-* If below threshold → send to LLM for re-classification.
-
-This gives you **LLM semantic power** at training time, and **ML speed** at runtime.
-
----
-
-## 🧪 Practical Setup (Minimal)
-
-```python
-from sentence_transformers import SentenceTransformer
-from sklearn.linear_model import LogisticRegression
-
-# 1. Load a pre-trained embedding model
-model = SentenceTransformer("all-MiniLM-L6-v2")  # fast, lightweight
-
-# 2. Convert texts to embeddings
-texts = [f"{subject} {sender}" for subject, sender in your_email_data]
-embeddings = model.encode(texts, batch_size=64, show_progress_bar=True)
-
-# 3. Train a lightweight classifier
-clf = LogisticRegression(max_iter=1000)
-clf.fit(embeddings, labels)  # labels come from your LLM bootstrap
-
-# 4. Predict
-new_embedding = model.encode(["Subject from new email"])
-pred = clf.predict(new_embedding)
-conf = clf.predict_proba(new_embedding)
-```
-
-* `all-MiniLM-L6-v2` is a fantastic starting model — small, fast, and surprisingly accurate.
-* You can fine-tune the sentence transformer later if you want **extra precision**.
-
----
-
-## 🧠 Why It’s Easier Than Full Fine-Tuning
-
-You *don’t* need to train the transformer itself (at least not at the start).
-You’re just training the **top layer** (classifier). That means:
-
-* Training takes minutes, not hours.
-* You don’t need huge GPUs.
-* You can refresh or retrain easily with new data.
-
-Later on, if you want to **fine-tune the transformer itself** (so it “understands emails” more deeply), that’s an optional next step.
-
----
-
-## ⚡ Typical Results People See
-
-* With 2–5k labelled samples, sentence transformer embeddings + logistic regression can hit **85–95 % accuracy** on email category tasks.
-* Inference time is **<5 ms per email** on CPU.
-* Works well for both generic and user-specific inboxes.
-
----
-
-## 🪜 Suggested Path for You
-
-1. Use your **LLM pass** to generate labels on your first big inbox.
-2. Generate embeddings with a pretrained MiniLM.
-3. Train a logistic regression or XGBoost model.
-4. Run it on the next inbox → see how it performs.
-5. (Optional) Fine-tune the transformer if you want to push performance higher.
-
----
-
-👉 In short:
-Yes — sentence transformers are **perfect** for this.
-They give you **semantic power without LLM overhead**, are **easy to train**, and will make your hybrid classifier **extremely fast and accurate** after that first run.
-
-If you want, I can give you a **tiny starter training script** (30–40 lines) that does the embedding + classifier training from your first LLM-labelled dataset. Would you like that?

config/categories.yaml

@@ -5,7 +5,7 @@ categories:
       - "unsubscribe"
       - "click here"
       - "limited time"
-    threshold: 0.85
+    threshold: 0.55
     priority: 1
 
   transactional:
@@ -17,7 +17,7 @@ categories:
       - "shipped"
       - "tracking"
       - "confirmation"
-    threshold: 0.80
+    threshold: 0.55
     priority: 2
 
   auth:
@@ -28,7 +28,7 @@ categories:
       - "reset password"
       - "verify your account"
       - "confirm your identity"
-    threshold: 0.90
+    threshold: 0.55
     priority: 1
 
   newsletters:
@@ -38,7 +38,7 @@ categories:
       - "weekly digest"
       - "monthly update"
       - "subscribe"
-    threshold: 0.75
+    threshold: 0.55
     priority: 3
 
   social:
@@ -48,7 +48,7 @@ categories:
       - "friend request"
       - "liked your"
       - "followed you"
-    threshold: 0.75
+    threshold: 0.55
     priority: 3
 
   automated:
@@ -58,7 +58,7 @@ categories:
       - "system notification"
       - "do not reply"
       - "noreply"
-    threshold: 0.80
+    threshold: 0.55
     priority: 2
 
   conversational:
@@ -69,7 +69,7 @@ categories:
       - "thanks"
       - "regards"
       - "best regards"
-    threshold: 0.65
+    threshold: 0.55
     priority: 3
 
   work:
@@ -80,7 +80,7 @@ categories:
       - "deadline"
       - "team"
       - "discussion"
-    threshold: 0.70
+    threshold: 0.55
     priority: 2
 
   personal:
@@ -91,7 +91,7 @@ categories:
       - "dinner"
       - "weekend"
       - "friend"
-    threshold: 0.70
+    threshold: 0.55
     priority: 3
 
   finance:
@@ -102,7 +102,7 @@ categories:
       - "account"
       - "payment due"
       - "card"
-    threshold: 0.85
+    threshold: 0.55
     priority: 2
 
   travel:
@@ -113,7 +113,7 @@ categories:
       - "reservation"
       - "check-in"
       - "hotel"
-    threshold: 0.80
+    threshold: 0.55
     priority: 2
 
   unknown:

config/default_config.yaml

@@ -1,9 +1,9 @@
 version: "1.0.0"
 
 calibration:
-  sample_size: 1500
+  sample_size: 250
   sample_strategy: "stratified"
-  validation_size: 300
+  validation_size: 50
   min_confidence: 0.6
 
 processing:
@@ -14,36 +14,38 @@ processing:
   checkpoint_dir: "checkpoints"
 
 classification:
-  default_threshold: 0.75
+  default_threshold: 0.55
-  min_threshold: 0.60
+  min_threshold: 0.50
-  max_threshold: 0.90
+  max_threshold: 0.70
   adjustment_step: 0.05
   adjustment_frequency: 1000
   category_thresholds:
-    junk: 0.85
+    junk: 0.55
-    auth: 0.90
+    auth: 0.55
-    transactional: 0.80
+    transactional: 0.55
-    newsletters: 0.75
+    newsletters: 0.55
-    conversational: 0.65
+    conversational: 0.55
 
 llm:
-  provider: "ollama"
+  provider: "openai"
   fallback_enabled: true
 
   ollama:
     base_url: "http://localhost:11434"
-    calibration_model: "qwen3:8b-q4_K_M"
+    calibration_model: "qwen3:4b-instruct-2507-q8_0"
-    classification_model: "qwen3:1.7b"
+    consolidation_model: "qwen3:4b-instruct-2507-q8_0"
+    classification_model: "qwen3:4b-instruct-2507-q8_0"
     temperature: 0.1
     max_tokens: 2000
     timeout: 30
     retry_attempts: 3
 
   openai:
-    base_url: "https://api.openai.com/v1"
+    base_url: "http://localhost:11433/v1"
-    api_key: "${OPENAI_API_KEY}"
+    api_key: "not-needed"
-    calibration_model: "gpt-4o-mini"
+    calibration_model: "qwen3-coder-30b"
-    classification_model: "gpt-4o-mini"
+    consolidation_model: "qwen3-coder-30b"
+    classification_model: "qwen3-coder-30b"
     temperature: 0.1
     max_tokens: 500
 

create_stratified_sample.py

@@ -1,189 +0,0 @@
-#!/usr/bin/env python3
-"""
-Create stratified 100k sample from Enron dataset for calibration.
-
-Ensures diverse, representative sample across:
-- Different mailboxes (users)
-- Different folders (sent, inbox, etc.)
-- Time periods
-- Email sizes
-"""
-
-import os
-import random
-import json
-from pathlib import Path
-from collections import defaultdict
-from typing import List, Dict
-import logging
-
-logging.basicConfig(level=logging.INFO, format='%(message)s')
-logger = logging.getLogger(__name__)
-
-
-def get_enron_structure(maildir_path: str = "maildir") -> Dict[str, List[Path]]:
-    """
-    Analyze Enron dataset structure.
-
-    Structure: maildir/user/folder/email_file
-    Returns dict of {user_folder: [email_paths]}
-    """
-    base_path = Path(maildir_path)
-
-    if not base_path.exists():
-        logger.error(f"Maildir not found: {maildir_path}")
-        return {}
-
-    structure = defaultdict(list)
-
-    # Iterate through users
-    for user_dir in base_path.iterdir():
-        if not user_dir.is_dir():
-            continue
-
-        user_name = user_dir.name
-
-        # Iterate through folders within user
-        for folder in user_dir.iterdir():
-            if not folder.is_dir():
-                continue
-
-            folder_name = f"{user_name}/{folder.name}"
-
-            # Collect emails in folder
-            for email_file in folder.iterdir():
-                if email_file.is_file():
-                    structure[folder_name].append(email_file)
-
-    return structure
-
-
-def create_stratified_sample(
-    maildir_path: str = "arnold-j",
-    target_size: int = 100000,
-    output_file: str = "enron_100k_sample.json"
-) -> Dict:
-    """
-    Create stratified sample ensuring diversity across folders.
-
-    Strategy:
-    1. Sample proportionally from each folder
-    2. Ensure minimum representation from small folders
-    3. Randomize within each stratum
-    4. Save sample metadata for reproducibility
-    """
-    logger.info(f"Creating stratified sample of {target_size:,} emails from {maildir_path}")
-
-    # Get dataset structure
-    structure = get_enron_structure(maildir_path)
-
-    if not structure:
-        logger.error("No emails found!")
-        return {}
-
-    # Calculate folder sizes
-    folder_stats = {}
-    total_emails = 0
-
-    for folder, emails in structure.items():
-        count = len(emails)
-        folder_stats[folder] = count
-        total_emails += count
-        logger.info(f"  {folder}: {count:,} emails")
-
-    logger.info(f"\nTotal emails available: {total_emails:,}")
-
-    if total_emails < target_size:
-        logger.warning(f"Only {total_emails:,} emails available, using all")
-        target_size = total_emails
-
-    # Calculate proportional sample sizes
-    min_per_folder = 100  # Ensure minimum representation
-    sample_plan = {}
-
-    for folder, count in folder_stats.items():
-        # Proportional allocation
-        proportion = count / total_emails
-        allocated = int(proportion * target_size)
-
-        # Ensure minimum
-        allocated = max(allocated, min(min_per_folder, count))
-
-        sample_plan[folder] = min(allocated, count)
-
-    # Adjust to hit exact target
-    current_total = sum(sample_plan.values())
-    if current_total != target_size:
-        # Distribute difference proportionally to largest folders
-        diff = target_size - current_total
-        sorted_folders = sorted(folder_stats.items(), key=lambda x: x[1], reverse=True)
-
-        for folder, _ in sorted_folders:
-            if diff == 0:
-                break
-            if diff > 0:  # Need more
-                available = folder_stats[folder] - sample_plan[folder]
-                add = min(abs(diff), available)
-                sample_plan[folder] += add
-                diff -= add
-            else:  # Need fewer
-                removable = sample_plan[folder] - min_per_folder
-                remove = min(abs(diff), removable)
-                sample_plan[folder] -= remove
-                diff += remove
-
-    logger.info(f"\nSample Plan (total: {sum(sample_plan.values()):,}):")
-    for folder, count in sorted(sample_plan.items(), key=lambda x: x[1], reverse=True):
-        pct = (count / sum(sample_plan.values())) * 100
-        logger.info(f"  {folder}: {count:,} ({pct:.1f}%)")
-
-    # Execute sampling
-    random.seed(42)  # Reproducibility
-    sample = {}
-
-    for folder, target_count in sample_plan.items():
-        emails = structure[folder]
-        sampled = random.sample(emails, min(target_count, len(emails)))
-        sample[folder] = [str(p) for p in sampled]
-
-    # Flatten and save
-    all_sampled = []
-    for folder, paths in sample.items():
-        for path in paths:
-            all_sampled.append({
-                'path': path,
-                'folder': folder
-            })
-
-    # Shuffle for randomness
-    random.shuffle(all_sampled)
-
-    # Save sample metadata
-    output_data = {
-        'version': '1.0',
-        'target_size': target_size,
-        'actual_size': len(all_sampled),
-        'maildir_path': maildir_path,
-        'sample_plan': sample_plan,
-        'folder_stats': folder_stats,
-        'emails': all_sampled
-    }
-
-    with open(output_file, 'w') as f:
-        json.dump(output_data, f, indent=2)
-
-    logger.info(f"\n✅ Sample created: {len(all_sampled):,} emails")
-    logger.info(f"📁 Saved to: {output_file}")
-    logger.info(f"🎲 Random seed: 42 (reproducible)")
-
-    return output_data
-
-
-if __name__ == "__main__":
-    import sys
-
-    maildir = sys.argv[1] if len(sys.argv) > 1 else "arnold-j"
-    target = int(sys.argv[2]) if len(sys.argv) > 2 else 100000
-    output = sys.argv[3] if len(sys.argv) > 3 else "enron_100k_sample.json"
-
-    create_stratified_sample(maildir, target, output)

credentials/README.md

@@ -0,0 +1,261 @@
+# Email Sorter - Credentials Management
+
+This directory stores authentication credentials for email providers. The system supports up to 3 accounts of each type (Gmail, Outlook, IMAP).
+
+## Directory Structure
+
+```
+credentials/
+├── gmail/
+│   ├── account1.json          # Primary Gmail account
+│   ├── account2.json          # Secondary Gmail account
+│   ├── account3.json          # Tertiary Gmail account
+│   └── account1.json.example  # Template
+├── outlook/
+│   ├── account1.json          # Primary Outlook account
+│   ├── account2.json          # Secondary Outlook account
+│   ├── account3.json          # Tertiary Outlook account
+│   └── account1.json.example  # Template
+└── imap/
+    ├── account1.json          # Primary IMAP account
+    ├── account2.json          # Secondary IMAP account
+    ├── account3.json          # Tertiary IMAP account
+    └── account1.json.example  # Template
+```
+
+## Gmail Setup
+
+### 1. Create OAuth Credentials
+
+1. Go to [Google Cloud Console](https://console.cloud.google.com)
+2. Create a new project (or select existing)
+3. Enable Gmail API
+4. Go to "Credentials" → "Create Credentials" → "OAuth client ID"
+5. Choose "Desktop app" as application type
+6. Download the JSON file
+7. Save as `credentials/gmail/account1.json` (or account2.json, account3.json)
+
+### 2. Credential File Format
+
+```json
+{
+  "installed": {
+    "client_id": "YOUR_CLIENT_ID.apps.googleusercontent.com",
+    "project_id": "your-project-id",
+    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+    "token_uri": "https://oauth2.googleapis.com/token",
+    "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+    "client_secret": "YOUR_CLIENT_SECRET",
+    "redirect_uris": ["http://localhost"]
+  }
+}
+```
+
+### 3. Usage
+
+```bash
+# Account 1
+python -m src.cli run --source gmail --credentials credentials/gmail/account1.json --limit 1000
+
+# Account 2
+python -m src.cli run --source gmail --credentials credentials/gmail/account2.json --limit 1000
+
+# Account 3
+python -m src.cli run --source gmail --credentials credentials/gmail/account3.json --limit 1000
+```
+
+## Outlook Setup
+
+### 1. Register Azure AD Application
+
+1. Go to [Azure Portal](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps)
+2. Click "New registration"
+3. Name your app (e.g., "Email Sorter")
+4. Choose "Accounts in any organizational directory and personal Microsoft accounts"
+5. Set Redirect URI to "Public client/native" with `http://localhost:8080`
+6. Click "Register"
+7. Copy the "Application (client) ID"
+8. (Optional) Create a client secret in "Certificates & secrets" for server apps
+
+### 2. Configure API Permissions
+
+1. Go to "API permissions"
+2. Click "Add a permission"
+3. Choose "Microsoft Graph"
+4. Select "Delegated permissions"
+5. Add:
+   - Mail.Read
+   - Mail.ReadWrite
+6. Click "Grant admin consent" (if you have admin rights)
+
+### 3. Credential File Format
+
+```json
+{
+  "client_id": "YOUR_AZURE_APP_CLIENT_ID",
+  "client_secret": "YOUR_CLIENT_SECRET_OPTIONAL",
+  "tenant_id": "common",
+  "redirect_uri": "http://localhost:8080"
+}
+```
+
+**Note:** `client_secret` is optional for desktop apps using device flow authentication.
+
+### 4. Usage
+
+```bash
+# Account 1
+python -m src.cli run --source outlook --credentials credentials/outlook/account1.json --limit 1000
+
+# Account 2
+python -m src.cli run --source outlook --credentials credentials/outlook/account2.json --limit 1000
+
+# Account 3
+python -m src.cli run --source outlook --credentials credentials/outlook/account3.json --limit 1000
+```
+
+## IMAP Setup
+
+### 1. Get IMAP Credentials
+
+For Gmail IMAP:
+1. Enable 2-factor authentication on your Google account
+2. Go to https://myaccount.google.com/apppasswords
+3. Generate an "App Password" for "Mail"
+4. Use this app password (not your real password)
+
+For Outlook/Office365 IMAP:
+- Host: `outlook.office365.com`
+- Port: `993`
+- Use your regular password or app password
+
+### 2. Credential File Format
+
+```json
+{
+  "host": "imap.gmail.com",
+  "port": 993,
+  "username": "your.email@gmail.com",
+  "password": "your_app_password_or_password",
+  "use_ssl": true
+}
+```
+
+### 3. Usage
+
+```bash
+# Account 1
+python -m src.cli run --source imap --credentials credentials/imap/account1.json --limit 1000
+
+# Account 2
+python -m src.cli run --source imap --credentials credentials/imap/account2.json --limit 1000
+
+# Account 3
+python -m src.cli run --source imap --credentials credentials/imap/account3.json --limit 1000
+```
+
+## Security Notes
+
+### Important Security Practices
+
+1. **Never commit credentials to git**
+   - The `.gitignore` file excludes `credentials/` directory
+   - Only `.example` files should be committed
+
+2. **File permissions**
+   - Set restrictive permissions: `chmod 600 credentials/*/*.json`
+
+3. **Credential rotation**
+   - Rotate credentials periodically
+   - Revoke unused credentials in provider dashboards
+
+4. **Separation**
+   - Keep each account's credentials in separate files
+   - Use descriptive names (account1, account2, account3)
+
+### Credential Storage Locations
+
+**This directory** (`credentials/`) is for:
+- Development and testing
+- Personal use
+- Single-user deployments
+
+**NOT recommended for:**
+- Production servers (use environment variables or secret managers)
+- Multi-user systems (use proper authentication systems)
+- Public repositories (credentials would be exposed)
+
+## Troubleshooting
+
+### Gmail Issues
+
+**Error: "credentials_path required"**
+- Ensure you're passing `--credentials` flag
+- Verify file exists and path is correct
+
+**Error: "GMAIL DEPENDENCIES MISSING"**
+- Install dependencies: `pip install google-api-python-client google-auth-oauthlib`
+
+**Error: "CREDENTIALS FILE NOT FOUND"**
+- Check file exists at specified path
+- Ensure filename is correct (case-sensitive)
+
+### Outlook Issues
+
+**Error: "client_id required"**
+- Verify JSON file has `client_id` field
+- Check Azure app registration
+
+**Error: "OUTLOOK DEPENDENCIES MISSING"**
+- Install dependencies: `pip install msal requests`
+
+**Authentication timeout**
+- Complete device flow authentication within time limit
+- Check browser for authentication prompt
+- Verify Azure app has correct permissions
+
+### IMAP Issues
+
+**Error: "Authentication failed"**
+- For Gmail: Use app password, not regular password
+- Enable "Less secure app access" if using regular password
+- Verify username/password are correct
+
+**Connection timeout**
+- Check host and port are correct
+- Verify firewall isn't blocking IMAP port
+- Test connection with: `telnet imap.gmail.com 993`
+
+## Testing Credentials
+
+Test each credential file before running full classification:
+
+```bash
+# Test Gmail connection
+python -m src.cli test-gmail --credentials credentials/gmail/account1.json
+
+# Test Outlook connection
+python -m src.cli test-outlook --credentials credentials/outlook/account1.json
+
+# Test IMAP connection
+python -m src.cli test-imap --credentials credentials/imap/account1.json
+```
+
+## Dependencies
+
+### Gmail
+```bash
+pip install google-api-python-client google-auth-oauthlib google-auth-httplib2
+```
+
+### Outlook
+```bash
+pip install msal requests
+```
+
+### IMAP
+No additional dependencies required (uses Python standard library).
+
+---
+
+**Remember:** Keep your credentials secure and never share them publicly!

credentials/gmail/account1.json.example

@@ -0,0 +1,11 @@
+{
+  "installed": {
+    "client_id": "YOUR_CLIENT_ID.apps.googleusercontent.com",
+    "project_id": "your-project-id",
+    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+    "token_uri": "https://oauth2.googleapis.com/token",
+    "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+    "client_secret": "YOUR_CLIENT_SECRET",
+    "redirect_uris": ["http://localhost"]
+  }
+}

credentials/imap/account1.json.example

@@ -0,0 +1,7 @@
+{
+  "host": "imap.gmail.com",
+  "port": 993,
+  "username": "your.email@gmail.com",
+  "password": "your_app_password_or_password",
+  "use_ssl": true
+}

credentials/outlook/account1.json.example

@@ -0,0 +1,6 @@
+{
+  "client_id": "YOUR_AZURE_APP_CLIENT_ID",
+  "client_secret": "YOUR_CLIENT_SECRET_OPTIONAL",
+  "tenant_id": "common",
+  "redirect_uri": "http://localhost:8080"
+}

docs/CLASSIFICATION_METHODS_COMPARISON.md

@@ -0,0 +1,518 @@
+# Email Classification Methods: Comparative Analysis
+
+## Executive Summary
+
+This document compares three email classification approaches tested on an 801-email personal Gmail dataset:
+
+| Method | Accuracy | Time | Best For |
+|--------|----------|------|----------|
+| ML-Only | 54.9% | 5 sec | 10k+ emails, speed critical |
+| ML+LLM Fallback | 93.3% | 3.5 min | 1k-10k emails, balanced |
+| Agent Analysis | 99.8% | 15-30 min | <1k emails, deep insights |
+
+**Key Finding:** The ML pipeline is overkill for datasets under ~5,000 emails. A 10-15 minute agent pre-analysis phase could dramatically improve ML accuracy for larger datasets.
+
+---
+
+## Test Dataset Profile
+
+| Characteristic | Value |
+|----------------|-------|
+| Total Emails | 801 |
+| Date Range | 20 years (2005-2025) |
+| Unique Senders | ~150 |
+| Automated % | 48.8% |
+| Personal % | 1.6% |
+| Structure Level | MEDIUM-HIGH |
+
+### Email Type Breakdown (Sanitized)
+
+```
+Automated Notifications     48.8%  ████████████████████████
+├─ Art marketplace alerts   16.2%  ████████
+├─ Shopping promotions      15.4%  ███████
+├─ Travel recommendations   13.4%  ██████
+└─ Streaming promotions      8.5%  ████
+
+Business/Professional       20.1%  ██████████
+├─ Cloud service reports    13.0%  ██████
+├─ Security alerts           7.1%  ███
+
+AI/Developer Services       12.8%  ██████
+├─ AI platform updates       6.4%  ███
+├─ Developer tool updates    6.4%  ███
+
+Personal/Other              18.3%  █████████
+├─ Entertainment             5.1%  ██
+├─ Productivity tools        3.7%  █
+├─ Direct correspondence     1.6%  █
+└─ Miscellaneous             7.9%  ███
+```
+
+---
+
+## Method 1: ML-Only Classification
+
+### Configuration
+```yaml
+model: LightGBM (pretrained on Enron dataset)
+embeddings: all-minilm:l6-v2 (384 dimensions)
+threshold: 0.55 confidence
+categories: 11 generic (Work, Updates, Financial, etc.)
+```
+
+### Results
+
+| Metric | Value |
+|--------|-------|
+| Accuracy Estimate | 54.9% |
+| High Confidence (>55%) | 477 (59.6%) |
+| Low Confidence | 324 (40.4%) |
+| Processing Time | ~5 seconds |
+| LLM Calls | 0 |
+
+### Category Distribution (ML-Only)
+
+| Category | Count | % |
+|----------|-------|---|
+| Work | 243 | 30.3% |
+| Technical | 198 | 24.7% |
+| Updates | 156 | 19.5% |
+| External | 89 | 11.1% |
+| Operational | 45 | 5.6% |
+| Financial | 38 | 4.7% |
+| Other | 32 | 4.0% |
+
+### Limitations Observed
+
+1. **Domain Mismatch:** Trained on corporate Enron emails, applied to personal Gmail
+2. **Generic Categories:** "Work" and "Technical" absorbed everything
+3. **No Sender Intelligence:** Didn't leverage sender domain patterns
+4. **High Uncertainty:** 40% needed LLM review but got none
+
+### When ML-Only Works
+
+- 10,000+ emails where speed matters
+- Corporate/enterprise datasets similar to training data
+- Pre-filtering before human review
+- Cost-constrained environments (no LLM API)
+
+---
+
+## Method 2: ML + LLM Fallback
+
+### Configuration
+```yaml
+ml_model: LightGBM (same as above)
+llm_model: qwen3-coder-30b (vLLM on localhost:11433)
+threshold: 0.55 confidence
+fallback_trigger: confidence < threshold
+```
+
+### Results
+
+| Metric | Value |
+|--------|-------|
+| Accuracy Estimate | 93.3% |
+| ML Classified | 477 (59.6%) |
+| LLM Classified | 324 (40.4%) |
+| Processing Time | ~3.5 minutes |
+| LLM Calls | 324 |
+
+### Category Distribution (ML+LLM)
+
+| Category | Count | % | Source |
+|----------|-------|---|--------|
+| Work | 243 | 30.3% | ML |
+| Technical | 156 | 19.5% | ML |
+| newsletters | 98 | 12.2% | LLM |
+| junk | 87 | 10.9% | LLM |
+| transactional | 76 | 9.5% | LLM |
+| Updates | 62 | 7.7% | ML |
+| auth | 45 | 5.6% | LLM |
+| Other | 34 | 4.2% | Mixed |
+
+### Improvements Over ML-Only
+
+1. **New Categories:** LLM introduced "newsletters", "junk", "transactional", "auth"
+2. **Better Separation:** Marketing vs. transactional distinguished
+3. **Higher Confidence:** 93.3% vs 54.9% accuracy estimate
+
+### Limitations Observed
+
+1. **Category Inconsistency:** ML uses "Updates", LLM uses "newsletters"
+2. **No Sender Context:** Still classifying email-by-email
+3. **Generic LLM Prompt:** Doesn't know about user's specific interests
+4. **Time Cost:** 324 sequential LLM calls at ~0.6s each
+
+### When ML+LLM Works
+
+- 1,000-10,000 emails
+- Mixed automated/personal content
+- When accuracy matters more than speed
+- Local LLM available (cost-free fallback)
+
+---
+
+## Method 3: Agent Analysis (Manual)
+
+### Approach
+```
+Phase 1: Initial Discovery (5 min)
+  - Sample filenames and subjects
+  - Identify sender domains
+  - Detect patterns
+
+Phase 2: Pattern Extraction (10 min)
+  - Design domain-specific rules
+  - Test regex patterns
+  - Validate on subset
+
+Phase 3: Deep Dive (5 min)
+  - Track order lifecycles
+  - Identify billing patterns
+  - Find edge cases
+
+Phase 4: Report Generation (5 min)
+  - Synthesize findings
+  - Create actionable recommendations
+```
+
+### Results
+
+| Metric | Value |
+|--------|-------|
+| Accuracy | 99.8% (799/801) |
+| Categories | 15 custom |
+| Processing Time | ~25 minutes |
+| LLM Calls | ~20 (analysis only) |
+
+### Category Distribution (Agent Analysis)
+
+| Category | Count | % | Subcategories |
+|----------|-------|---|---------------|
+| Art & Collectibles | 130 | 16.2% | Marketplace alerts |
+| Shopping | 123 | 15.4% | eBay, AliExpress, Automotive |
+| Entertainment | 109 | 13.6% | Streaming, Gaming, Social |
+| Travel & Tourism | 107 | 13.4% | Review sites, Bookings |
+| Google Services | 104 | 13.0% | Business, Ads, Analytics |
+| Security | 57 | 7.1% | Sign-in alerts, 2FA |
+| AI Services | 51 | 6.4% | Claude, OpenAI, Lambda |
+| Developer Tools | 51 | 6.4% | ngrok, Firebase, Docker |
+| Productivity | 30 | 3.7% | Screen recording, Docs |
+| Personal | 13 | 1.6% | Direct correspondence |
+| Other | 26 | 3.2% | Childcare, Legal, etc. |
+
+### Unique Insights (Not Found by ML)
+
+1. **Specific Artist Tracking:** 95 alerts for specific artist "Dan Colen"
+2. **Order Lifecycle:** Single order generated 7 notification emails
+3. **Billing Patterns:** Monthly receipts from AI services on 15th
+4. **Business Context:** User runs "Fox Software Solutions"
+5. **Filtering Rules:** Ready-to-implement Gmail filters
+
+### When Agent Analysis Works
+
+- Under 1,000 emails
+- Initial dataset understanding
+- Creating filtering rules
+- One-time deep analysis
+- Training data preparation
+
+---
+
+## Comparative Analysis
+
+### Accuracy vs Time Tradeoff
+
+```
+Accuracy
+100% ─┬─────────────────────────●─── Agent (99.8%)
+      │                    ●─────── ML+LLM (93.3%)
+ 75% ─┤
+      │
+ 50% ─┼────●───────────────────────── ML-Only (54.9%)
+      │
+ 25% ─┤
+      │
+  0% ─┴────┬────────┬────────┬────────┬─── Time
+          5s      1m       5m      30m
+```
+
+### Cost Analysis (per 1000 emails)
+
+| Method | Compute | LLM Calls | Est. Cost |
+|--------|---------|-----------|-----------|
+| ML-Only | 5 sec | 0 | $0.00 |
+| ML+LLM | 4 min | ~400 | $0.02-0.40* |
+| Agent | 30 min | ~30 | $0.01-0.10* |
+
+*Depends on LLM provider; local = free, cloud = varies
+
+### Category Quality
+
+| Aspect | ML-Only | ML+LLM | Agent |
+|--------|---------|--------|-------|
+| Granularity | Low (11) | Medium (16) | High (15+subs) |
+| Domain-Specific | No | Partial | Yes |
+| Actionable | Limited | Moderate | High |
+| Sender-Aware | No | No | Yes |
+| Context-Aware | No | Limited | Yes |
+
+---
+
+## Enhancement Recommendations
+
+### 1. Pre-Analysis Phase (10-15 min investment)
+
+**Concept:** Run agent analysis BEFORE ML classification to:
+- Discover sender domains and their purposes
+- Identify category patterns specific to dataset
+- Generate custom classification rules
+- Create sender-to-category mappings
+
+**Implementation:**
+```python
+class PreAnalysisAgent:
+    def analyze(self, emails: List[Email], sample_size=100):
+        # Phase 1: Sender domain clustering
+        domains = self.cluster_by_sender_domain(emails)
+
+        # Phase 2: Subject pattern extraction
+        patterns = self.extract_subject_patterns(emails)
+
+        # Phase 3: Generate custom categories
+        categories = self.generate_categories(domains, patterns)
+
+        # Phase 4: Create sender-category mapping
+        sender_map = self.map_senders_to_categories(domains, categories)
+
+        return {
+            'categories': categories,
+            'sender_map': sender_map,
+            'patterns': patterns
+        }
+```
+
+**Expected Impact:**
+- Accuracy: 54.9% → 85-90% (ML-only with pre-analysis)
+- Time: +10 min setup, same runtime
+- Best for: 5,000+ email datasets
+
+### 2. Sender-First Classification
+
+**Concept:** Classify by sender domain BEFORE content analysis:
+
+```python
+SENDER_CATEGORIES = {
+    # High-volume automated
+    'mutualart.com': ('Notifications', 'Art Alerts'),
+    'tripadvisor.com': ('Notifications', 'Travel Marketing'),
+    'ebay.com': ('Shopping', 'Marketplace'),
+    'spotify.com': ('Entertainment', 'Streaming'),
+
+    # Security - never auto-filter
+    'accounts.google.com': ('Security', 'Account Alerts'),
+
+    # Business
+    'businessprofile-noreply@google.com': ('Business', 'Reports'),
+}
+
+def classify(email):
+    domain = extract_domain(email.sender)
+    if domain in SENDER_CATEGORIES:
+        return SENDER_CATEGORIES[domain]  # 80% of emails
+    else:
+        return ml_classify(email)  # Fallback for 20%
+```
+
+**Expected Impact:**
+- Accuracy: 85-95% for known senders
+- Speed: 10x faster (skip ML for known senders)
+- Maintenance: Requires sender map updates
+
+### 3. Post-Analysis Enhancement
+
+**Concept:** Run agent analysis AFTER ML to:
+- Validate classification quality
+- Extract deeper insights
+- Generate reports and recommendations
+- Identify misclassifications
+
+**Implementation:**
+```python
+class PostAnalysisAgent:
+    def analyze(self, emails: List[Email], classifications: List[Result]):
+        # Validate: Check for obvious errors
+        errors = self.detect_misclassifications(emails, classifications)
+
+        # Enrich: Add metadata not captured by ML
+        enriched = self.extract_metadata(emails)
+
+        # Insights: Generate actionable recommendations
+        insights = self.generate_insights(emails, classifications)
+
+        return {
+            'corrections': errors,
+            'enrichments': enriched,
+            'insights': insights
+        }
+```
+
+### 4. Dataset Size Routing
+
+**Concept:** Automatically choose method based on volume:
+
+```python
+def choose_method(email_count: int, time_budget: str = 'normal'):
+    if email_count < 500:
+        return 'agent_only'  # Full agent analysis
+
+    elif email_count < 2000:
+        return 'agent_then_ml'  # Pre-analysis + ML
+
+    elif email_count < 10000:
+        return 'ml_with_llm'  # ML + LLM fallback
+
+    else:
+        return 'ml_only'  # Pure ML for speed
+```
+
+**Recommended Thresholds:**
+
+| Volume | Recommended Method | Rationale |
+|--------|-------------------|-----------|
+| <500 | Agent Only | ML overhead not worth it |
+| 500-2000 | Agent Pre-Analysis + ML | Investment pays off |
+| 2000-10000 | ML + LLM Fallback | Balanced approach |
+| >10000 | ML-Only | Speed critical |
+
+### 5. Hybrid Category System
+
+**Concept:** Merge ML categories with agent-discovered categories:
+
+```python
+# ML Generic Categories (trained)
+ML_CATEGORIES = ['Work', 'Updates', 'Technical', 'Financial', ...]
+
+# Agent-Discovered Categories (per-dataset)
+AGENT_CATEGORIES = {
+    'Art Alerts': {'parent': 'Updates', 'sender': 'mutualart.com'},
+    'Travel Marketing': {'parent': 'Updates', 'sender': 'tripadvisor.com'},
+    'AI Services': {'parent': 'Technical', 'keywords': ['anthropic', 'openai']},
+}
+
+def classify_hybrid(email, ml_result):
+    # First: Check agent-specific rules
+    for cat, rules in AGENT_CATEGORIES.items():
+        if matches_rules(email, rules):
+            return (cat, ml_result.category)  # Specific + generic
+
+    # Fallback: ML result
+    return (ml_result.category, None)
+```
+
+---
+
+## Implementation Roadmap
+
+### Phase 1: Quick Wins (1-2 hours)
+
+1. **Add sender-domain classifier**
+   - Map top 20 senders to categories
+   - Use as fast-path before ML
+   - Expected: +20% accuracy
+
+2. **Add dataset size routing**
+   - Check email count before processing
+   - Route small datasets to agent analysis
+   - Route large datasets to ML pipeline
+
+### Phase 2: Pre-Analysis Agent (4-8 hours)
+
+1. **Build sender clustering**
+   - Group emails by domain
+   - Calculate volume per domain
+   - Identify automated vs personal
+
+2. **Build pattern extraction**
+   - Find subject templates
+   - Extract IDs and tracking numbers
+   - Identify lifecycle stages
+
+3. **Generate sender map**
+   - Output: JSON mapping senders to categories
+   - Feed into ML pipeline as rules
+
+### Phase 3: Post-Analysis Enhancement (4-8 hours)
+
+1. **Build validation agent**
+   - Check low-confidence results
+   - Detect category conflicts
+   - Flag for review
+
+2. **Build enrichment agent**
+   - Extract order IDs
+   - Track lifecycles
+   - Generate insights
+
+3. **Integrate with HTML report**
+   - Add insights section
+   - Show lifecycle tracking
+   - Include recommendations
+
+---
+
+## Conclusion
+
+### Key Takeaways
+
+1. **ML pipeline is overkill for <5,000 emails** - Agent analysis provides better accuracy with similar time investment
+
+2. **Sender domain is the strongest signal** - 80%+ emails can be classified by sender alone
+
+3. **Pre-analysis investment pays off** - 10-15 min agent setup dramatically improves ML accuracy
+
+4. **One-size-fits-all doesn't work** - Route by dataset size for optimal results
+
+5. **Post-analysis adds unique value** - Lifecycle tracking and insights not possible with ML alone
+
+### Recommended Default Pipeline
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    EMAIL CLASSIFICATION                      │
+└─────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+                    ┌─────────────────┐
+                    │ Count Emails    │
+                    └────────┬────────┘
+                             │
+          ┌──────────────────┼──────────────────┐
+          │                  │                  │
+          ▼                  ▼                  ▼
+     <500 emails       500-5000            >5000
+          │                  │                  │
+          ▼                  ▼                  ▼
+   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐
+   │ Agent Only   │  │ Pre-Analysis │  │ ML Pipeline  │
+   │ (15-30 min)  │  │ + ML + Post  │  │ (fast)       │
+   │              │  │ (15 min + ML)│  │              │
+   └──────────────┘  └──────────────┘  └──────────────┘
+          │                  │                  │
+          ▼                  ▼                  ▼
+   ┌──────────────────────────────────────────────────┐
+   │              UNIFIED OUTPUT                       │
+   │  - Categorized emails                            │
+   │  - Confidence scores                             │
+   │  - Insights & recommendations                    │
+   │  - Filtering rules                               │
+   └──────────────────────────────────────────────────┘
+```
+
+---
+
+*Document Version: 1.0*
+*Created: 2025-11-28*
+*Based on: brett-gmail dataset analysis (801 emails)*

docs/PROJECT_ROADMAP_2025.md

@@ -0,0 +1,479 @@
+# Email Sorter: Project Roadmap & Learnings
+
+## Document Purpose
+
+This document captures learnings from the November 2025 research session and defines the project scope, role within a larger email processing ecosystem, and development roadmap for 2025.
+
+---
+
+## Project Scope Definition
+
+### What This Tool IS
+
+**Email Sorter is a TRIAGE tool.** Its job is:
+
+1. **Bulk classification** - Sort emails into buckets quickly
+2. **Risk-based routing** - Flag high-stakes items for careful handling
+3. **Downstream handoff** - Prepare emails for specialized processing tools
+
+### What This Tool IS NOT
+
+- Not a spam filter (trust Gmail/Outlook for that)
+- Not a complete email management solution
+- Not trying to do everything
+- Not the final destination for any email
+
+### Role in Larger Ecosystem
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    EMAIL PROCESSING ECOSYSTEM                    │
+└─────────────────────────────────────────────────────────────────┘
+
+     ┌──────────────┐
+     │  RAW INBOX   │  (Gmail, Outlook, IMAP)
+     │   10k+       │
+     └──────┬───────┘
+            │
+            ▼
+     ┌──────────────┐
+     │ SPAM FILTER  │  ← Trust existing provider (Gmail/Outlook)
+     │  (existing)  │
+     └──────┬───────┘
+            │
+            ▼
+┌───────────────────────────────────────┐
+│         EMAIL SORTER (THIS TOOL)      │  ← TRIAGE/ROUTING
+│  ┌─────────────┐  ┌────────────────┐  │
+│  │ Agent Scan  │→ │ ML/LLM Classify│  │
+│  │ (discovery) │  │ (bulk sort)    │  │
+│  └─────────────┘  └────────────────┘  │
+└───────────────────┬───────────────────┘
+                    │
+      ┌─────────────┼─────────────┬─────────────┐
+      ▼             ▼             ▼             ▼
+┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
+│  JUNK    │ │ ROUTINE  │ │ BUSINESS │ │ PERSONAL │
+│  BUCKET  │ │  BUCKET  │ │  BUCKET  │ │  BUCKET  │
+└────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘
+     │            │            │            │
+     ▼            ▼            ▼            ▼
+┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
+│  Batch   │ │  Batch   │ │ Knowledge│ │  Human   │
+│ Cleanup  │ │ Summary  │ │  Graph   │ │  Review  │
+│  (cheap) │ │  Tool    │ │  Builder │ │(careful) │
+└──────────┘ └──────────┘ └──────────┘ └──────────┘
+
+     OTHER TOOLS IN ECOSYSTEM (not this project)
+```
+
+---
+
+## Key Learnings from Research Sessions
+
+### Session 1: brett-gmail (801 emails, Personal Inbox)
+
+| Method | Accuracy | Time |
+|--------|----------|------|
+| ML-Only | 54.9% | ~5 sec |
+| ML+LLM | 93.3% | ~3.5 min |
+| Manual Agent | 99.8% | ~25 min |
+
+### Session 2: brett-microsoft (596 emails, Business Inbox)
+
+| Method | Accuracy | Time |
+|--------|----------|------|
+| Manual Agent | 98.2% | ~30 min |
+
+**Key Insight:** Business inboxes require different classification approaches than personal inboxes.
+
+---
+
+### 1. ML Pipeline is Overkill for Small Datasets
+
+| Dataset Size | Recommended Approach | Rationale |
+|--------------|---------------------|-----------|
+| <500 | Agent-only analysis | ML overhead exceeds benefit |
+| 500-2000 | Agent pre-scan + ML | Discovery improves ML accuracy |
+| 2000-10000 | ML + LLM fallback | Balanced speed/accuracy |
+| >10000 | ML-only (fast mode) | Speed critical at scale |
+
+**Evidence:** 801-email dataset achieved 99.8% accuracy with 25-min agent analysis vs 54.9% with pure ML.
+
+### 2. Agent Pre-Scan Adds Massive Value
+
+A 10-15 minute agent discovery phase before bulk classification:
+- Identifies dominant sender domains
+- Discovers subject patterns
+- Suggests optimal categories for THIS dataset
+- Can generate sender-to-category mappings
+
+**This is NOT the same as the full manual analysis.** It's a quick reconnaissance pass.
+
+### 3. Categories Should Serve Downstream Processing
+
+Don't optimize for human-readable labels. Optimize for routing decisions:
+
+| Category Type | Downstream Handler | Accuracy Need |
+|---------------|-------------------|---------------|
+| Junk/Marketing | Batch cleanup tool | LOW (errors OK) |
+| Newsletters | Summary aggregator | MEDIUM |
+| Transactional | Archive, searchable | MEDIUM |
+| Business | Knowledge graph | HIGH |
+| Personal | Human review | CRITICAL |
+| Security | Never auto-filter | CRITICAL |
+
+### 4. Risk-Based Accuracy Requirements
+
+Not all emails need the same classification confidence:
+
+```
+HIGH STAKES (must not miss):
+├─ Personal correspondence (sentimental value)
+├─ Security alerts (account safety)
+├─ Job applications (life-changing)
+└─ Financial/legal documents
+
+LOW STAKES (errors tolerable):
+├─ Marketing promotions
+├─ Newsletter digests
+├─ Automated notifications
+└─ Social media alerts
+```
+
+### 5. Spam Filtering is a Solved Problem
+
+Don't reinvent spam filtering. Gmail and Outlook do it well. This tool should:
+- Assume spam is already filtered
+- Focus on categorizing legitimate mail
+- Trust the upstream provider
+
+If spam does get through, a simple secondary filter could catch obvious cases, but this is low priority.
+
+### 6. Sender Domain is the Strongest Signal
+
+From the 801-email analysis:
+- Top 5 senders = 47.5% of all emails
+- Sender domain alone could classify 80%+ of automated emails
+- Subject patterns matter less than sender patterns
+
+**Implication:** A sender-first classification approach could dramatically speed up processing.
+
+### 7. Inbox Character Matters (NEW - Session 2)
+
+**Critical Discovery:** Before classifying emails, assess the inbox CHARACTER:
+
+| Inbox Type | Characteristics | Classification Approach |
+|------------|-----------------|------------------------|
+| **Personal/Consumer** | Subscription-heavy, marketing-dominant, automated 40-50% | Sender domain first |
+| **Business/Professional** | Client work, operations, developer tools 60-70% | Sender + Subject context |
+| **Mixed** | Both patterns present | Hybrid approach needed |
+
+**Evidence from brett-microsoft analysis:**
+- 73.2% Business/Professional content
+- Only 8.2% Personal content
+- Required client relationship tracking
+- Support case ID extraction valuable
+
+**Implications for Agent Pre-Scan:**
+1. First determine inbox character (business vs personal vs mixed)
+2. Select appropriate category templates
+3. Business inboxes need relationship context, not just sender domains
+
+### 8. Business Inboxes Need Special Handling (NEW - Session 2)
+
+Business/professional inboxes require additional classification dimensions:
+
+**Client Relationship Tracking:**
+- Same domain may have different contexts (internal vs external)
+- Client conversations span multiple senders
+- Subject threading matters more than in consumer inboxes
+
+**Support Case ID Extraction:**
+- Business inboxes often have case/ticket IDs connecting emails
+- Microsoft: Case #, TrackingID#
+- Other vendors: Ticket numbers, reference IDs
+- ID extraction should be first-class feature
+
+**Accuracy Expectations:**
+- Personal inboxes: 99%+ achievable with sender-first
+- Business inboxes: 95-98% achievable (more nuanced)
+- Accept lower accuracy ceiling, invest in risk-flagging
+
+### 9. Multi-Inbox Analysis Reveals Patterns (NEW - Session 2)
+
+Analyzing multiple inboxes from same user reveals:
+- **Inbox segregation patterns** - Gmail for personal, Outlook for business
+- **Cross-inbox senders** - Security alerts appear in both
+- **Category overlap** - Some categories universal, some inbox-specific
+
+**Implication:** Future feature could merge analysis across inboxes to build complete user profile.
+
+---
+
+## Technical Architecture (Refined)
+
+### Current State
+
+```
+Email Source → LocalFileParser → FeatureExtractor → ML Classifier → Output
+                                      │
+                                      └→ LLM Fallback (if low confidence)
+```
+
+### Target State (2025)
+
+```
+Email Source
+     │
+     ▼
+┌─────────────────────────────────────────────────────────────┐
+│                    ROUTING LAYER                             │
+│  Check dataset size → Route to appropriate pipeline          │
+└─────────────────────────────────────────────────────────────┘
+     │
+     ├─── <500 emails ────→ Agent-Only Analysis
+     │
+     ├─── 500-5000 ───────→ Agent Pre-Scan + ML Pipeline
+     │
+     └─── >5000 ──────────→ ML Pipeline (optional LLM)
+
+Each pipeline outputs:
+  - Categorized emails (with confidence)
+  - Risk flags (high-stakes items)
+  - Routing recommendations
+  - Insights report
+```
+
+### Agent Pre-Scan Module (NEW)
+
+```python
+class AgentPreScan:
+    """
+    Quick discovery phase before bulk classification.
+    Time budget: 10-15 minutes.
+    """
+
+    def scan(self, emails: List[Email]) -> PreScanResult:
+        # 1. Sender domain analysis (2 min)
+        sender_stats = self.analyze_senders(emails)
+
+        # 2. Subject pattern detection (3 min)
+        patterns = self.detect_patterns(emails, sample_size=100)
+
+        # 3. Category suggestions (5 min, uses LLM)
+        categories = self.suggest_categories(sender_stats, patterns)
+
+        # 4. Generate sender map (2 min)
+        sender_map = self.create_sender_mapping(sender_stats, categories)
+
+        return PreScanResult(
+            sender_stats=sender_stats,
+            patterns=patterns,
+            suggested_categories=categories,
+            sender_map=sender_map,
+            estimated_distribution=self.estimate_distribution(emails, categories)
+        )
+```
+
+---
+
+## Development Roadmap
+
+### Phase 0: Documentation Complete (NOW)
+
+- [x] Research session findings documented
+- [x] Classification methods comparison written
+- [x] Project scope defined
+- [x] This roadmap created
+
+### Phase 1: Quick Wins (Q1 2025, 4-8 hours)
+
+1. **Dataset size routing**
+   - Auto-detect email count
+   - Route small datasets to agent analysis
+   - Route large datasets to ML pipeline
+
+2. **Sender-first classification**
+   - Extract sender domain
+   - Check against known sender map
+   - Skip ML for known high-volume senders
+
+3. **Risk flagging**
+   - Flag low-confidence results
+   - Flag potential personal emails
+   - Flag security-related emails
+
+### Phase 2: Agent Pre-Scan (Q1 2025, 8-16 hours)
+
+1. **Sender analysis module**
+   - Cluster by domain
+   - Calculate volume statistics
+   - Identify automated vs personal
+
+2. **Pattern detection module**
+   - Sample subject lines
+   - Find templates and IDs
+   - Detect lifecycle stages
+
+3. **Category suggestion module**
+   - Use LLM to suggest categories
+   - Based on sender/pattern analysis
+   - Output category definitions
+
+4. **Sender mapping module**
+   - Map senders to suggested categories
+   - Output as JSON for pipeline use
+   - Support manual overrides
+
+### Phase 3: Integration & Polish (Q2 2025)
+
+1. **Unified CLI**
+   - Single command handles all dataset sizes
+   - Progress reporting
+   - Configurable verbosity
+
+2. **Output standardization**
+   - Common format for all pipelines
+   - Include routing recommendations
+   - Include confidence and risk flags
+
+3. **Ecosystem integration**
+   - Define handoff format for downstream tools
+   - Document API for other tools to consume
+   - Create example integrations
+
+### Phase 4: Scale Testing (Q2-Q3 2025)
+
+1. **Test on real 10k+ mailboxes**
+   - Multiple users, different patterns
+   - Measure accuracy vs speed
+   - Refine thresholds
+
+2. **Pattern library**
+   - Accumulate patterns from multiple mailboxes
+   - Build reusable sender maps
+   - Create category templates
+
+3. **Feedback loop**
+   - Track classification accuracy
+   - Learn from corrections
+   - Improve over time
+
+---
+
+## Configuration Philosophy
+
+### User-Facing Config (Keep Simple)
+
+```yaml
+# config/user_config.yaml
+mode: auto          # auto | agent | ml | hybrid
+risk_threshold: high  # low | medium | high
+output_format: json   # json | csv | html
+```
+
+### Internal Config (Full Control)
+
+```yaml
+# config/advanced_config.yaml
+routing:
+  small_threshold: 500
+  medium_threshold: 5000
+
+agent_prescan:
+  enabled: true
+  time_budget_minutes: 15
+  sample_size: 100
+
+ml_pipeline:
+  confidence_threshold: 0.55
+  llm_fallback: true
+  batch_size: 512
+
+risk_detection:
+  personal_indicators: [gmail.com, hotmail.com, outlook.com]
+  security_senders: [accounts.google.com, security@]
+  high_stakes_keywords: [urgent, important, legal, contract]
+```
+
+---
+
+## Success Metrics
+
+### For This Tool
+
+| Metric | Target | Current |
+|--------|--------|---------|
+| Classification accuracy (large datasets) | >85% | 54.9% (ML), 93.3% (ML+LLM) |
+| Processing speed (10k emails) | <5 min | ~24 sec (ML-only) |
+| High-stakes miss rate | <1% | Not measured |
+| Setup time for new mailbox | <20 min | Variable |
+
+### For Ecosystem
+
+| Metric | Target |
+|--------|--------|
+| End-to-end mailbox processing | <2 hours for 10k |
+| User intervention needed | <10% of emails |
+| Downstream tool compatibility | 100% |
+
+---
+
+## Open Questions (To Resolve in 2025)
+
+1. **Category standardization**: Should categories be fixed across all users, or discovered per-mailbox?
+
+2. **Sender map sharing**: Can sender maps be shared across users? Privacy implications?
+
+3. **Incremental processing**: How to handle new emails added to already-processed mailboxes?
+
+4. **Multi-account support**: Same user, multiple email accounts?
+
+5. **Feedback integration**: How do corrections feed back into the system?
+
+---
+
+## Files Created During Research
+
+### Session 1 (brett-gmail, Personal Inbox)
+
+| File | Purpose |
+|------|---------|
+| `tools/brett_gmail_analyzer.py` | Custom analyzer for personal inbox |
+| `tools/generate_html_report.py` | HTML report generator |
+| `data/brett_gmail_analysis.json` | Analysis data output |
+| `docs/CLASSIFICATION_METHODS_COMPARISON.md` | Method comparison |
+| `docs/REPORT_FORMAT.md` | HTML report documentation |
+| `docs/SESSION_HANDOVER_20251128.md` | Session 1 handover |
+
+### Session 2 (brett-microsoft, Business Inbox)
+
+| File | Purpose |
+|------|---------|
+| `tools/brett_microsoft_analyzer.py` | Custom analyzer for business inbox |
+| `data/brett_microsoft_analysis.json` | Analysis data output |
+| `/home/bob/.../brett-ms-sorter/BRETT_MICROSOFT_ANALYSIS_REPORT.md` | Full analysis report |
+
+---
+
+## Summary
+
+**Email Sorter is a triage tool, not a complete solution.**
+
+Its job is to quickly sort emails into buckets so that specialized downstream tools can handle each bucket appropriately. The key insight from this research session is that an agent pre-scan phase, even just 10-15 minutes, dramatically improves classification accuracy for any dataset size.
+
+The ML pipeline is valuable for scale (10k+ emails) but overkill for smaller datasets. Risk-based accuracy means we can tolerate errors on junk but must be careful with personal correspondence.
+
+2025 development should focus on:
+1. Smart routing based on dataset size
+2. Agent pre-scan for discovery
+3. Standardized output for ecosystem integration
+4. Scale testing on real large mailboxes
+
+---
+
+*Document Version: 1.1*
+*Created: 2025-11-28*
+*Updated: 2025-11-28 (Session 2 learnings)*
+*Sessions: brett-gmail (801 emails, personal), brett-microsoft (596 emails, business)*

docs/REPORT_FORMAT.md

@@ -0,0 +1,232 @@
+# Email Classification Report Format
+
+This document explains the HTML report generation system, its data sources, and how to customize it.
+
+## Overview
+
+The report generator creates a static HTML file from classification results. It requires enriched `results.json` with email metadata (subject, sender, date, etc.) - not just classification data.
+
+## Files Involved
+
+| File | Purpose |
+|------|---------|
+| `tools/generate_html_report.py` | Main report generator script |
+| `src/cli.py` | Classification CLI - outputs enriched `results.json` |
+| `src/export/exporter.py` | Legacy exporter (JSON/CSV) - not used for HTML |
+
+## Data Flow
+
+```
+Email Source (.eml/.msg files)
+        ↓
+   src/cli.py (classification)
+        ↓
+   results.json (enriched with metadata)
+        ↓
+   tools/generate_html_report.py
+        ↓
+   report.html (static, self-contained)
+```
+
+## Usage
+
+### Generate Report
+
+```bash
+python tools/generate_html_report.py \
+  --input /path/to/results.json \
+  --output /path/to/report.html
+```
+
+If `--output` is omitted, creates `report.html` in same directory as input.
+
+### Full Workflow
+
+```bash
+# 1. Classify emails
+python -m src.cli run \
+  --source local \
+  --directory "/path/to/emails" \
+  --output "/path/to/output" \
+  --no-llm-fallback
+
+# 2. Generate report
+python tools/generate_html_report.py \
+  --input "/path/to/output/results.json"
+```
+
+## results.json Format
+
+The report generator expects this structure:
+
+```json
+{
+  "metadata": {
+    "total_emails": 801,
+    "accuracy_estimate": 0.55,
+    "classification_stats": {
+      "rule_matched": 9,
+      "ml_classified": 468,
+      "llm_classified": 0,
+      "needs_review": 324
+    },
+    "generated_at": "2025-11-28T02:34:00.680196",
+    "source": "local",
+    "source_path": "/path/to/emails"
+  },
+  "classifications": [
+    {
+      "email_id": "unique_id.eml",
+      "subject": "Email subject line",
+      "sender": "sender@example.com",
+      "sender_name": "Sender Name",
+      "date": "2023-04-13T09:43:29+10:00",
+      "has_attachments": false,
+      "category": "Work",
+      "confidence": 0.81,
+      "method": "ml"
+    }
+  ]
+}
+```
+
+### Required Fields
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `email_id` | string | Unique identifier (usually filename) |
+| `subject` | string | Email subject line |
+| `sender` | string | Sender email address |
+| `category` | string | Assigned category |
+| `confidence` | float | Classification confidence (0-1) |
+| `method` | string | Classification method: `ml`, `rule`, or `llm` |
+
+### Optional Fields
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `sender_name` | string | Display name of sender |
+| `date` | string | ISO 8601 date string |
+| `has_attachments` | boolean | Whether email has attachments |
+
+## Report Sections
+
+### 1. Header
+- Report title
+- Generation timestamp
+- Source info
+- Total email count
+
+### 2. Stats Grid
+- Total emails
+- Number of categories
+- High confidence count (>=70%)
+- Unique sender domains
+
+### 3. Category Distribution
+- Horizontal bar chart
+- Count and percentage per category
+- Sorted by count (descending)
+
+### 4. Classification Methods
+- Breakdown of ML vs Rule vs LLM
+- Shows which method handled what percentage
+
+### 5. Confidence Distribution
+- High (>=70%): Green
+- Medium (50-70%): Yellow
+- Low (<50%): Red
+
+### 6. Top Senders
+- Top 20 senders by email count
+- Grid layout
+
+### 7. Email Tables (Tabbed)
+- "All" tab shows all emails
+- Category tabs filter by category
+- Search box filters by subject/sender
+- Columns: Date, Subject, Sender, Category, Confidence, Method
+- Sorted by date (newest first)
+- Attachment indicator (📎)
+
+## Customization
+
+### Changing Colors
+
+Edit the CSS variables in `generate_html_report.py`:
+
+```css
+:root {
+    --bg-primary: #1a1a2e;      /* Main background */
+    --bg-secondary: #16213e;    /* Card backgrounds */
+    --bg-card: #0f3460;         /* Nested elements */
+    --text-primary: #eee;       /* Main text */
+    --text-secondary: #aaa;     /* Muted text */
+    --accent: #e94560;          /* Accent color (red) */
+    --accent-hover: #ff6b6b;    /* Accent hover */
+    --success: #00d9a5;         /* Green (high confidence) */
+    --warning: #ffc107;         /* Yellow (medium confidence) */
+    --border: #2a2a4a;          /* Border color */
+}
+```
+
+### Light Theme Example
+
+```css
+:root {
+    --bg-primary: #f5f5f5;
+    --bg-secondary: #ffffff;
+    --bg-card: #e8e8e8;
+    --text-primary: #333;
+    --text-secondary: #666;
+    --accent: #2563eb;
+    --accent-hover: #3b82f6;
+    --success: #10b981;
+    --warning: #f59e0b;
+    --border: #d1d5db;
+}
+```
+
+### Adding New Sections
+
+1. Add data extraction in `generate_html_report()` function
+2. Add HTML section in the main template string
+3. Style with existing CSS classes or add new ones
+
+### Adding New Table Columns
+
+1. Modify `generate_email_row()` function
+2. Add `<th>` in table header
+3. Add `<td>` in row template
+
+## Performance Notes
+
+- Report is fully static (no server required)
+- JavaScript is minimal (tab switching, search filtering)
+- Handles 1000+ emails without performance issues
+- For 10k+ emails, consider pagination (not yet implemented)
+
+## Future Enhancements (TODO)
+
+- [ ] Pagination for large datasets
+- [ ] Export to PDF option
+- [ ] Configurable color themes via CLI
+- [ ] Column sorting (click headers)
+- [ ] Date range filter
+- [ ] Sender domain grouping
+- [ ] Category confidence heatmap
+- [ ] Email body preview on hover
+
+## Troubleshooting
+
+### "KeyError: 'subject'"
+Results.json lacks email metadata. Re-run classification with latest cli.py.
+
+### Empty tables
+Check that results.json has `classifications` array with data.
+
+### Dates showing "N/A"
+Date parsing failed. Check date format in results.json is ISO 8601.
+
+### Search not working
+JavaScript error. Check browser console. Ensure no HTML entities in data.

docs/SESSION_HANDOVER_20251128.md

@@ -0,0 +1,128 @@
+# Session Handover Report - Email Sorter
+**Date:** 2025-11-28
+**Session ID:** eb549838-a153-48d1-ae5d-891e0e83108f
+
+---
+
+## What Was Done This Session
+
+### 1. Classified 801 emails from brett-gmail using three methods:
+
+| Method | Accuracy | Time | Output Location |
+|--------|----------|------|-----------------|
+| ML-Only | 54.9% | ~5 sec | `/home/bob/Documents/Email Manager/emails/brett-gm-md/` |
+| ML+LLM | 93.3% | ~3.5 min | `/home/bob/Documents/Email Manager/emails/brett-gm-llm/` |
+| Manual Agent | 99.8% | ~25 min | Same as ML-only + analysis files |
+
+### 2. Created/Modified Files
+
+**New Files:**
+- `tools/generate_html_report.py` - HTML report generator
+- `tools/brett_gmail_analyzer.py` - Custom dataset analyzer
+- `data/brett_gmail_analysis.json` - Analysis output
+- `docs/REPORT_FORMAT.md` - Report system documentation
+- `docs/CLASSIFICATION_METHODS_COMPARISON.md` - Method comparison
+- `docs/PROJECT_ROADMAP_2025.md` - Full roadmap and learnings
+- `/home/bob/Documents/Email Manager/emails/brett-gm-md/BRETT_GMAIL_ANALYSIS_REPORT.md` - Analysis report
+- `/home/bob/Documents/Email Manager/emails/brett-gm-md/report.html` - HTML report (ML-only)
+- `/home/bob/Documents/Email Manager/emails/brett-gm-llm/report.html` - HTML report (ML+LLM)
+
+**Modified Files:**
+- `src/cli.py` - Added `--force-ml` flag, enriched results.json with email metadata
+- `src/llm/openai_compat.py` - Removed API key requirement for local vLLM
+- `config/default_config.yaml` - Changed LLM to openai provider on localhost:11433
+
+### 3. Key Configuration Changes
+
+```yaml
+# config/default_config.yaml - LLM now uses vLLM endpoint
+llm:
+  provider: "openai"
+  openai:
+    base_url: "http://localhost:11433/v1"
+    api_key: "not-needed"
+    classification_model: "qwen3-coder-30b"
+```
+
+---
+
+## Key Findings
+
+1. **ML pipeline overkill for <5000 emails** - Agent analysis gives better accuracy in similar time
+2. **Sender domain is strongest signal** - Top 5 senders = 47.5% of emails
+3. **Categories should serve downstream routing** - Not human labels, but processing decisions
+4. **Risk-based accuracy** - Personal emails need high accuracy, junk can tolerate errors
+5. **This tool = triage** - Sorts into buckets for other specialized tools
+
+---
+
+## Project Scope (Agreed with User)
+
+**Email Sorter IS:**
+- Bulk classification/triage tool
+- Router to downstream specialized tools
+- Part of larger email processing ecosystem
+
+**Email Sorter IS NOT:**
+- Complete email management solution
+- Spam filter (trust Gmail/Outlook)
+- Final destination for emails
+
+---
+
+## Recommended Dataset Size Routing
+
+| Size | Method |
+|------|--------|
+| <500 | Agent-only |
+| 500-5000 | Agent pre-scan + ML |
+| >5000 | ML pipeline |
+
+---
+
+## Background Processes
+
+There are stale background bash processes (f8678e, 0a3549, 0d150e) from classification runs. These completed successfully and can be ignored.
+
+---
+
+## What Needs Doing Next
+
+1. **Review docs/** - All learnings are in PROJECT_ROADMAP_2025.md
+2. **Phase 1 development** - Dataset size routing, sender-first classification
+3. **Agent pre-scan module** - 10-15 min discovery phase before ML
+
+---
+
+## User Preferences (from CLAUDE.md)
+
+- NO emojis in commits
+- NO "Generated with Claude" attribution
+- Use tools (Read/Edit/Grep) not bash commands for file ops
+- Virtual environment required for Python
+- TTS available via `fss-speak` (single line messages only, no newlines)
+
+---
+
+## Quick Start for Next Agent
+
+```bash
+cd /MASTERFOLDER/Tools/email-sorter
+source venv/bin/activate
+
+# Read the roadmap
+cat docs/PROJECT_ROADMAP_2025.md
+
+# Run classification
+python -m src.cli run --source local \
+  --directory "/path/to/emails" \
+  --output "/path/to/output" \
+  --force-ml --llm-provider openai
+
+# Generate HTML report
+python tools/generate_html_report.py --input /path/to/results.json
+```
+
+---
+
+*Session ended: 2025-11-28 ~03:30 AEDT*

scripts/experimental/spot_check_results.txt

@@ -0,0 +1,303 @@
+================================================================================
+SMART CLASSIFICATION SPOT-CHECK
+================================================================================
+
+Loading results from: results_100k/results.json
+Total emails: 100,000
+
+Analyzing classification patterns...
+Selected 30 emails for spot-checking
+
+  - high_conf_suspicious: 10 samples
+  - low_conf_obvious: 2 samples
+  - mid_conf_edge_cases: 0 samples
+  - category_anomalies: 8 samples
+  - random_check: 10 samples
+
+Loading email content...
+Loaded 100,000 emails
+
+================================================================================
+SPOT-CHECK SAMPLES
+================================================================================
+
+[1] HIGH CONFIDENCE - Potential Overconfidence
+--------------------------------------------------------------------------------
+These have very high confidence. Check if they're actually correct.
+
+Sample 1:
+  Category: Administrative
+  Confidence: 1.000
+  Method: ml
+  From: john.arnold@enron.com
+  Subject: RE:
+  Body preview: i'll get the movie and wine.  my suggestion is something from central market but i'm easy
+
+ -----Original Message-----
+From: 	Ward, Kim S (Houston)  
+Sent:	Monday, July 02, 2001 5:29 PM
+To:	Arnold, Jo...
+
+Sample 2:
+  Category: Administrative
+  Confidence: 1.000
+  Method: ml
+  From: eric.bass@enron.com
+  Subject: Re: New deals
+  Body preview: Can you spell S-N-O-O-T-Y?
+
+e
+
+
+   
+	
+	
+	From:  Ami Chokshi @ ENRON                           01/06/2000 05:38 PM
+	
+
+To: Eric Bass/HOU/ECT@ECT
+cc:  
+Subject: Re: New deals  
+
+Was E-R-I-C too hard to w...
+
+Sample 3:
+  Category: Meeting
+  Confidence: 1.000
+  Method: ml
+  From: amy.fitzpatrick@enron.com
+  Subject: MEETING TONIGHT - 6:00 pm Central Time at The Houstonian
+  Body preview: Throughout this week, we have a team from UBS in Houston to introduce and discuss the NETCO business and associated HR matters. 
+
+In this regard, please make yourself available for a meeting tonight b...
+
+Sample 4:
+  Category: Meeting
+  Confidence: 1.000
+  Method: ml
+  From: james.steffes@enron.com
+  Subject: 
+  Body preview: Jeff --
+
+Please add John Neslage to your e-mail list.
+
+Jim...
+
+Sample 5:
+  Category: Financial
+  Confidence: 1.000
+  Method: ml
+  From: sheri.thomas@enron.com
+  Subject: Fercinfo2 (The Whole Picture)
+  Body preview: Sally - just an fyi...  Jeff Hodge requested that we send him the information 
+below.  Evidently, the FERC has requested that several US wholesale companies 
+provide a great deal of information to the...
+
+[2] LOW CONFIDENCE - Might Be Obvious
+--------------------------------------------------------------------------------
+These have low confidence. Check if they're actually obvious.
+
+Sample 1:
+  Category: unknown
+  Confidence: 0.500
+  Method: llm
+  From: k..allen@enron.com
+  Subject: FW:
+  Body preview: Greg,
+
+After making an election in October to receive a full distribution of my deferral account under Section 6.3 of the plan, a disagreement has arisen regarding the Phantom Stock Account.  
+
+Se...
+
+Sample 2:
+  Category: unknown
+  Confidence: 0.500
+  Method: llm
+  From: mitch.robinson@enron.com
+  Subject: Running Units
+  Body preview: Given the sale, etc of the units, don't sell any power off the units, and 
+don't run the units (any of the six plants) for any reason without first 
+getting my specific permission.
+
+Thanks,
+
+Mitch...
+
+[3] MIDDLE CONFIDENCE - Edge Cases
+--------------------------------------------------------------------------------
+These are in the middle. Most likely to be tricky classifications.
+
+[4] CATEGORY ANOMALIES - Rare Categories with High Confidence
+--------------------------------------------------------------------------------
+These are high confidence but in small categories. Might be mislabeled.
+
+Sample 1:
+  Category: California Market
+  Confidence: 1.000
+  Method: ml
+  From: dhunter@s-k-w.com
+  Subject: FW: Direct Access Language
+  Body preview: -----Original Message-----
+From: Mike Florio [mailto:mflorio@turn.org]
+Sent: Tuesday, September 11, 2001 3:23 AM
+To: Delaney Hunter
+Subject: Direct Access Language
+
+
+Delaney--  DJ asked me to forward ...
+
+Sample 2:
+  Category: auth
+  Confidence: 0.990
+  Method: rule
+  From: david.roland@enron.com
+  Subject: FW: Notices and Agenda for Dec 21 ServiceCo Board Meeting
+  Body preview: Vicki, Dave, Mark and Jimmie,
+
+We're scheduling a pre-meeting to the ServiceCo Board meeting at 11:30 a.m. tomorrow (Friday) in Dave's office.
+
+Thanks,
+David
+
+
+ -----Original Message-----
+From: 	Rolan...
+
+Sample 3:
+  Category: transactional
+  Confidence: 0.970
+  Method: rule
+  From: orders@amazon.com
+  Subject: Cancellation from Amazon.com Order (#107-0663988-7584503)
+  Body preview: Greetings from Amazon.com.  You have successfully cancelled an item
+from your order #107-0663988-7584503
+
+For your reference, here is a summary of your order:
+
+
+Order #107-0663988-7584503 - placed Dec...
+
+Sample 4:
+  Category: Forwarded
+  Confidence: 1.000
+  Method: ml
+  From: jefferson.sorenson@enron.com
+  Subject: UNIFY TO SAP INTERFACES
+  Body preview: ---------------------- Forwarded by Jefferson D Sorenson/HOU/ECT on 
+07/05/2000 04:58 PM ---------------------------
+
+
+Bob Klein
+07/05/2000 04:57 PM
+To: Jefferson D Sorenson/HOU/ECT@ECT
+cc: Rebecca Fo...
+
+Sample 5:
+  Category: Urgent
+  Confidence: 1.000
+  Method: ml
+  From: l..garcia@enron.com
+  Subject: RE: LUNCH
+  Body preview: You Idiot! Why are you sending emails to people who wont get them (Reese, Dustin, Blaine, Greer, Reeves), and who the hell is AC? Mr. Huddle and the Horseman?????????????? Did you fall and hit your he...
+
+[5] RANDOM CHECK - General Quality Check
+--------------------------------------------------------------------------------
+Random samples from each category for general quality assessment.
+
+Sample 1:
+  Category: Administrative
+  Confidence: 1.000
+  Method: ml
+  From: cameron@perfect.com
+  Subject: RE: Directions
+  Body preview: I will send this out.  Yes, we can talk tonight.  When will you be at the
+house?
+
+
+Cameron Sellers
+Vice President, Business Development
+PERFECT
+1860 Embarcadero Road - Suite 210
+Palo Alto, CA 94303
+ca...
+
+Sample 2:
+  Category: Meeting
+  Confidence: 1.000
+  Method: ml
+  From: perfmgmt@enron.com
+  Subject: Mid-Year 2001 Performance Feedback
+  Body preview: DEAN, CLINT E,
+?
+You have been selected to participate in the Mid Year 2001 Performance 
+Management process.  Your feedback plays an important role in the process, 
+and your participation is critical ...
+
+Sample 3:
+  Category: Financial
+  Confidence: 1.000
+  Method: ml
+  From: schwabalerts.marketupdates@schwab.com
+  Subject: Midday Market View for June 7, 2001
+  Body preview: Charles Schwab & Co., Inc.
+
+Midday Market View(TM) for Thursday, June 7, 2001
+as of 1:00PM EDT
+Information provided by Standard & Poor's
+
+==============================================================...
+
+Sample 4:
+  Category: Work
+  Confidence: 1.000
+  Method: ml
+  From: enron.announcements@enron.com
+  Subject: SUPPLEMENTAL Weekend Outage Report for 11-10-00
+  Body preview: ------------------------------------------------------------------------------
+------------------------
+W E E K E N D   S Y S T E M S   A V A I L A B I L I T Y
+
+F O R
+
+November 10, 2000 5:00pm through...
+
+Sample 5:
+  Category: Operational
+  Confidence: 1.000
+  Method: ml
+  From: phillip.allen@enron.com
+  Subject: Re: Insight Hardware
+  Body preview: I have not received the aircard 300 yet.
+
+Phillip...
+
+================================================================================
+CATEGORY DISTRIBUTION
+================================================================================
+
+Category                Total  High Conf   Low Conf   Avg Conf
+--------------------------------------------------------------------------------
+Administrative         67,195     67,191          0      1.000
+Work                   14,223     14,213          0      1.000
+Meeting                 7,785      7,783          0      1.000
+Financial               5,943      5,943          0      1.000
+Operational             3,274      3,272          0      1.000
+junk                      394        394          0      0.960
+work                      368        368          0      0.950
+Miscellaneous             238        238          0      1.000
+Technical                 193        193          0      1.000
+External                  137        137          0      1.000
+Announcements             113        112          0      0.999
+transactional              44         44          0      0.970
+auth                       37         37          0      0.990
+unknown                    23          0         23      0.500
+Forwarded                  16         16          0      0.999
+California Market           6          6          0      1.000
+Prehearing                  6          6          0      0.974
+Change                      3          3          0      1.000
+Urgent                      1          1          0      1.000
+Monitoring                  1          1          0      1.000
+
+================================================================================
+DONE!
+================================================================================

scripts/run_clean_10k.sh

@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+# Clean 10k test with all fixes applied
+# Run this when ready: ./run_clean_10k.sh
+
+set -e
+
+echo "=========================================="
+echo "CLEAN 10K TEST - Fixed Category System"
+echo "=========================================="
+echo ""
+echo "Fixes applied:"
+echo "  ✓ Removed hardcoded category pollution"
+echo "  ✓ LLM-only category discovery"
+echo "  ✓ Intelligent scaling (3% cal, 1% val)"
+echo ""
+echo "Expected results:"
+echo "  - ~11 clean categories (not 29)"
+echo "  - No duplicates (Work vs work)"
+echo "  - Realistic confidence scores"
+echo ""
+echo "Starting at: $(date)"
+echo ""
+
+# Activate venv
+if [ -z "$VIRTUAL_ENV" ]; then
+    source venv/bin/activate
+fi
+
+# Clean start
+rm -rf results_10k/
+rm -f src/models/calibrated/classifier.pkl
+rm -f src/models/category_cache.json
+
+# Run with progress visible
+python -m src.cli run \
+    --source enron \
+    --limit 10000 \
+    --output results_10k/ \
+    --verbose
+
+echo ""
+echo "=========================================="
+echo "COMPLETE at: $(date)"
+echo "=========================================="
+echo ""
+echo "Check results:"
+echo "  - Categories: cat src/models/category_cache.json | python3 -m json.tool"
+echo "  - Model: ls -lh src/models/calibrated/"
+echo "  - Results: ls -lh results_10k/"
+echo ""

scripts/test_ml_only.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+# Test ML performance without LLM fallback using trained model
+
+set -e
+
+echo "=========================================="
+echo "ML-ONLY TEST (No LLM Fallback)"
+echo "=========================================="
+echo ""
+echo "Using model: src/models/calibrated/classifier.pkl"
+echo "Testing on: 1000 emails"
+echo ""
+
+# Activate venv
+if [ -z "$VIRTUAL_ENV" ]; then
+    source venv/bin/activate
+fi
+
+# Run classification with trained model, NO LLM fallback
+python -m src.cli run \
+    --source enron \
+    --limit 1000 \
+    --output ml_only_test/ \
+    --no-llm-fallback \
+    2>&1 | tee ml_only_test.log
+
+echo ""
+echo "=========================================="
+echo "Test complete. Check ml_only_test.log"
+echo "=========================================="

scripts/train_final_model.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+# Train final production model with 10k emails and 0.55 thresholds
+
+set -e
+
+echo "=========================================="
+echo "TRAINING FINAL MODEL"
+echo "=========================================="
+echo ""
+echo "Config: 0.55 thresholds across all categories"
+echo "Training set: 10,000 Enron emails"
+echo "Calibration: 300 samples (3%)"
+echo "Validation: 100 samples (1%)"
+echo ""
+
+# Backup existing model if it exists
+if [ -f src/models/calibrated/classifier.pkl ]; then
+    BACKUP_FILE="src/models/calibrated/classifier.pkl.backup-$(date +%Y%m%d-%H%M%S)"
+    cp src/models/calibrated/classifier.pkl "$BACKUP_FILE"
+    echo "Backed up existing model to: $BACKUP_FILE"
+fi
+
+# Clean old results
+rm -rf results_final/ final_training.log
+
+# Activate venv
+if [ -z "$VIRTUAL_ENV" ]; then
+    source venv/bin/activate
+fi
+
+# Train model
+python -m src.cli run \
+    --source enron \
+    --limit 10000 \
+    --output results_final/ \
+    2>&1 | tee final_training.log
+
+# Create timestamped backup of trained model
+if [ -f src/models/calibrated/classifier.pkl ]; then
+    TRAINED_BACKUP="src/models/calibrated/classifier.pkl.backup-trained-$(date +%Y%m%d-%H%M%S)"
+    cp src/models/calibrated/classifier.pkl "$TRAINED_BACKUP"
+    echo "Created backup of trained model: $TRAINED_BACKUP"
+fi
+
+echo ""
+echo "=========================================="
+echo "Training complete!"
+echo "Model saved to: src/models/calibrated/classifier.pkl"
+echo "Backup created with timestamp"
+echo "Log: final_training.log"
+echo "=========================================="

src/calibration/category_verifier.py

@@ -0,0 +1,190 @@
+"""Category verification for existing models on new mailboxes."""
+import logging
+import json
+import re
+import random
+from typing import List, Dict, Any
+
+from src.email_providers.base import Email
+from src.llm.base import BaseLLMProvider
+
+logger = logging.getLogger(__name__)
+
+
+def verify_model_categories(
+    emails: List[Email],
+    model_categories: List[str],
+    llm_provider: BaseLLMProvider,
+    sample_size: int = 20
+) -> Dict[str, Any]:
+    """
+    Verify if trained model categories fit a new mailbox.
+
+    Single LLM call to check if categories are appropriate.
+
+    Args:
+        emails: All emails from new mailbox
+        model_categories: Categories the model was trained on
+        llm_provider: LLM provider for verification
+        sample_size: Number of emails to sample for verification
+
+    Returns:
+        {
+            'verdict': 'GOOD_MATCH' | 'FAIR_MATCH' | 'POOR_MATCH',
+            'confidence': float (0-1),
+            'reasoning': str,
+            'suggested_categories': List[str] (if poor match),
+            'category_mapping': Dict[str, str] (suggested name changes)
+        }
+    """
+    logger.info(f"Verifying model categories against {len(emails)} emails")
+    logger.info(f"Model categories ({len(model_categories)}): {', '.join(model_categories)}")
+
+    # Sample random emails
+    sample = random.sample(emails, min(sample_size, len(emails)))
+    logger.info(f"Sampled {len(sample)} emails for verification")
+
+    # Build email summaries
+    email_summaries = []
+    for i, email in enumerate(sample[:20]):  # Limit to 20 to avoid token limits
+        summary = f"{i+1}. From: {email.sender}\n   Subject: {email.subject}\n   Preview: {email.body_snippet[:80]}..."
+        email_summaries.append(summary)
+
+    email_text = "\n\n".join(email_summaries)
+
+    # Build categories list
+    categories_text = "\n".join([f"  - {cat}" for cat in model_categories])
+
+    # Build verification prompt
+    prompt = f"""<no_think>You are evaluating whether pre-trained email categories fit a new mailbox.
+
+TRAINED MODEL CATEGORIES ({len(model_categories)} categories):
+{categories_text}
+
+SAMPLE EMAILS FROM NEW MAILBOX ({len(sample)} total, showing first {len(email_summaries)}):
+{email_text}
+
+TASK:
+Evaluate if the trained categories are appropriate for this mailbox.
+
+Consider:
+1. Do the sample emails naturally fit into the trained categories?
+2. Are there obvious email types that don't match any category?
+3. Are the category names semantically appropriate?
+4. Would a user find these categories helpful for THIS mailbox?
+
+Respond with JSON:
+{{
+  "verdict": "GOOD_MATCH" | "FAIR_MATCH" | "POOR_MATCH",
+  "confidence": 0.0-1.0,
+  "reasoning": "brief explanation",
+  "fit_percentage": 0-100,
+  "suggested_categories": ["cat1", "cat2", ...],  // Only if POOR_MATCH
+  "category_mapping": {{"old_name": "better_name", ...}}  // Optional renames
+}}
+
+Verdict criteria:
+- GOOD_MATCH: 80%+ of emails fit well, categories are appropriate
+- FAIR_MATCH: 60-80% fit, some gaps but usable
+- POOR_MATCH: <60% fit, significant category mismatch
+
+JSON:
+"""
+
+    try:
+        logger.info("Calling LLM for category verification...")
+        response = llm_provider.complete(
+            prompt,
+            temperature=0.1,
+            max_tokens=1000
+        )
+
+        logger.debug(f"LLM verification response: {response[:500]}")
+
+        # Parse response
+        result = _parse_verification_response(response)
+
+        logger.info(f"Verification complete: {result['verdict']} ({result['confidence']:.0%})")
+        if result.get('reasoning'):
+            logger.info(f"Reasoning: {result['reasoning']}")
+
+        return result
+
+    except Exception as e:
+        logger.error(f"Verification failed: {e}")
+        # Return conservative default
+        return {
+            'verdict': 'FAIR_MATCH',
+            'confidence': 0.5,
+            'reasoning': f'Verification failed: {e}',
+            'fit_percentage': 50,
+            'suggested_categories': [],
+            'category_mapping': {}
+        }
+
+
+def _parse_verification_response(response: str) -> Dict[str, Any]:
+    """Parse LLM verification response."""
+    try:
+        # Strip think tags
+        cleaned = re.sub(r'<think>.*?</think>', '', response, flags=re.DOTALL)
+
+        # Extract JSON
+        json_match = re.search(r'\{.*\}', cleaned, re.DOTALL)
+        if json_match:
+            # Find complete JSON by counting braces
+            brace_count = 0
+            for i, char in enumerate(cleaned):
+                if char == '{':
+                    brace_count += 1
+                    if brace_count == 1:
+                        start = i
+                elif char == '}':
+                    brace_count -= 1
+                    if brace_count == 0:
+                        json_str = cleaned[start:i+1]
+                        break
+
+            parsed = json.loads(json_str)
+
+            # Validate and set defaults
+            result = {
+                'verdict': parsed.get('verdict', 'FAIR_MATCH'),
+                'confidence': float(parsed.get('confidence', 0.5)),
+                'reasoning': parsed.get('reasoning', ''),
+                'fit_percentage': int(parsed.get('fit_percentage', 50)),
+                'suggested_categories': parsed.get('suggested_categories', []),
+                'category_mapping': parsed.get('category_mapping', {})
+            }
+
+            # Validate verdict
+            if result['verdict'] not in ['GOOD_MATCH', 'FAIR_MATCH', 'POOR_MATCH']:
+                logger.warning(f"Invalid verdict: {result['verdict']}, defaulting to FAIR_MATCH")
+                result['verdict'] = 'FAIR_MATCH'
+
+            # Clamp confidence
+            result['confidence'] = max(0.0, min(1.0, result['confidence']))
+
+            return result
+
+    except json.JSONDecodeError as e:
+        logger.warning(f"JSON parse error: {e}")
+    except Exception as e:
+        logger.warning(f"Parse error: {e}")
+
+    # Fallback parsing - try to extract verdict from text
+    verdict = 'FAIR_MATCH'
+    if 'GOOD_MATCH' in response or 'good match' in response.lower():
+        verdict = 'GOOD_MATCH'
+    elif 'POOR_MATCH' in response or 'poor match' in response.lower():
+        verdict = 'POOR_MATCH'
+
+    logger.warning(f"Using fallback parsing, verdict: {verdict}")
+    return {
+        'verdict': verdict,
+        'confidence': 0.5,
+        'reasoning': 'Fallback parsing - response format invalid',
+        'fit_percentage': 50,
+        'suggested_categories': [],
+        'category_mapping': {}
+    }

src/calibration/llm_analyzer.py

@@ -90,8 +90,10 @@ class CalibrationAnalyzer:
         # Step 2: Consolidate overlapping/duplicate categories
         if len(discovered_categories) > 10:  # Only consolidate if too many categories
             logger.info(f"Consolidating {len(discovered_categories)} categories...")
-            consolidated = self._consolidate_categories(discovered_categories, email_labels)
+            # Use consolidation LLM if provided (larger model for structured output)
-            if len(consolidated) < len(discovered_categories):
+            consolidation_llm = self.config.get('consolidation_llm', self.llm_provider)
+            consolidated = self._consolidate_categories(discovered_categories, email_labels, llm_provider=consolidation_llm)
+            if consolidated and len(consolidated) < len(discovered_categories):
                 discovered_categories = consolidated
                 logger.info(f"After consolidation: {len(discovered_categories)} categories")
             else:
@@ -202,17 +204,6 @@ GUIDELINES FOR GOOD CATEGORIES:
 - FUNCTIONAL: Each category serves a distinct purpose
 - 3-10 categories ideal: Too many = noise, too few = useless
 
-{stats_summary}
-
-EMAILS TO ANALYZE:
-{email_summary}
-
-TASK:
-1. Identify natural groupings based on PURPOSE, not just topic
-2. Create SHORT (1-3 word) category names
-3. Assign each email to exactly one category
-4. CRITICAL: Copy EXACT email IDs - if email #1 shows ID "{example_id}", use exactly "{example_id}" in labels
-
 EXAMPLES OF GOOD CATEGORIES:
 - "Work Communication" (daily business emails)
 - "Financial" (invoices, budgets, reports)
@@ -220,12 +211,26 @@ EXAMPLES OF GOOD CATEGORIES:
 - "Technical" (system alerts, dev discussions)
 - "Administrative" (HR, policies, announcements)
 
+TASK:
+1. Identify natural groupings based on PURPOSE, not just topic
+2. Create SHORT (1-3 word) category names
+3. Assign each email to exactly one category
+4. CRITICAL: Copy EXACT email IDs - if email #1 shows ID "{example_id}", use exactly "{example_id}" in labels
+
+OUTPUT FORMAT:
 Return JSON:
 {{
   "categories": {{"category_name": "what user need this serves", ...}},
   "labels": [["{example_id}", "category"], ...]
 }}
 
+BATCH DATA TO ANALYZE:
+
+{stats_summary}
+
+EMAILS TO ANALYZE:
+{email_summary}
+
 JSON:
 """
 
@@ -265,10 +270,28 @@ JSON:
             # Strip <think> tags if present
             cleaned = re.sub(r'<think>.*?</think>', '', response, flags=re.DOTALL)
 
-            # Extract JSON
+            # Stop at endoftext token if present
-            json_match = re.search(r'\{.*\}', cleaned, re.DOTALL)
+            if '<|endoftext|>' in cleaned:
+                cleaned = cleaned.split('<|endoftext|>')[0]
+
+            # Extract JSON - use non-greedy match and stop at first valid JSON
+            json_match = re.search(r'\{.*?\}', cleaned, re.DOTALL)
             if json_match:
-                parsed = json.loads(json_match.group())
+                json_str = json_match.group()
+                # Try to find the complete JSON by counting braces
+                brace_count = 0
+                for i, char in enumerate(cleaned):
+                    if char == '{':
+                        brace_count += 1
+                        if brace_count == 1:
+                            start = i
+                    elif char == '}':
+                        brace_count -= 1
+                        if brace_count == 0:
+                            json_str = cleaned[start:i+1]
+                            break
+
+                parsed = json.loads(json_str)
                 logger.debug(f"Successfully parsed JSON: {len(parsed.get('categories', {}))} categories, {len(parsed.get('labels', []))} labels")
                 return parsed
         except json.JSONDecodeError as e:
@@ -281,7 +304,8 @@ JSON:
     def _consolidate_categories(
         self,
         discovered_categories: Dict[str, str],
-        email_labels: List[Tuple[str, str]]
+        email_labels: List[Tuple[str, str]],
+        llm_provider=None
     ) -> Dict[str, str]:
         """
         Consolidate overlapping/duplicate categories using LLM.
@@ -379,7 +403,7 @@ when semantically appropriate to maintain cross-mailbox consistency.
 
         rules_text = "\n".join(rules)
 
-        # Build prompt
+        # Build prompt - optimized for caching (static instructions first)
         prompt = f"""<no_think>You are helping build an email classification system that will automatically sort thousands of emails.
 
 TASK: Consolidate the discovered categories below into a lean, effective set for training a machine learning classifier.
@@ -398,10 +422,7 @@ WHAT MAKES GOOD CATEGORIES:
 - TIMELESS: "Financial Reports" not "2023 Budget Review"
 - ACTION-ORIENTED: Users ask "show me all X" - what is X?
 
-DISCOVERED CATEGORIES (sorted by email count):
+CONSOLIDATION STRATEGY:
-{category_list}
-
-{context_section}CONSOLIDATION STRATEGY:
 {rules_text}
 
 THINK LIKE A USER: If you had to sort 10,000 emails, what categories would help you find things fast?
@@ -426,11 +447,17 @@ CRITICAL REQUIREMENTS:
 - Final category names must be SHORT (1-3 words), GENERIC, and REUSABLE
 - Think: "Would this category still make sense in 5 years?"
 
+DISCOVERED CATEGORIES TO CONSOLIDATE (sorted by email count):
+{category_list}
+
+{context_section}
 JSON:
 """
 
         try:
-            response = self.llm_provider.complete(
+            # Use provided LLM or fall back to self.llm_provider
+            provider = llm_provider or self.llm_provider
+            response = provider.complete(
                 prompt,
                 temperature=temperature,
                 max_tokens=3000

src/calibration/local_file_parser.py

@@ -0,0 +1,266 @@
+"""Parse local email files (.msg and .eml formats)."""
+import logging
+import email.message
+import email.parser
+from pathlib import Path
+from typing import List, Optional
+from datetime import datetime
+from email.utils import parsedate_to_datetime
+import extract_msg
+
+from src.email_providers.base import Email, Attachment
+
+logger = logging.getLogger(__name__)
+
+
+class LocalFileParser:
+    """
+    Parse local email files in .msg (Outlook) and .eml formats.
+
+    Supports:
+    - Single directory with email files
+    - Nested directory structure
+    - Mixed .msg and .eml files
+    """
+
+    def __init__(self, directory_path: str):
+        """Initialize local file parser."""
+        self.directory_path = Path(directory_path)
+
+        if not self.directory_path.exists():
+            raise ValueError(f"Directory path not found: {self.directory_path}")
+
+        if not self.directory_path.is_dir():
+            raise ValueError(f"Path is not a directory: {self.directory_path}")
+
+        logger.info(f"Initialized local file parser: {self.directory_path}")
+
+    def parse_emails(self, limit: Optional[int] = None) -> List[Email]:
+        """
+        Parse emails from directory (including subdirectories).
+
+        Args:
+            limit: Maximum number of emails to parse
+
+        Returns:
+            List of Email objects
+        """
+        emails = []
+        email_count = 0
+
+        logger.info(f"Starting local file parsing (limit: {limit})")
+
+        # Find all .msg and .eml files recursively
+        msg_files = list(self.directory_path.rglob("*.msg"))
+        eml_files = list(self.directory_path.rglob("*.eml"))
+
+        all_files = sorted(msg_files + eml_files)
+
+        logger.info(f"Found {len(msg_files)} .msg files and {len(eml_files)} .eml files")
+
+        for email_file in all_files:
+            try:
+                if email_file.suffix.lower() == '.msg':
+                    parsed_email = self._parse_msg_file(email_file)
+                elif email_file.suffix.lower() == '.eml':
+                    parsed_email = self._parse_eml_file(email_file)
+                else:
+                    continue
+
+                if parsed_email:
+                    emails.append(parsed_email)
+                    email_count += 1
+
+                    if limit and email_count >= limit:
+                        logger.info(f"Reached limit: {email_count} emails parsed")
+                        return emails
+
+                    if email_count % 100 == 0:
+                        logger.info(f"Progress: {email_count} emails parsed")
+
+            except Exception as e:
+                logger.debug(f"Error parsing {email_file}: {e}")
+
+        logger.info(f"Parsing complete: {email_count} emails")
+        return emails
+
+    def _parse_msg_file(self, filepath: Path) -> Optional[Email]:
+        """Parse Outlook .msg file using extract-msg."""
+        try:
+            msg = extract_msg.Message(str(filepath))
+
+            # Extract basic info
+            msg_id = str(filepath).replace('/', '_').replace('\\', '_')
+            subject = msg.subject or 'No Subject'
+            sender = msg.sender or ''
+            sender_name = None  # extract-msg doesn't provide senderName attribute
+
+            # Parse date
+            date = None
+            if msg.date:
+                try:
+                    # extract-msg returns datetime object
+                    if isinstance(msg.date, datetime):
+                        date = msg.date
+                    else:
+                        # Try parsing string
+                        date = parsedate_to_datetime(str(msg.date))
+                except Exception:
+                    pass
+
+            # Extract body
+            body = msg.body or ""
+            body_snippet = body[:500] if body else ""
+
+            # Extract attachments
+            attachments = []
+            has_attachments = False
+            if msg.attachments:
+                has_attachments = True
+                for att in msg.attachments:
+                    try:
+                        attachments.append(Attachment(
+                            filename=att.longFilename or att.shortFilename or "unknown",
+                            mime_type=att.mimetype or "application/octet-stream",
+                            size=len(att.data) if att.data else 0
+                        ))
+                    except Exception:
+                        pass
+
+            # Get relative folder path
+            rel_path = filepath.relative_to(self.directory_path)
+            folder_name = str(rel_path.parent) if rel_path.parent != Path('.') else 'root'
+
+            msg.close()
+
+            return Email(
+                id=msg_id,
+                subject=subject,
+                sender=sender,
+                sender_name=sender_name,
+                date=date,
+                body=body,
+                body_snippet=body_snippet,
+                has_attachments=has_attachments,
+                attachments=attachments,
+                provider='local_msg',
+                headers={'X-Folder': folder_name, 'X-File': str(filepath)}
+            )
+
+        except Exception as e:
+            logger.debug(f"Error parsing MSG file {filepath}: {e}")
+            return None
+
+    def _parse_eml_file(self, filepath: Path) -> Optional[Email]:
+        """Parse .eml file using Python email library."""
+        try:
+            with open(filepath, 'rb') as f:
+                msg = email.message_from_bytes(f.read())
+
+            # Get relative folder path
+            rel_path = filepath.relative_to(self.directory_path)
+            folder_name = str(rel_path.parent) if rel_path.parent != Path('.') else 'root'
+
+            # Extract basic info
+            msg_id = str(filepath).replace('/', '_').replace('\\', '_')
+            subject = msg.get('subject', 'No Subject')
+            sender = msg.get('from', '')
+            date_str = msg.get('date')
+
+            # Parse sender name if available
+            sender_name = None
+            if sender:
+                try:
+                    from email.utils import parseaddr
+                    name, addr = parseaddr(sender)
+                    if name:
+                        sender_name = name
+                        sender = addr
+                except Exception:
+                    pass
+
+            # Parse date
+            date = None
+            if date_str:
+                try:
+                    date = parsedate_to_datetime(date_str)
+                except Exception:
+                    pass
+
+            # Extract body
+            body = self._extract_body(msg)
+            body_snippet = body[:500] if body else ""
+
+            # Extract attachments
+            attachments = []
+            has_attachments = self._has_attachments(msg)
+            if has_attachments:
+                for part in msg.walk():
+                    if part.get_content_disposition() == 'attachment':
+                        filename = part.get_filename()
+                        if filename:
+                            try:
+                                attachments.append(Attachment(
+                                    filename=filename,
+                                    mime_type=part.get_content_type(),
+                                    size=len(part.get_payload(decode=True) or b'')
+                                ))
+                            except Exception:
+                                pass
+
+            return Email(
+                id=msg_id,
+                subject=subject,
+                sender=sender,
+                sender_name=sender_name,
+                date=date,
+                body=body,
+                body_snippet=body_snippet,
+                has_attachments=has_attachments,
+                attachments=attachments,
+                provider='local_eml',
+                headers={'X-Folder': folder_name, 'X-File': str(filepath)}
+            )
+
+        except Exception as e:
+            logger.debug(f"Error parsing EML file {filepath}: {e}")
+            return None
+
+    def _extract_body(self, msg: email.message.Message) -> str:
+        """Extract email body from EML message."""
+        body = ""
+
+        if msg.is_multipart():
+            for part in msg.walk():
+                if part.get_content_type() == 'text/plain':
+                    try:
+                        payload = part.get_payload(decode=True)
+                        if payload:
+                            body = payload.decode('utf-8', errors='ignore')
+                            break
+                    except Exception:
+                        pass
+        else:
+            try:
+                payload = msg.get_payload(decode=True)
+                if payload:
+                    body = payload.decode('utf-8', errors='ignore')
+                else:
+                    body = msg.get_payload(decode=False)
+                    if isinstance(body, str):
+                        pass
+                    else:
+                        body = str(body)
+            except Exception:
+                pass
+
+        return body.strip() if isinstance(body, str) else ""
+
+    def _has_attachments(self, msg: email.message.Message) -> bool:
+        """Check if EML message has attachments."""
+        if msg.is_multipart():
+            for part in msg.walk():
+                if part.get_content_disposition() == 'attachment':
+                    if part.get_filename():
+                        return True
+        return False

src/calibration/trainer.py

@@ -102,6 +102,7 @@ class ModelTrainer:
 
         # Optional validation data
         eval_set = None
+        val_names = None
         if validation_emails:
             logger.info(f"Preparing validation set with {len(validation_emails)} emails")
             X_val_list = []
@@ -120,7 +121,8 @@ class ModelTrainer:
             if X_val_list:
                 X_val = np.array(X_val_list)
                 y_val = np.array(y_val_list)
-                eval_set = [(lgb.Dataset(X_val, label=y_val, reference=train_data), 'valid')]
+                eval_set = [lgb.Dataset(X_val, label=y_val, reference=train_data)]
+                val_names = ['valid']
 
         # Train model
         logger.info("Training LightGBM classifier...")
@@ -136,7 +138,7 @@ class ModelTrainer:
             'bagging_fraction': 0.8,
             'bagging_freq': 5,
             'verbose': -1,
-            'num_threads': -1
+            'num_threads': 28
         }
 
         self.model = lgb.train(
@@ -144,9 +146,9 @@ class ModelTrainer:
             train_data,
             num_boost_round=n_estimators,
             valid_sets=eval_set,
-            valid_names=['valid'] if eval_set else None,
+            valid_names=val_names,
             callbacks=[
-                lgb.log_evaluation(logger, period=50) if eval_set else None,
+                lgb.log_evaluation(period=50)
             ] if eval_set else None
         )
 

src/calibration/workflow.py

@@ -41,16 +41,22 @@ class CalibrationWorkflow:
         llm_provider: BaseLLMProvider,
         feature_extractor: FeatureExtractor,
         categories: Dict[str, Dict],
-        config: CalibrationConfig = None
+        config: CalibrationConfig = None,
+        consolidation_llm_provider: BaseLLMProvider = None
     ):
         """Initialize calibration workflow."""
         self.llm_provider = llm_provider
+        self.consolidation_llm_provider = consolidation_llm_provider or llm_provider
         self.feature_extractor = feature_extractor
         self.categories = list(categories.keys())
         self.config = config or CalibrationConfig()
 
         self.sampler = EmailSampler()
-        self.analyzer = CalibrationAnalyzer(llm_provider, {}, embedding_model=feature_extractor.embedder)
+        self.analyzer = CalibrationAnalyzer(
+            llm_provider,
+            {'consolidation_llm': self.consolidation_llm_provider},
+            embedding_model=feature_extractor.embedder
+        )
         self.trainer = ModelTrainer(feature_extractor, self.categories)
 
         self.results = {}
@@ -98,9 +104,12 @@ class CalibrationWorkflow:
         # Create lookup for LLM labels
         label_map = {email_id: category for email_id, category in sample_labels}
 
-        # Update categories to include discovered ones
+        # Use ONLY LLM-discovered categories for training
-        all_categories = list(set(self.categories) | set(discovered_categories.keys()))
+        # DO NOT merge self.categories (hardcoded) - those are for rule-based matching only
-        logger.info(f"Using categories: {all_categories}")
+        label_categories = set(category for _, category in sample_labels)
+        all_categories = list(set(discovered_categories.keys()) | label_categories)
+        logger.info(f"Using categories (LLM-discovered): {all_categories}")
+        logger.info(f"Categories count: {len(all_categories)}")
 
         # Update trainer with discovered categories
         self.trainer.categories = all_categories
@@ -140,10 +149,10 @@ class CalibrationWorkflow:
 
         # Prepare validation data
         validation_data = []
+        # Use first discovered category as default for validation
+        default_category = all_categories[0] if all_categories else 'unknown'
         for email in validation_emails:
-            # Use LLM to label validation set (or use heuristics)
+            validation_data.append((email, default_category))
-            # For now, use first category as default
-            validation_data.append((email, self.categories[0]))
 
         try:
             train_results = self.trainer.train(

src/classification/adaptive_classifier.py

@@ -68,7 +68,8 @@ class AdaptiveClassifier:
         ml_classifier: MLClassifier,
         llm_classifier: Optional[LLMClassifier],
         categories: Dict[str, Dict],
-        config: Dict[str, Any]
+        config: Dict[str, Any],
+        disable_llm_fallback: bool = False
     ):
         """Initialize adaptive classifier."""
         self.feature_extractor = feature_extractor
@@ -76,6 +77,7 @@ class AdaptiveClassifier:
         self.llm_classifier = llm_classifier
         self.categories = categories
         self.config = config
+        self.disable_llm_fallback = disable_llm_fallback
 
         self.thresholds = self._init_thresholds()
         self.stats = ClassificationStats()
@@ -85,10 +87,10 @@ class AdaptiveClassifier:
         thresholds = {}
 
         for category, cat_config in self.categories.items():
-            threshold = cat_config.get('threshold', 0.75)
+            threshold = cat_config.get('threshold', 0.55)
             thresholds[category] = threshold
 
-        default = self.config.get('classification', {}).get('default_threshold', 0.75)
+        default = self.config.get('classification', {}).get('default_threshold', 0.55)
         thresholds['default'] = default
 
         logger.info(f"Initialized thresholds: {thresholds}")
@@ -143,9 +145,105 @@ class AdaptiveClassifier:
                     probabilities=ml_result.get('probabilities', {})
                 )
             else:
-                # Low confidence: Queue for LLM
+                # Low confidence: Queue for LLM (unless disabled)
                 logger.debug(f"Low confidence for {email.id}: {category} ({confidence:.2f})")
                 self.stats.needs_review += 1
+
+                if self.disable_llm_fallback:
+                    # Just return ML result without LLM fallback
+                    return ClassificationResult(
+                        email_id=email.id,
+                        category=category,
+                        confidence=confidence,
+                        method='ml',
+                        needs_review=False,
+                        probabilities=ml_result.get('probabilities', {})
+                    )
+                else:
+                    return ClassificationResult(
+                        email_id=email.id,
+                        category=category,
+                        confidence=confidence,
+                        method='ml',
+                        needs_review=True,
+                        probabilities=ml_result.get('probabilities', {})
+                    )
+
+        except Exception as e:
+            logger.error(f"Classification error for {email.id}: {e}")
+            return ClassificationResult(
+                email_id=email.id,
+                category='unknown',
+                confidence=0.0,
+                method='error',
+                error=str(e)
+            )
+
+    def classify_with_features(self, email: Email, features: Dict[str, Any]) -> ClassificationResult:
+        """
+        Classify email using pre-extracted features (for batched processing).
+
+        Args:
+            email: Email object
+            features: Pre-extracted features from extract_batch()
+
+        Returns:
+            Classification result
+        """
+        self.stats.total_emails += 1
+
+        # Step 1: Try hard rules
+        rule_result = self._try_hard_rules(email)
+        if rule_result:
+            self.stats.rule_matched += 1
+            return rule_result
+
+        # Step 2: ML classification with pre-extracted embedding
+        try:
+            ml_result = self.ml_classifier.predict(features.get('embedding'))
+
+            if not ml_result or ml_result.get('error'):
+                logger.warning(f"ML classification error for {email.id}")
+                return ClassificationResult(
+                    email_id=email.id,
+                    category='unknown',
+                    confidence=0.0,
+                    method='error',
+                    error='ML classification failed'
+                )
+
+            category = ml_result.get('category', 'unknown')
+            confidence = ml_result.get('confidence', 0.0)
+
+            # Check if above threshold
+            threshold = self.thresholds.get(category, self.thresholds['default'])
+
+            if confidence >= threshold:
+                # High confidence: Accept ML classification
+                self.stats.ml_classified += 1
+                return ClassificationResult(
+                    email_id=email.id,
+                    category=category,
+                    confidence=confidence,
+                    method='ml',
+                    probabilities=ml_result.get('probabilities', {})
+                )
+            else:
+                # Low confidence: Queue for LLM (unless disabled)
+                logger.debug(f"Low confidence for {email.id}: {category} ({confidence:.2f})")
+                self.stats.needs_review += 1
+
+                if self.disable_llm_fallback:
+                    # Just return ML result without LLM fallback
+                    return ClassificationResult(
+                        email_id=email.id,
+                        category=category,
+                        confidence=confidence,
+                        method='ml',
+                        needs_review=False,
+                        probabilities=ml_result.get('probabilities', {})
+                    )
+                else:
                     return ClassificationResult(
                         email_id=email.id,
                         category=category,

src/classification/feature_extractor.py

@@ -230,6 +230,57 @@ class FeatureExtractor:
 
         return features
 
+    def extract_batch(self, emails: List[Email], batch_size: int = 512) -> List[Dict[str, Any]]:
+        """
+        Extract features from multiple emails with batched embeddings.
+
+        Much faster than calling extract() in a loop because embeddings are batched.
+        """
+        if not emails:
+            return []
+
+        # Extract all non-embedding features first
+        all_features = []
+        texts_to_embed = []
+
+        for email in emails:
+            features = {}
+            features['subject'] = email.subject
+            features['body_snippet'] = email.body_snippet
+            features['full_body'] = email.body
+            features.update(self._extract_structural(email))
+            features.update(self._extract_sender(email))
+            features.update(self._extract_patterns(email))
+            all_features.append(features)
+            texts_to_embed.append(self._build_embedding_text(email))
+
+        # Batch embed all texts
+        if self.embedder:
+            try:
+                # Process in batches
+                embeddings = []
+                for i in range(0, len(texts_to_embed), batch_size):
+                    batch = texts_to_embed[i:i + batch_size]
+                    response = self.embedder.embed(
+                        model='all-minilm:l6-v2',
+                        input=batch
+                    )
+                    embeddings.extend(response['embeddings'])
+
+                # Add embeddings to features
+                for features, embedding in zip(all_features, embeddings):
+                    features['embedding'] = np.array(embedding, dtype=np.float32)
+
+            except Exception as e:
+                logger.error(f"Batch embedding failed: {e}, falling back to zeros")
+                for features in all_features:
+                    features['embedding'] = np.zeros(384)
+        else:
+            for features in all_features:
+                features['embedding'] = np.zeros(384)
+
+        return all_features
+
     def _extract_embedding(self, email: Email) -> np.ndarray:
         """
         Generate semantic embedding for email using Ollama.
@@ -244,12 +295,12 @@ class FeatureExtractor:
             # Build structured text for embedding
             text = self._build_embedding_text(email)
 
-            # Get embedding from Ollama
+            # Get embedding from Ollama (use new embed API)
-            response = self.embedder.embeddings(
+            response = self.embedder.embed(
                 model='all-minilm:l6-v2',
-                prompt=text
+                input=text
             )
-            embedding = np.array(response['embedding'], dtype=np.float32)
+            embedding = np.array(response['embeddings'][0], dtype=np.float32)
             return embedding
         except Exception as e:
             logger.error(f"Error generating embedding: {e}")
@@ -281,27 +332,6 @@ body: {email.body_snippet[:300]}
 """
         return text
 
-    def extract_batch(self, emails: List[Email]) -> Optional[Any]:
-        """Extract features from batch of emails."""
-        if not pd:
-            logger.error("pandas not available for batch extraction")
-            return None
-
-        try:
-            feature_dicts = []
-            for email in emails:
-                features = self.extract(email)
-                feature_dicts.append(features)
-
-            # Convert to DataFrame
-            df = pd.DataFrame(feature_dicts)
-            logger.info(f"Extracted features for {len(df)} emails ({df.shape[1]} features)")
-            return df
-
-        except Exception as e:
-            logger.error(f"Error in batch extraction: {e}")
-            return None
-
     def fit_text_vectorizer(self, emails: List[Email]) -> bool:
         """Fit TF-IDF vectorizer on email corpus."""
         if not self.text_vectorizer:

src/classification/llm_classifier.py

@@ -45,26 +45,33 @@ class LLMClassifier:
         except FileNotFoundError:
             pass
 
-        # Default prompt
+        # Default prompt - optimized for caching (static instructions first)
         return """You are an expert email classifier. Analyze the email and classify it.
 
-CATEGORIES:
+INSTRUCTIONS:
-{categories}
+- Review the email content and available categories below
-
+- Select the single most appropriate category
-EMAIL:
+- Provide confidence score (0.0 to 1.0)
-Subject: {subject}
+- Give brief reasoning for your classification
-From: {sender}
-Has Attachments: {has_attachments}
-Body (first 300 chars): {body_snippet}
-
-ML Prediction: {ml_prediction} (confidence: {ml_confidence:.2f})
 
+OUTPUT FORMAT:
 Respond with ONLY valid JSON (no markdown, no extra text):
 {{
   "category": "category_name",
   "confidence": 0.95,
   "reasoning": "brief reason"
 }}
+
+CATEGORIES:
+{categories}
+
+EMAIL TO CLASSIFY:
+Subject: {subject}
+From: {sender}
+Has Attachments: {has_attachments}
+Body (first 300 chars): {body_snippet}
+
+ML Prediction: {ml_prediction} (confidence: {ml_confidence:.2f})
 """
 
     def classify(self, email: Dict[str, Any]) -> Dict[str, Any]:

src/cli.py

@@ -12,6 +12,8 @@ from src.email_providers.base import MockProvider
 from src.email_providers.gmail import GmailProvider
 from src.email_providers.imap import IMAPProvider
 from src.email_providers.enron import EnronProvider
+from src.email_providers.outlook import OutlookProvider
+from src.email_providers.local_file import LocalFileProvider
 from src.classification.feature_extractor import FeatureExtractor
 from src.classification.ml_classifier import MLClassifier
 from src.classification.llm_classifier import LLMClassifier
@@ -27,10 +29,12 @@ def cli():
 
 
 @cli.command()
-@click.option('--source', type=click.Choice(['gmail', 'imap', 'mock', 'enron']), default='mock',
+@click.option('--source', type=click.Choice(['gmail', 'outlook', 'imap', 'mock', 'enron', 'local']), default='mock',
               help='Email provider')
 @click.option('--credentials', type=click.Path(exists=False),
               help='Path to credentials file')
+@click.option('--directory', type=click.Path(exists=True),
+              help='Directory path for local file provider (.msg/.eml files)')
 @click.option('--output', type=click.Path(), default='results/',
               help='Output directory')
 @click.option('--config', type=click.Path(exists=False), default='config/default_config.yaml',
@@ -43,15 +47,28 @@ def cli():
               help='Do not sync results back')
 @click.option('--verbose', is_flag=True,
               help='Verbose logging')
+@click.option('--no-llm-fallback', is_flag=True,
+              help='Disable LLM fallback - test pure ML performance')
+@click.option('--verify-categories', is_flag=True,
+              help='Verify model categories fit new mailbox (single LLM call)')
+@click.option('--verify-sample', type=int, default=20,
+              help='Number of emails to sample for category verification')
+@click.option('--force-ml', is_flag=True,
+              help='Force use of existing ML model regardless of dataset size')
 def run(
     source: str,
     credentials: Optional[str],
+    directory: Optional[str],
     output: str,
     config: str,
     limit: Optional[int],
     llm_provider: str,
     dry_run: bool,
-    verbose: bool
+    verbose: bool,
+    no_llm_fallback: bool,
+    verify_categories: bool,
+    verify_sample: int,
+    force_ml: bool
 ):
     """Run email sorter pipeline."""
 
@@ -76,6 +93,11 @@ def run(
         if not credentials:
             logger.error("Gmail provider requires --credentials")
             sys.exit(1)
+    elif source == 'outlook':
+        provider = OutlookProvider()
+        if not credentials:
+            logger.error("Outlook provider requires --credentials")
+            sys.exit(1)
     elif source == 'imap':
         provider = IMAPProvider()
         if not credentials:
@@ -84,6 +106,12 @@ def run(
     elif source == 'enron':
         provider = EnronProvider(maildir_path=".")
         credentials = None
+    elif source == 'local':
+        if not directory:
+            logger.error("Local file provider requires --directory")
+            sys.exit(1)
+        provider = LocalFileProvider(directory_path=directory)
+        credentials = None
     else:  # mock
         logger.warning("Using MOCK provider for testing")
         provider = MockProvider()
@@ -125,7 +153,8 @@ def run(
         ml_classifier,
         llm_classifier,
         categories,
-        cfg.dict()
+        cfg.dict(),
+        disable_llm_fallback=no_llm_fallback
     )
 
     # Fetch emails
@@ -138,33 +167,98 @@ def run(
 
     logger.info(f"Fetched {len(emails)} emails")
 
+    # Category verification (if requested and model exists)
+    if verify_categories and not ml_classifier.is_mock and ml_classifier.model:
+        logger.info("=" * 80)
+        logger.info("VERIFYING MODEL CATEGORIES")
+        logger.info("=" * 80)
+
+        from src.calibration.category_verifier import verify_model_categories
+
+        verification_result = verify_model_categories(
+            emails=emails,
+            model_categories=ml_classifier.categories,
+            llm_provider=llm,
+            sample_size=min(verify_sample, len(emails))
+        )
+
+        logger.info(f"Verification: {verification_result['verdict']}")
+        logger.info(f"Confidence: {verification_result['confidence']:.0%}")
+
+        if verification_result['verdict'] == 'POOR_MATCH':
+            logger.warning("=" * 80)
+            logger.warning("WARNING: Model categories may not fit this mailbox well")
+            logger.warning(f"Suggested categories: {verification_result.get('suggested_categories', [])}")
+            logger.warning("Consider running full calibration for better accuracy")
+            logger.warning("Proceeding with existing model anyway...")
+            logger.warning("=" * 80)
+        elif verification_result['verdict'] == 'GOOD_MATCH':
+            logger.info("Model categories look appropriate for this mailbox")
+
+        logger.info("=" * 80)
+
+    # Intelligent scaling: Decide if we need ML at all
+    total_emails = len(emails)
+
+    # Skip ML for small datasets (<1000 emails) - use LLM only
+    # Unless --force-ml is set and we have an existing model
+    if total_emails < 1000 and not force_ml:
+        logger.warning(f"Only {total_emails} emails - too few for ML training")
+        logger.warning("Using LLM-only classification (no ML model)")
+        logger.warning("Use --force-ml to use existing model anyway")
+        ml_classifier.is_mock = True
+    elif force_ml and ml_classifier.model:
+        logger.info(f"--force-ml: Using existing ML model for {total_emails} emails")
+
     # Check if we need calibration (no good ML model)
     if ml_classifier.is_mock or not ml_classifier.model:
+        if total_emails >= 1000:
             logger.info("=" * 80)
-        logger.info("RUNNING CALIBRATION - Training ML model on LLM-labeled samples")
+            logger.info("RUNNING CALIBRATION - Training ML model")
             logger.info("=" * 80)
 
             from src.calibration.workflow import CalibrationWorkflow, CalibrationConfig
 
-        # Create calibration LLM provider with larger model
+            # Intelligent scaling for calibration and validation
+            # Calibration: 3% of emails (min 250, max 1500)
+            calibration_size = max(250, min(1500, int(total_emails * 0.03)))
+            # Validation: 1% of emails (min 100, max 300)
+            validation_size = max(100, min(300, int(total_emails * 0.01)))
+
+            logger.info(f"Total emails: {total_emails:,}")
+            logger.info(f"Calibration samples: {calibration_size} ({calibration_size/total_emails*100:.1f}%)")
+            logger.info(f"Validation samples: {validation_size} ({validation_size/total_emails*100:.1f}%)")
+
+            # Create calibration LLM provider
             calibration_llm = OllamaProvider(
                 base_url=cfg.llm.ollama.base_url,
                 model=cfg.llm.ollama.calibration_model,
                 temperature=cfg.llm.ollama.temperature,
                 max_tokens=cfg.llm.ollama.max_tokens
             )
-        logger.info(f"Using calibration model: {cfg.llm.ollama.calibration_model}")
+            logger.info(f"Calibration model: {cfg.llm.ollama.calibration_model}")
+
+            # Create consolidation LLM provider
+            consolidation_model = getattr(cfg.llm.ollama, 'consolidation_model', cfg.llm.ollama.calibration_model)
+            consolidation_llm = OllamaProvider(
+                base_url=cfg.llm.ollama.base_url,
+                model=consolidation_model,
+                temperature=cfg.llm.ollama.temperature,
+                max_tokens=cfg.llm.ollama.max_tokens
+            )
+            logger.info(f"Consolidation model: {consolidation_model}")
 
             calibration_config = CalibrationConfig(
-            sample_size=min(1500, len(emails) // 2),  # Use 1500 or half the emails
+                sample_size=calibration_size,
-            validation_size=300,
+                validation_size=validation_size,
                 llm_batch_size=50
             )
 
             calibration = CalibrationWorkflow(
                 llm_provider=calibration_llm,
+                consolidation_llm_provider=consolidation_llm,
                 feature_extractor=feature_extractor,
-            categories=categories,
+                categories={},  # Don't pass hardcoded - let LLM discover
                 config=calibration_config
             )
 
@@ -180,13 +274,22 @@ def run(
 
     # Classify emails
     logger.info("Starting classification")
+
+    # Batch size for embedding extraction (larger = fewer API calls but more memory)
+    batch_size = 512
+    logger.info(f"Extracting features in batches (batch_size={batch_size})...")
+
+    # Extract all features in batches (MUCH faster than one-at-a-time)
+    all_features = feature_extractor.extract_batch(emails, batch_size=batch_size)
+
+    logger.info(f"Feature extraction complete, classifying {len(emails)} emails...")
     results = []
 
-    for i, email in enumerate(emails):
+    for i, (email, features) in enumerate(zip(emails, all_features)):
-        if (i + 1) % 100 == 0:
+        if (i + 1) % 1000 == 0:
             logger.info(f"Progress: {i+1}/{len(emails)}")
 
-        result = adaptive_classifier.classify(email)
+        result = adaptive_classifier.classify_with_features(email, features)
 
         # If low confidence and LLM available: Use LLM
         if result.needs_review and llm.is_available():
@@ -198,7 +301,20 @@ def run(
     logger.info("Exporting results")
     Path(output).mkdir(parents=True, exist_ok=True)
 
+    # Build email lookup for metadata enrichment
+    email_lookup = {email.id: email for email in emails}
+
     import json
+    from datetime import datetime as dt
+
+    def serialize_date(date_obj):
+        """Serialize date to ISO format string."""
+        if date_obj is None:
+            return None
+        if isinstance(date_obj, dt):
+            return date_obj.isoformat()
+        return str(date_obj)
+
     results_data = {
         'metadata': {
             'total_emails': len(emails),
@@ -208,16 +324,24 @@ def run(
                 'ml_classified': adaptive_classifier.get_stats().ml_classified,
                 'llm_classified': adaptive_classifier.get_stats().llm_classified,
                 'needs_review': adaptive_classifier.get_stats().needs_review,
-            }
+            },
+            'generated_at': dt.now().isoformat(),
+            'source': source,
+            'source_path': directory if source == 'local' else None,
         },
         'classifications': [
             {
                 'email_id': r.email_id,
+                'subject': email_lookup.get(r.email_id, emails[i]).subject if r.email_id in email_lookup or i < len(emails) else '',
+                'sender': email_lookup.get(r.email_id, emails[i]).sender if r.email_id in email_lookup or i < len(emails) else '',
+                'sender_name': email_lookup.get(r.email_id, emails[i]).sender_name if r.email_id in email_lookup or i < len(emails) else None,
+                'date': serialize_date(email_lookup.get(r.email_id, emails[i]).date if r.email_id in email_lookup or i < len(emails) else None),
+                'has_attachments': email_lookup.get(r.email_id, emails[i]).has_attachments if r.email_id in email_lookup or i < len(emails) else False,
                 'category': r.category,
                 'confidence': r.confidence,
                 'method': r.method
             }
-            for r in results
+            for i, r in enumerate(results)
         ]
     }
 

src/email_providers/local_file.py

@@ -0,0 +1,104 @@
+"""Local file provider - for .msg and .eml files."""
+import logging
+from typing import List, Dict, Optional
+
+from .base import BaseProvider, Email
+from src.calibration.local_file_parser import LocalFileParser
+
+logger = logging.getLogger(__name__)
+
+
+class LocalFileProvider(BaseProvider):
+    """
+    Local file provider for .msg and .eml files.
+
+    Supports:
+    - Single directory with email files
+    - Nested directory structure
+    - Mixed .msg (Outlook) and .eml formats
+
+    Uses the same Email data model and BaseProvider interface as other providers.
+    """
+
+    def __init__(self, directory_path: str):
+        """
+        Initialize local file provider.
+
+        Args:
+            directory_path: Path to directory containing email files
+        """
+        super().__init__(name="local_file")
+        self.parser = LocalFileParser(directory_path)
+        self.connected = False
+
+    def connect(self, credentials: Dict = None) -> bool:
+        """
+        Connect to local file provider (no auth needed).
+
+        Args:
+            credentials: Not used for local files
+
+        Returns:
+            Always True for local files
+        """
+        self.connected = True
+        logger.info("Connected to local file provider")
+        return True
+
+    def disconnect(self) -> bool:
+        """Disconnect from local file provider."""
+        self.connected = False
+        logger.info("Disconnected from local file provider")
+        return True
+
+    def fetch_emails(self, limit: int = None, filters: Dict = None) -> List[Email]:
+        """
+        Fetch emails from local directory.
+
+        Args:
+            limit: Maximum number of emails to fetch
+            filters: Optional filters (not implemented for local files)
+
+        Returns:
+            List of Email objects
+        """
+        if not self.connected:
+            logger.warning("Not connected to local file provider")
+            return []
+
+        logger.info(f"Fetching up to {limit or 'all'} emails from local files")
+        emails = self.parser.parse_emails(limit=limit)
+        logger.info(f"Fetched {len(emails)} emails")
+
+        return emails
+
+    def update_labels(self, email_id: str, labels: List[str]) -> bool:
+        """
+        Update labels (not supported for local files).
+
+        Args:
+            email_id: Email ID
+            labels: List of labels to add
+
+        Returns:
+            Always False for local files
+        """
+        logger.warning("Label updates not supported for local file provider")
+        return False
+
+    def batch_update(self, updates: List[Dict]) -> bool:
+        """
+        Batch update (not supported for local files).
+
+        Args:
+            updates: List of update operations
+
+        Returns:
+            Always False for local files
+        """
+        logger.warning("Batch updates not supported for local file provider")
+        return False
+
+    def is_connected(self) -> bool:
+        """Check if provider is connected."""
+        return self.connected

src/email_providers/outlook.py

@@ -0,0 +1,358 @@
+"""Microsoft Outlook/Office365 provider implementation using Microsoft Graph API.
+
+This provider connects to Outlook.com, Office365, and Microsoft 365 accounts
+using the Microsoft Graph API with OAuth 2.0 authentication.
+
+Authentication Setup:
+1. Register app at https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps
+2. Add Mail.Read and Mail.ReadWrite permissions
+3. Get client_id and client_secret
+4. Configure redirect URI (http://localhost:8080 for development)
+"""
+import logging
+from typing import List, Dict, Optional, Any
+from datetime import datetime
+from email.utils import parsedate_to_datetime
+
+from .base import BaseProvider, Email, Attachment
+
+logger = logging.getLogger(__name__)
+
+
+class OutlookProvider(BaseProvider):
+    """
+    Microsoft Outlook/Office365 email provider via Microsoft Graph API.
+
+    Supports:
+    - Outlook.com personal accounts
+    - Office365 business accounts
+    - Microsoft 365 accounts
+
+    Authentication:
+    - OAuth 2.0 with Microsoft Identity Platform
+    - Requires app registration in Azure Portal
+    - Uses delegated permissions (Mail.Read, Mail.ReadWrite)
+    """
+
+    def __init__(self):
+        """Initialize Outlook provider."""
+        super().__init__(name="outlook")
+        self.client = None
+        self.user_id = None
+        self._credentials_configured = False
+
+    def connect(self, credentials: Dict[str, Any]) -> bool:
+        """
+        Connect to Microsoft Graph API using OAuth credentials.
+
+        Args:
+            credentials: Dict containing:
+                - client_id: Azure AD application ID
+                - client_secret: Azure AD application secret (optional for desktop apps)
+                - tenant_id: Azure AD tenant ID (optional, defaults to 'common')
+                - redirect_uri: OAuth redirect URI (default: http://localhost:8080)
+
+        Returns:
+            True if connection successful, False otherwise
+        """
+        try:
+            client_id = credentials.get('client_id')
+            if not client_id:
+                logger.error(
+                    "OUTLOOK OAUTH NOT CONFIGURED: "
+                    "client_id required in credentials. "
+                    "Register app at: "
+                    "https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps"
+                )
+                return False
+
+            # TRY IMPORT - will fail if msal not installed
+            try:
+                import msal
+                import requests
+            except ImportError as e:
+                logger.error(f"OUTLOOK DEPENDENCIES MISSING: {e}")
+                logger.error("Install with: pip install msal requests")
+                return False
+
+            # TRY CONNECTION - authenticate with Microsoft
+            tenant_id = credentials.get('tenant_id', 'common')
+            client_secret = credentials.get('client_secret')
+            redirect_uri = credentials.get('redirect_uri', 'http://localhost:8080')
+
+            authority = f"https://login.microsoftonline.com/{tenant_id}"
+            scopes = ["https://graph.microsoft.com/Mail.Read",
+                     "https://graph.microsoft.com/Mail.ReadWrite"]
+
+            logger.info(f"Attempting Outlook OAuth with client_id: {client_id[:8]}...")
+
+            # Create MSAL app (public client for desktop, confidential for server)
+            if client_secret:
+                app = msal.ConfidentialClientApplication(
+                    client_id,
+                    authority=authority,
+                    client_credential=client_secret
+                )
+            else:
+                app = msal.PublicClientApplication(
+                    client_id,
+                    authority=authority
+                )
+
+            # Try to get token - interactive flow for desktop apps
+            result = None
+
+            # First try cached token
+            accounts = app.get_accounts()
+            if accounts:
+                result = app.acquire_token_silent(scopes, account=accounts[0])
+
+            # If no cached token, do interactive login
+            if not result:
+                flow = app.initiate_device_flow(scopes=scopes)
+                if "user_code" not in flow:
+                    logger.error("Failed to create device flow")
+                    return False
+
+                logger.info("\n" + "="*60)
+                logger.info("MICROSOFT AUTHENTICATION REQUIRED")
+                logger.info("="*60)
+                logger.info(flow["message"])
+                logger.info("="*60 + "\n")
+
+                result = app.acquire_token_by_device_flow(flow)
+
+            if "access_token" not in result:
+                logger.error(f"OUTLOOK AUTHENTICATION FAILED: {result.get('error_description', 'Unknown error')}")
+                return False
+
+            # Store access token and create Graph API client
+            self.access_token = result['access_token']
+            self.graph_client = requests.Session()
+            self.graph_client.headers.update({
+                'Authorization': f'Bearer {self.access_token}',
+                'Content-Type': 'application/json'
+            })
+
+            # Get user profile to verify connection
+            response = self.graph_client.get('https://graph.microsoft.com/v1.0/me')
+            if response.status_code == 200:
+                user_info = response.json()
+                self.user_id = user_info.get('id')
+                logger.info(f"Successfully connected to Outlook for: {user_info.get('userPrincipalName')}")
+                self._credentials_configured = True
+                return True
+            else:
+                logger.error(f"Failed to verify Outlook connection: {response.status_code}")
+                return False
+
+        except Exception as e:
+            logger.error(f"OUTLOOK CONNECTION FAILED: {e}")
+            import traceback
+            logger.debug(traceback.format_exc())
+            return False
+
+    def disconnect(self) -> bool:
+        """Close Outlook connection."""
+        self.graph_client = None
+        self.access_token = None
+        self.user_id = None
+        self._credentials_configured = False
+        logger.info("Disconnected from Outlook")
+        return True
+
+    def fetch_emails(
+        self,
+        limit: Optional[int] = None,
+        filters: Optional[Dict[str, Any]] = None
+    ) -> List[Email]:
+        """
+        Fetch emails from Outlook via Microsoft Graph API.
+
+        Args:
+            limit: Maximum number of emails to fetch
+            filters: Optional filters (folder, search query, etc.)
+
+        Returns:
+            List of Email objects
+        """
+        if not self._credentials_configured or not self.graph_client:
+            logger.error("OUTLOOK NOT CONFIGURED: Cannot fetch emails without OAuth setup")
+            return []
+
+        emails = []
+        try:
+            # Build Graph API query
+            folder = filters.get('folder', 'inbox') if filters else 'inbox'
+            search_query = filters.get('query', '') if filters else ''
+
+            # Construct Graph API URL
+            url = f"https://graph.microsoft.com/v1.0/me/mailFolders/{folder}/messages"
+            params = {
+                '$top': min(limit or 500, 1000) if limit else 500,
+                '$orderby': 'receivedDateTime DESC'
+            }
+
+            if search_query:
+                params['$search'] = f'"{search_query}"'
+
+            # Fetch messages
+            response = self.graph_client.get(url, params=params)
+
+            if response.status_code != 200:
+                logger.error(f"Failed to fetch emails: {response.status_code} - {response.text}")
+                return []
+
+            data = response.json()
+            messages = data.get('value', [])
+
+            for msg in messages:
+                email = self._parse_message(msg)
+                if email:
+                    emails.append(email)
+                    if limit and len(emails) >= limit:
+                        break
+
+            logger.info(f"Fetched {len(emails)} emails from Outlook")
+            return emails
+
+        except Exception as e:
+            logger.error(f"OUTLOOK FETCH ERROR: {e}")
+            import traceback
+            logger.debug(traceback.format_exc())
+            return emails
+
+    def _parse_message(self, msg: Dict) -> Email:
+        """Parse Microsoft Graph message into Email object."""
+        try:
+            # Parse sender
+            sender_email = msg.get('from', {}).get('emailAddress', {}).get('address', '')
+
+            # Parse date
+            date_str = msg.get('receivedDateTime')
+            date = datetime.fromisoformat(date_str.replace('Z', '+00:00')) if date_str else None
+
+            # Parse body
+            body_content = msg.get('body', {})
+            body = body_content.get('content', '')
+
+            # Parse attachments
+            has_attachments = msg.get('hasAttachments', False)
+            attachments = []
+            if has_attachments:
+                attachments = self._parse_attachments(msg.get('id'))
+
+            return Email(
+                id=msg.get('id'),
+                subject=msg.get('subject', 'No Subject'),
+                sender=sender_email,
+                date=date,
+                body=body,
+                has_attachments=has_attachments,
+                attachments=attachments,
+                headers={'message-id': msg.get('id')},
+                labels=msg.get('categories', []),
+                is_read=msg.get('isRead', False),
+                provider='outlook'
+            )
+
+        except Exception as e:
+            logger.error(f"Error parsing message: {e}")
+            return None
+
+    def _parse_attachments(self, message_id: str) -> List[Attachment]:
+        """Fetch and parse attachments for a message."""
+        attachments = []
+
+        try:
+            url = f"https://graph.microsoft.com/v1.0/me/messages/{message_id}/attachments"
+            response = self.graph_client.get(url)
+
+            if response.status_code == 200:
+                data = response.json()
+                for att in data.get('value', []):
+                    attachments.append(Attachment(
+                        filename=att.get('name', 'unknown'),
+                        mime_type=att.get('contentType', 'application/octet-stream'),
+                        size=att.get('size', 0),
+                        attachment_id=att.get('id')
+                    ))
+        except Exception as e:
+            logger.debug(f"Error fetching attachments: {e}")
+
+        return attachments
+
+    def update_labels(self, email_id: str, labels: List[str]) -> bool:
+        """Update categories for a single email."""
+        if not self._credentials_configured or not self.graph_client:
+            logger.error("OUTLOOK NOT CONFIGURED: Cannot update labels")
+            return False
+
+        try:
+            url = f"https://graph.microsoft.com/v1.0/me/messages/{email_id}"
+            data = {"categories": labels}
+
+            response = self.graph_client.patch(url, json=data)
+
+            if response.status_code in [200, 204]:
+                return True
+            else:
+                logger.error(f"Failed to update labels: {response.status_code}")
+                return False
+
+        except Exception as e:
+            logger.error(f"Error updating labels: {e}")
+            return False
+
+    def batch_update(self, updates: List[Dict[str, Any]]) -> bool:
+        """Batch update multiple emails."""
+        if not self._credentials_configured or not self.graph_client:
+            logger.error("OUTLOOK NOT CONFIGURED: Cannot batch update")
+            return False
+
+        try:
+            # Microsoft Graph API supports batch requests
+            batch_requests = []
+
+            for i, update in enumerate(updates):
+                email_id = update.get('email_id')
+                labels = update.get('labels', [])
+
+                batch_requests.append({
+                    "id": str(i),
+                    "method": "PATCH",
+                    "url": f"/me/messages/{email_id}",
+                    "body": {"categories": labels},
+                    "headers": {"Content-Type": "application/json"}
+                })
+
+            # Send batch request (max 20 per batch)
+            batch_size = 20
+            successful = 0
+
+            for i in range(0, len(batch_requests), batch_size):
+                batch = batch_requests[i:i+batch_size]
+
+                response = self.graph_client.post(
+                    'https://graph.microsoft.com/v1.0/$batch',
+                    json={"requests": batch}
+                )
+
+                if response.status_code == 200:
+                    result = response.json()
+                    for resp in result.get('responses', []):
+                        if resp.get('status') in [200, 204]:
+                            successful += 1
+
+            logger.info(f"Batch updated {successful}/{len(updates)} emails")
+            return successful > 0
+
+        except Exception as e:
+            logger.error(f"Batch update error: {e}")
+            import traceback
+            logger.debug(traceback.format_exc())
+            return False
+
+    def is_connected(self) -> bool:
+        """Check if connected."""
+        return self._credentials_configured and self.graph_client is not None

src/llm/openai_compat.py

@@ -47,14 +47,12 @@ class OpenAIProvider(BaseLLMProvider):
         try:
             from openai import OpenAI
 
-            if not self.api_key:
+            # For local vLLM/OpenAI-compatible servers, API key may not be required
-                self.logger.error("OpenAI API key not configured")
+            # Use a placeholder if not set
-                self.logger.error("Set OPENAI_API_KEY environment variable or pass api_key parameter")
+            api_key = self.api_key or "not-needed"
-                self._available = False
-                return
 
             self.client = OpenAI(
-                api_key=self.api_key,
+                api_key=api_key,
                 base_url=self.base_url if self.base_url != "https://api.openai.com/v1" else None,
                 timeout=self.timeout
             )
@@ -121,7 +119,7 @@ class OpenAIProvider(BaseLLMProvider):
 
     def test_connection(self) -> bool:
         """Test if OpenAI API is accessible."""
-        if not self.client or not self.api_key:
+        if not self.client:
             self.logger.warning("OpenAI client not initialized")
             return False
 

src/utils/config.py

@@ -39,7 +39,8 @@ class ClassificationConfig(BaseModel):
 class OllamaConfig(BaseModel):
     """Ollama LLM provider configuration."""
     base_url: str = "http://localhost:11434"
-    calibration_model: str = "qwen3:4b"
+    calibration_model: str = "qwen3:1.7b"  # Changed from 4b to 1.7b for speed testing
+    consolidation_model: str = "qwen3:8b-q4_K_M"  # Larger model for structured JSON output
     classification_model: str = "qwen3:1.7b"
     temperature: float = 0.1
     max_tokens: int = 500

tools/README.md

@@ -0,0 +1,248 @@
+# Email Sorter - Supplementary Tools
+
+This directory contains **optional** standalone tools that complement the main ML classification pipeline without interfering with it.
+
+## Tools
+
+### batch_llm_classifier.py
+
+**Purpose**: Ask custom questions across batches of emails using vLLM server
+
+**Prerequisite**: vLLM server must be running at configured endpoint
+
+**When to use this:**
+- One-off batch analysis with custom questions
+- Exploratory queries ("find all emails mentioning budget cuts")
+- Custom classification criteria not in trained ML model
+- Quick ad-hoc analysis without retraining
+
+**When to use RAG instead:**
+- Searching across large email corpus (10k+ emails)
+- Finding specific topics/keywords with semantic search
+- Building knowledge base from email content
+- Multi-step reasoning across many documents
+
+**When to use main ML pipeline:**
+- Regular ongoing classification of incoming emails
+- High-volume processing (100k+ emails)
+- Consistent categories that don't change
+- Maximum speed (pure ML with no LLM calls)
+
+---
+
+## batch_llm_classifier.py Usage
+
+### Check vLLM Server Status
+
+```bash
+python tools/batch_llm_classifier.py check
+```
+
+Expected output:
+```
+✓ vLLM server is running and ready
+✓ Max concurrent requests: 4
+✓ Estimated throughput: ~4.4 emails/sec
+```
+
+### Ask Custom Question
+
+```bash
+python tools/batch_llm_classifier.py ask \
+  --source enron \
+  --limit 100 \
+  --question "Does this email contain any financial numbers or budget information?" \
+  --output financial_emails.txt
+```
+
+**Parameters:**
+- `--source`: Email provider (gmail, enron)
+- `--credentials`: Path to credentials (for Gmail)
+- `--limit`: Number of emails to process
+- `--question`: Custom question to ask about each email
+- `--output`: Output file for results
+
+### Example Questions
+
+**Finding specific content:**
+```bash
+--question "Is this email about a meeting or calendar event? Answer yes/no and provide date if found."
+```
+
+**Sentiment analysis:**
+```bash
+--question "What is the tone of this email? Professional/Casual/Urgent/Friendly?"
+```
+
+**Categorization with custom criteria:**
+```bash
+--question "Should this email be archived or kept for reference? Explain why."
+```
+
+**Data extraction:**
+```bash
+--question "Extract all names, dates, and dollar amounts mentioned in this email."
+```
+
+---
+
+## Configuration
+
+vLLM server settings are in `batch_llm_classifier.py`:
+
+```python
+VLLM_CONFIG = {
+    'base_url': 'https://rtx3090.bobai.com.au/v1',
+    'api_key': 'rtx3090_foxadmin_10_8034ecb47841f45ba1d5f3f5d875c092',
+    'model': 'qwen3-coder-30b',
+    'batch_size': 4,  # Tested optimal - 100% success rate
+    'temperature': 0.1,
+    'max_tokens': 500
+}
+```
+
+**Note**: `batch_size: 4` is the tested optimal setting. Uses proper batch pooling (send 4, wait for completion, send next 4). Higher values cause 503 errors.
+
+---
+
+## Performance Benchmarks
+
+Tested on rtx3090.bobai.com.au with qwen3-coder-30b:
+
+| Emails | Batch Size | Time | Throughput | Success Rate |
+|--------|-----------|------|------------|--------------|
+| 500    | 4 (pooled)| 108s | 4.65/sec   | 100%         |
+| 500    | 8 (pooled)| 62s  | 8.10/sec   | 60%          |
+| 500    | 20 (pooled)| 23s | 21.8/sec   | 23%          |
+
+**Conclusion**: batch_size=4 with proper batch pooling is optimal (100% reliability, ~4.7 req/sec)
+
+---
+
+## Architecture Notes
+
+### Prompt Caching Optimization
+
+Prompts are structured with static content first, variable content last:
+
+```
+STATIC (cached):
+  - System instructions
+  - Question
+  - Output format guidelines
+
+VARIABLE (not cached):
+  - Email subject
+  - Email sender
+  - Email body
+```
+
+This allows vLLM to cache the static portion across all emails in the batch.
+
+### Separation from Main Pipeline
+
+This tool is **completely independent** from the main classification pipeline:
+
+- **Main pipeline** (`src/cli.py run`):
+  - Uses calibrated LightGBM model
+  - Fast pure ML classification
+  - Optional LLM fallback for low-confidence cases
+  - Processes 10k emails in ~24s (pure ML) or ~5min (with LLM fallback)
+
+- **Batch LLM tool** (`tools/batch_llm_classifier.py`):
+  - Uses vLLM server exclusively
+  - Custom questions per run
+  - ~4.4 emails/sec throughput
+  - For ad-hoc analysis, not production classification
+
+### No Interference Guarantee
+
+The batch LLM tool:
+- ✓ Does NOT modify any files in `src/`
+- ✓ Does NOT touch trained models in `src/models/`
+- ✓ Does NOT affect config files
+- ✓ Does NOT interfere with existing workflows
+- ✓ Uses separate vLLM endpoint (not Ollama)
+
+---
+
+## Comparison: Batch LLM vs RAG
+
+| Feature | Batch LLM (this tool) | RAG (rag-search) |
+|---------|----------------------|------------------|
+| **Speed** | 4.4 emails/sec | Instant (pre-indexed) |
+| **Flexibility** | Custom questions | Semantic search queries |
+| **Best for** | 50-500 email batches | 10k+ email corpus |
+| **Prerequisite** | vLLM server running | RAG collection indexed |
+| **Use case** | "Does this mention X?" | "Find all emails about X" |
+| **Reasoning** | Per-email LLM analysis | Similarity + ranking |
+
+**Rule of thumb:**
+- < 500 emails + custom question = Use Batch LLM
+- > 1000 emails + topic search = Use RAG
+- Regular classification = Use main ML pipeline
+
+---
+
+## Prerequisites
+
+1. **vLLM server must be running**
+   - Endpoint: https://rtx3090.bobai.com.au/v1
+   - Model loaded: qwen3-coder-30b
+   - Check with: `python tools/batch_llm_classifier.py check`
+
+2. **Python dependencies**
+   ```bash
+   pip install httpx click
+   ```
+
+3. **Email provider setup**
+   - Enron: No setup needed (uses local maildir)
+   - Gmail: Requires credentials file
+
+---
+
+## Troubleshooting
+
+### "vLLM server not available"
+
+Check server status:
+```bash
+curl https://rtx3090.bobai.com.au/v1/models \
+  -H "Authorization: Bearer rtx3090_foxadmin_10_8034ecb47841f45ba1d5f3f5d875c092"
+```
+
+Verify model is loaded:
+```bash
+python tools/batch_llm_classifier.py check
+```
+
+### High error rate (503 errors)
+
+Reduce concurrent requests in `VLLM_CONFIG`:
+```python
+'max_concurrent': 2,  # Lower if getting 503s
+```
+
+### Slow processing
+
+- Check vLLM server isn't overloaded
+- Verify network latency to rtx3090.bobai.com.au
+- Consider using main ML pipeline for large batches
+
+---
+
+## Future Enhancements
+
+Potential additions (not implemented):
+
+- Support for custom prompt templates
+- JSON output mode for structured extraction
+- Progress bar for large batches
+- Retry logic for transient failures
+- Multi-server load balancing
+- Streaming responses for real-time feedback
+
+---
+
+**Remember**: This tool is supplementary. For production email classification, use the main ML pipeline (`src/cli.py run`).

tools/batch_llm_classifier.py

@@ -0,0 +1,364 @@
+#!/usr/bin/env python3
+"""
+Standalone vLLM Batch Email Classifier
+
+PREREQUISITE: vLLM server must be running at configured endpoint
+
+This is a SEPARATE tool from the main ML classification pipeline.
+Use this for:
+- One-off batch questions ("find all emails about project X")
+- Custom classification criteria not in trained model
+- Exploratory analysis with flexible prompts
+
+Use RAG instead for:
+- Searching across large email corpus
+- Finding specific topics/keywords
+- Building knowledge from email content
+"""
+
+import time
+import asyncio
+import logging
+import sys
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+
+import httpx
+import click
+
+
+# Server configuration
+VLLM_CONFIG = {
+    'base_url': 'https://rtx3090.bobai.com.au/v1',
+    'api_key': 'rtx3090_foxadmin_10_8034ecb47841f45ba1d5f3f5d875c092',
+    'model': 'qwen3-coder-30b',
+    'batch_size': 4,  # Tested optimal - 100% success, proper batch pooling
+    'temperature': 0.1,
+    'max_tokens': 500
+}
+
+
+async def check_vllm_server(base_url: str, api_key: str, model: str) -> bool:
+    """Check if vLLM server is running and model is loaded."""
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"{base_url}/chat/completions",
+                json={
+                    "model": model,
+                    "messages": [{"role": "user", "content": "test"}],
+                    "max_tokens": 5
+                },
+                headers={
+                    "Authorization": f"Bearer {api_key}",
+                    "Content-Type": "application/json"
+                },
+                timeout=10.0
+            )
+            return response.status_code == 200
+    except Exception as e:
+        print(f"ERROR: vLLM server check failed: {e}")
+        return False
+
+
+async def classify_email_async(
+    client: httpx.AsyncClient,
+    email: Any,
+    prompt_template: str,
+    base_url: str,
+    api_key: str,
+    model: str,
+    temperature: float,
+    max_tokens: int
+) -> Dict[str, Any]:
+    """Classify single email using async HTTP request."""
+
+    # No semaphore - proper batch pooling instead
+    try:
+        # Build prompt with email data
+        prompt = prompt_template.format(
+            subject=email.get('subject', 'N/A')[:100],
+            sender=email.get('sender', 'N/A')[:50],
+            body_snippet=email.get('body_snippet', '')[:500]
+        )
+            response = await client.post(
+                f"{base_url}/chat/completions",
+                json={
+                    "model": model,
+                    "messages": [{"role": "user", "content": prompt}],
+                    "temperature": temperature,
+                    "max_tokens": max_tokens
+                },
+                headers={
+                    "Authorization": f"Bearer {api_key}",
+                    "Content-Type": "application/json"
+                },
+                timeout=30.0
+            )
+
+            if response.status_code == 200:
+                data = response.json()
+                content = data['choices'][0]['message']['content']
+
+                return {
+                    'email_id': email.get('id', 'unknown'),
+                    'subject': email.get('subject', 'N/A')[:60],
+                    'result': content.strip(),
+                    'success': True
+                }
+
+            return {
+                'email_id': email.get('id', 'unknown'),
+                'subject': email.get('subject', 'N/A')[:60],
+                'result': f'HTTP {response.status_code}',
+                'success': False
+            }
+
+    except Exception as e:
+        return {
+            'email_id': email.get('id', 'unknown'),
+            'subject': email.get('subject', 'N/A')[:60],
+            'result': f'Error: {str(e)[:100]}',
+            'success': False
+        }
+
+
+async def classify_single_batch(
+    client: httpx.AsyncClient,
+    emails: List[Dict[str, Any]],
+    prompt_template: str,
+    config: Dict[str, Any]
+) -> List[Dict[str, Any]]:
+    """Classify one batch of emails - send all at once, wait for completion."""
+
+    tasks = [
+        classify_email_async(
+            client, email, prompt_template,
+            config['base_url'], config['api_key'], config['model'],
+            config['temperature'], config['max_tokens']
+        )
+        for email in emails
+    ]
+
+    results = await asyncio.gather(*tasks)
+    return results
+
+
+async def batch_classify_async(
+    emails: List[Dict[str, Any]],
+    prompt_template: str,
+    config: Dict[str, Any]
+) -> List[Dict[str, Any]]:
+    """Classify emails using proper batch pooling."""
+
+    batch_size = config['batch_size']
+    all_results = []
+
+    async with httpx.AsyncClient() as client:
+        # Process in batches - send batch, wait for all to complete, repeat
+        for batch_start in range(0, len(emails), batch_size):
+            batch_end = min(batch_start + batch_size, len(emails))
+            batch_emails = emails[batch_start:batch_end]
+
+            batch_results = await classify_single_batch(
+                client, batch_emails, prompt_template, config
+            )
+
+            all_results.extend(batch_results)
+
+    return all_results
+
+
+def load_emails_from_provider(provider_type: str, credentials: Optional[str], limit: int) -> List[Dict[str, Any]]:
+    """Load emails from configured provider."""
+
+    # Lazy import to avoid dependency issues
+    if provider_type == 'enron':
+        from src.email_providers.enron import EnronProvider
+        provider = EnronProvider(maildir_path=".")
+        provider.connect({})
+        emails = provider.fetch_emails(limit=limit)
+        provider.disconnect()
+
+        # Convert to dict format
+        return [
+            {
+                'id': e.id,
+                'subject': e.subject,
+                'sender': e.sender,
+                'body_snippet': e.body_snippet
+            }
+            for e in emails
+        ]
+
+    elif provider_type == 'gmail':
+        from src.email_providers.gmail import GmailProvider
+        if not credentials:
+            print("ERROR: Gmail requires --credentials path")
+            sys.exit(1)
+        provider = GmailProvider()
+        provider.connect({'credentials_path': credentials})
+        emails = provider.fetch_emails(limit=limit)
+        provider.disconnect()
+
+        return [
+            {
+                'id': e.id,
+                'subject': e.subject,
+                'sender': e.sender,
+                'body_snippet': e.body_snippet
+            }
+            for e in emails
+        ]
+
+    else:
+        print(f"ERROR: Unsupported provider: {provider_type}")
+        sys.exit(1)
+
+
+@click.group()
+def cli():
+    """vLLM Batch Email Classifier - Ask custom questions across email batches."""
+    pass
+
+
+@cli.command()
+@click.option('--source', type=click.Choice(['gmail', 'enron']), default='enron',
+              help='Email provider')
+@click.option('--credentials', type=click.Path(exists=False),
+              help='Path to credentials file (for Gmail)')
+@click.option('--limit', type=int, default=50,
+              help='Number of emails to process')
+@click.option('--question', type=str, required=True,
+              help='Question to ask about each email')
+@click.option('--output', type=click.Path(), default='batch_results.txt',
+              help='Output file for results')
+def ask(source: str, credentials: Optional[str], limit: int, question: str, output: str):
+    """Ask a custom question about a batch of emails."""
+
+    print("=" * 80)
+    print("vLLM BATCH EMAIL CLASSIFIER")
+    print("=" * 80)
+    print(f"Question: {question}")
+    print(f"Source: {source}")
+    print(f"Batch size: {limit}")
+    print("=" * 80)
+    print()
+
+    # Check vLLM server
+    print("Checking vLLM server...")
+    if not asyncio.run(check_vllm_server(
+        VLLM_CONFIG['base_url'],
+        VLLM_CONFIG['api_key'],
+        VLLM_CONFIG['model']
+    )):
+        print()
+        print("ERROR: vLLM server not available or not responding")
+        print(f"Expected endpoint: {VLLM_CONFIG['base_url']}")
+        print(f"Expected model: {VLLM_CONFIG['model']}")
+        print()
+        print("PREREQUISITE: Start vLLM server before running this tool")
+        sys.exit(1)
+
+    print(f"✓ vLLM server running ({VLLM_CONFIG['model']})")
+    print()
+
+    # Load emails
+    print(f"Loading {limit} emails from {source}...")
+    emails = load_emails_from_provider(source, credentials, limit)
+    print(f"✓ Loaded {len(emails)} emails")
+    print()
+
+    # Build prompt template (optimized for caching)
+    prompt_template = f"""You are analyzing emails to answer specific questions.
+
+INSTRUCTIONS:
+- Read the email carefully
+- Answer the question directly and concisely
+- Provide reasoning if helpful
+- If the email is not relevant, say "Not relevant"
+
+QUESTION:
+{question}
+
+EMAIL TO ANALYZE:
+Subject: {{subject}}
+From: {{sender}}
+Body: {{body_snippet}}
+
+ANSWER:
+"""
+
+    # Process batch
+    print(f"Processing {len(emails)} emails with {VLLM_CONFIG['max_concurrent']} concurrent requests...")
+    start_time = time.time()
+
+    results = asyncio.run(batch_classify_async(emails, prompt_template, VLLM_CONFIG))
+
+    end_time = time.time()
+    total_time = end_time - start_time
+
+    # Stats
+    successful = sum(1 for r in results if r['success'])
+    throughput = len(emails) / total_time
+
+    print()
+    print("=" * 80)
+    print("RESULTS")
+    print("=" * 80)
+    print(f"Total emails: {len(emails)}")
+    print(f"Successful: {successful}")
+    print(f"Failed: {len(emails) - successful}")
+    print(f"Time: {total_time:.1f}s")
+    print(f"Throughput: {throughput:.2f} emails/sec")
+    print("=" * 80)
+    print()
+
+    # Save results
+    with open(output, 'w') as f:
+        f.write(f"Question: {question}\n")
+        f.write(f"Processed: {len(emails)} emails in {total_time:.1f}s\n")
+        f.write("=" * 80 + "\n\n")
+
+        for i, result in enumerate(results, 1):
+            f.write(f"{i}. {result['subject']}\n")
+            f.write(f"   Email ID: {result['email_id']}\n")
+            f.write(f"   Answer: {result['result']}\n")
+            f.write("\n")
+
+    print(f"Results saved to: {output}")
+    print()
+
+    # Show sample
+    print("SAMPLE RESULTS (first 5):")
+    for i, result in enumerate(results[:5], 1):
+        print(f"\n{i}. {result['subject']}")
+        print(f"   {result['result'][:100]}...")
+
+
+@cli.command()
+def check():
+    """Check if vLLM server is running and ready."""
+
+    print("Checking vLLM server...")
+    print(f"Endpoint: {VLLM_CONFIG['base_url']}")
+    print(f"Model: {VLLM_CONFIG['model']}")
+    print()
+
+    if asyncio.run(check_vllm_server(
+        VLLM_CONFIG['base_url'],
+        VLLM_CONFIG['api_key'],
+        VLLM_CONFIG['model']
+    )):
+        print("✓ vLLM server is running and ready")
+        print(f"✓ Max concurrent requests: {VLLM_CONFIG['max_concurrent']}")
+        print(f"✓ Estimated throughput: ~4.4 emails/sec")
+    else:
+        print("✗ vLLM server not available")
+        print()
+        print("Start vLLM server before using this tool")
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    cli()

tools/brett_gmail_analyzer.py

@@ -0,0 +1,391 @@
+#!/usr/bin/env python3
+"""
+Brett Gmail Dataset Analyzer
+============================
+CUSTOM script for analyzing the brett-gmail email dataset.
+NOT portable to other datasets without modification.
+
+Usage:
+    python tools/brett_gmail_analyzer.py
+
+Output:
+    - Console report with comprehensive statistics
+    - data/brett_gmail_analysis.json with full analysis data
+"""
+
+import json
+import re
+from collections import Counter, defaultdict
+from datetime import datetime
+from pathlib import Path
+
+# Add parent to path for imports
+import sys
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from src.calibration.local_file_parser import LocalFileParser
+
+
+# =============================================================================
+# CLASSIFICATION RULES - CUSTOM FOR BRETT'S GMAIL
+# =============================================================================
+
+def classify_email(email):
+    """
+    Classify email into categories based on sender domain and subject patterns.
+
+    Priority: Sender domain > Subject keywords
+    """
+    sender = email.sender or ""
+    subject = email.subject or ""
+    domain = sender.split('@')[-1] if '@' in sender else sender
+
+    # === HIGH-LEVEL CATEGORIES ===
+
+    # --- Art & Collectibles ---
+    if 'mutualart.com' in domain:
+        return ('Art & Collectibles', 'MutualArt Alerts')
+
+    # --- Travel & Tourism ---
+    if 'tripadvisor.com' in domain:
+        return ('Travel & Tourism', 'Tripadvisor')
+    if 'booking.com' in domain:
+        return ('Travel & Tourism', 'Booking.com')
+
+    # --- Entertainment & Streaming ---
+    if 'spotify.com' in domain:
+        if 'concert' in subject.lower() or 'live' in subject.lower():
+            return ('Entertainment', 'Spotify Concerts')
+        return ('Entertainment', 'Spotify Promotions')
+    if 'youtube.com' in domain:
+        return ('Entertainment', 'YouTube')
+    if 'onlyfans.com' in domain:
+        return ('Entertainment', 'OnlyFans')
+    if 'ign.com' in domain:
+        return ('Entertainment', 'IGN Gaming')
+
+    # --- Shopping & eCommerce ---
+    if 'ebay.com' in domain or 'reply.ebay' in domain:
+        return ('Shopping', 'eBay')
+    if 'aliexpress.com' in domain:
+        return ('Shopping', 'AliExpress')
+    if 'alibabacloud.com' in domain or 'alibaba-inc.com' in domain:
+        return ('Tech Services', 'Alibaba Cloud')
+    if '4wdsupacentre' in domain:
+        return ('Shopping', '4WD Supacentre')
+    if 'mikeblewitt' in domain or 'mbcoffscoast' in domain:
+        return ('Shopping', 'Mike Blewitt/MBC')
+    if 'auspost.com.au' in domain:
+        return ('Shopping', 'Australia Post')
+    if 'printfresh' in domain:
+        return ('Business', 'Timesheets')
+
+    # --- AI & Tech Services ---
+    if 'anthropic.com' in domain or 'claude.com' in domain:
+        return ('AI Services', 'Anthropic/Claude')
+    if 'openai.com' in domain:
+        return ('AI Services', 'OpenAI')
+    if 'openrouter.ai' in domain:
+        return ('AI Services', 'OpenRouter')
+    if 'lambda' in domain:
+        return ('AI Services', 'Lambda Labs')
+    if 'x.ai' in domain:
+        return ('AI Services', 'xAI')
+    if 'perplexity.ai' in domain:
+        return ('AI Services', 'Perplexity')
+    if 'cursor.com' in domain:
+        return ('Developer Tools', 'Cursor')
+
+    # --- Developer Tools ---
+    if 'ngrok.com' in domain:
+        return ('Developer Tools', 'ngrok')
+    if 'docker.com' in domain:
+        return ('Developer Tools', 'Docker')
+
+    # --- Productivity Apps ---
+    if 'screencastify.com' in domain:
+        return ('Productivity', 'Screencastify')
+    if 'tango.us' in domain:
+        return ('Productivity', 'Tango')
+    if 'xplor.com' in domain or 'myxplor' in domain:
+        return ('Services', 'Xplor Childcare')
+
+    # --- Google Services ---
+    if 'google.com' in domain or 'accounts.google.com' in domain:
+        if 'performance report' in subject.lower() or 'business profile' in subject.lower():
+            return ('Google', 'Business Profile')
+        if 'security' in subject.lower() or 'sign-in' in subject.lower():
+            return ('Security', 'Google Security')
+        if 'firebase' in subject.lower() or 'firestore' in subject.lower():
+            return ('Developer Tools', 'Firebase')
+        if 'ads' in subject.lower():
+            return ('Google', 'Google Ads')
+        if 'analytics' in subject.lower():
+            return ('Google', 'Analytics')
+        if re.search(r'verification code|verify', subject, re.I):
+            return ('Security', 'Google Verification')
+        return ('Google', 'Other Google')
+
+    # --- Microsoft ---
+    if 'microsoft.com' in domain or 'outlook.com' in domain or 'hotmail.com' in domain:
+        if 'security' in subject.lower() or 'protection' in domain:
+            return ('Security', 'Microsoft Security')
+        return ('Personal', 'Microsoft/Outlook')
+
+    # --- Social Media ---
+    if 'reddit' in domain:
+        return ('Social', 'Reddit')
+
+    # --- Business/Work ---
+    if 'frontiertechstrategies' in domain:
+        return ('Business', 'Appointments')
+    if 'crsaustralia.gov.au' in domain:
+        return ('Business', 'Job Applications')
+    if 'v6send.net' in domain:
+        return ('Shopping', 'Automotive Dealers')
+
+    # === SUBJECT-BASED FALLBACK ===
+
+    if re.search(r'security alert|verification code|sign.?in|password|2fa', subject, re.I):
+        return ('Security', 'General Security')
+
+    if re.search(r'order.*ship|receipt|payment|invoice|purchase', subject, re.I):
+        return ('Transactions', 'Orders/Receipts')
+
+    if re.search(r'trial|subscription|billing|renew', subject, re.I):
+        return ('Billing', 'Subscriptions')
+
+    if re.search(r'terms of service|privacy policy|legal', subject, re.I):
+        return ('Legal', 'Policy Updates')
+
+    if re.search(r'welcome to|getting started', subject, re.I):
+        return ('Onboarding', 'Welcome Emails')
+
+    # --- Personal contacts ---
+    if 'gmail.com' in domain:
+        return ('Personal', 'Gmail Contacts')
+
+    return ('Uncategorized', 'Unknown')
+
+
+def extract_order_ids(emails):
+    """Extract order/transaction IDs from emails."""
+    order_patterns = [
+        (r'Order\s+(\d{10,})', 'AliExpress Order'),
+        (r'receipt.*(\d{4}-\d{4}-\d{4})', 'Receipt ID'),
+        (r'#(\d{4,})', 'Generic Order ID'),
+    ]
+
+    orders = []
+    for email in emails:
+        subject = email.subject or ""
+        for pattern, order_type in order_patterns:
+            match = re.search(pattern, subject, re.I)
+            if match:
+                orders.append({
+                    'id': match.group(1),
+                    'type': order_type,
+                    'subject': subject,
+                    'date': str(email.date) if email.date else None,
+                    'sender': email.sender
+                })
+                break
+    return orders
+
+
+def analyze_time_distribution(emails):
+    """Analyze email distribution over time."""
+    by_year = Counter()
+    by_month = Counter()
+    by_day_of_week = Counter()
+
+    day_names = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
+
+    for email in emails:
+        if email.date:
+            try:
+                by_year[email.date.year] += 1
+                by_month[f"{email.date.year}-{email.date.month:02d}"] += 1
+                by_day_of_week[day_names[email.date.weekday()]] += 1
+            except:
+                pass
+
+    return {
+        'by_year': dict(by_year.most_common()),
+        'by_month': dict(sorted(by_month.items())),
+        'by_day_of_week': {d: by_day_of_week.get(d, 0) for d in day_names}
+    }
+
+
+def main():
+    email_dir = "/home/bob/Documents/Email Manager/emails/brett-gmail"
+    output_dir = Path(__file__).parent.parent / "data"
+    output_dir.mkdir(exist_ok=True)
+
+    print("="*70)
+    print("BRETT GMAIL DATASET ANALYSIS")
+    print("="*70)
+    print(f"\nSource: {email_dir}")
+    print(f"Output: {output_dir}")
+
+    # Parse emails
+    print("\nParsing emails...")
+    parser = LocalFileParser(email_dir)
+    emails = parser.parse_emails()
+    print(f"Total emails: {len(emails)}")
+
+    # Date range
+    dates = [e.date for e in emails if e.date]
+    if dates:
+        dates.sort()
+        print(f"Date range: {dates[0].strftime('%Y-%m-%d')} to {dates[-1].strftime('%Y-%m-%d')}")
+
+    # Classify all emails
+    print("\nClassifying emails...")
+
+    category_counts = Counter()
+    subcategory_counts = Counter()
+    by_category = defaultdict(list)
+    by_subcategory = defaultdict(list)
+
+    for email in emails:
+        category, subcategory = classify_email(email)
+        category_counts[category] += 1
+        subcategory_counts[subcategory] += 1
+        by_category[category].append(email)
+        by_subcategory[subcategory].append(email)
+
+    # Print category summary
+    print("\n" + "="*70)
+    print("CATEGORY SUMMARY")
+    print("="*70)
+
+    for category, count in category_counts.most_common():
+        pct = count / len(emails) * 100
+        bar = "█" * int(pct / 2)
+        print(f"\n{category} ({count} emails, {pct:.1f}%)")
+        print(f"  {bar}")
+
+        # Show subcategories
+        subcats = Counter()
+        for email in by_category[category]:
+            _, subcat = classify_email(email)
+            subcats[subcat] += 1
+
+        for subcat, subcount in subcats.most_common():
+            print(f"    - {subcat}: {subcount}")
+
+    # Analyze senders
+    print("\n" + "="*70)
+    print("TOP SENDERS BY VOLUME")
+    print("="*70)
+
+    sender_counts = Counter(e.sender for e in emails)
+    for sender, count in sender_counts.most_common(15):
+        pct = count / len(emails) * 100
+        print(f"  {count:4d} ({pct:4.1f}%)  {sender}")
+
+    # Time analysis
+    print("\n" + "="*70)
+    print("TIME DISTRIBUTION")
+    print("="*70)
+
+    time_dist = analyze_time_distribution(emails)
+
+    print("\nBy Year:")
+    for year, count in sorted(time_dist['by_year'].items()):
+        bar = "█" * (count // 10)
+        print(f"  {year}: {count:4d} {bar}")
+
+    print("\nBy Day of Week:")
+    for day, count in time_dist['by_day_of_week'].items():
+        bar = "█" * (count // 5)
+        print(f"  {day}: {count:3d} {bar}")
+
+    # Extract orders
+    print("\n" + "="*70)
+    print("ORDER/TRANSACTION IDs FOUND")
+    print("="*70)
+
+    orders = extract_order_ids(emails)
+    if orders:
+        for order in orders[:10]:
+            print(f"  [{order['type']}] {order['id']}")
+            print(f"    Subject: {order['subject'][:60]}...")
+    else:
+        print("  No order IDs detected in subjects")
+
+    # Actionable insights
+    print("\n" + "="*70)
+    print("ACTIONABLE INSIGHTS")
+    print("="*70)
+
+    # High-volume automated senders
+    automated_domains = ['mutualart.com', 'tripadvisor.com', 'ebay.com', 'spotify.com']
+    auto_count = sum(1 for e in emails if any(d in (e.sender or '') for d in automated_domains))
+    print(f"\n1. AUTOMATED EMAILS: {auto_count} ({auto_count/len(emails)*100:.1f}%)")
+    print("   - MutualArt alerts: Consider aggregating to weekly digest")
+    print("   - Tripadvisor: Can be filtered to trash or separate folder")
+    print("   - eBay/Spotify: Promotional, low priority")
+
+    # Security alerts
+    security_count = category_counts.get('Security', 0)
+    print(f"\n2. SECURITY ALERTS: {security_count} ({security_count/len(emails)*100:.1f}%)")
+    print("   - Google security: Review for legitimate sign-in attempts")
+    print("   - Should NOT be auto-filtered")
+
+    # Business/Work
+    business_count = category_counts.get('Business', 0) + category_counts.get('Google', 0)
+    print(f"\n3. BUSINESS-RELATED: {business_count} ({business_count/len(emails)*100:.1f}%)")
+    print("   - Google Business Profile reports: Monthly review")
+    print("   - Job applications: High priority")
+    print("   - Appointments: Calendar integration")
+
+    # AI Services (professional interest)
+    ai_count = category_counts.get('AI Services', 0) + category_counts.get('Developer Tools', 0)
+    print(f"\n4. AI/DEVELOPER TOOLS: {ai_count} ({ai_count/len(emails)*100:.1f}%)")
+    print("   - Anthropic, OpenAI, Lambda: Keep for reference")
+    print("   - ngrok, Docker, Cursor: Developer updates")
+
+    # Personal
+    personal_count = category_counts.get('Personal', 0)
+    print(f"\n5. PERSONAL: {personal_count} ({personal_count/len(emails)*100:.1f}%)")
+    print("   - Gmail contacts: May need human review")
+    print("   - Microsoft/Outlook: Check for spam")
+
+    # Save analysis data
+    analysis_data = {
+        'metadata': {
+            'total_emails': len(emails),
+            'date_range': {
+                'start': str(dates[0]) if dates else None,
+                'end': str(dates[-1]) if dates else None
+            },
+            'analyzed_at': datetime.now().isoformat()
+        },
+        'categories': dict(category_counts),
+        'subcategories': dict(subcategory_counts),
+        'top_senders': dict(sender_counts.most_common(50)),
+        'time_distribution': time_dist,
+        'orders_found': orders,
+        'classification_accuracy': {
+            'categorized': len(emails) - category_counts.get('Uncategorized', 0),
+            'uncategorized': category_counts.get('Uncategorized', 0),
+            'accuracy_pct': (len(emails) - category_counts.get('Uncategorized', 0)) / len(emails) * 100
+        }
+    }
+
+    output_file = output_dir / "brett_gmail_analysis.json"
+    with open(output_file, 'w') as f:
+        json.dump(analysis_data, f, indent=2)
+
+    print(f"\n\nAnalysis saved to: {output_file}")
+    print("\n" + "="*70)
+    print(f"CLASSIFICATION ACCURACY: {analysis_data['classification_accuracy']['accuracy_pct']:.1f}%")
+    print(f"({analysis_data['classification_accuracy']['categorized']} categorized, "
+          f"{analysis_data['classification_accuracy']['uncategorized']} uncategorized)")
+    print("="*70)
+
+
+if __name__ == '__main__':
+    main()

tools/brett_microsoft_analyzer.py

@@ -0,0 +1,500 @@
+#!/usr/bin/env python3
+"""
+Brett Microsoft (Outlook) Dataset Analyzer
+==========================================
+CUSTOM script for analyzing the brett-microsoft email dataset.
+NOT portable to other datasets without modification.
+
+Usage:
+    python tools/brett_microsoft_analyzer.py
+
+Output:
+    - Console report with comprehensive statistics
+    - data/brett_microsoft_analysis.json with full analysis data
+"""
+
+import json
+import re
+from collections import Counter, defaultdict
+from datetime import datetime
+from pathlib import Path
+
+# Add parent to path for imports
+import sys
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from src.calibration.local_file_parser import LocalFileParser
+
+
+# =============================================================================
+# CLASSIFICATION RULES - CUSTOM FOR BRETT'S MICROSOFT/OUTLOOK INBOX
+# =============================================================================
+
+def classify_email(email):
+    """
+    Classify email into categories based on sender domain and subject patterns.
+
+    This is a BUSINESS inbox - different approach than personal Gmail.
+    Priority: Sender domain > Subject keywords > Business context
+    """
+    sender = email.sender or ""
+    subject = email.subject or ""
+    domain = sender.split('@')[-1] if '@' in sender else sender
+
+    # === BUSINESS OPERATIONS ===
+
+    # MYOB/Accounting
+    if 'apps.myob.com' in domain or 'myob' in subject.lower():
+        return ('Business Operations', 'MYOB Invoices')
+
+    # TPG/Telecom/Internet
+    if 'tpgtelecom.com.au' in domain or 'aapt.com.au' in domain:
+        if 'suspension' in subject.lower() or 'overdue' in subject.lower():
+            return ('Business Operations', 'Telecom - Urgent/Overdue')
+        if 'novation' in subject.lower():
+            return ('Business Operations', 'Telecom - Contract Changes')
+        if 'NBN' in subject or 'nbn' in subject.lower():
+            return ('Business Operations', 'Telecom - NBN')
+        return ('Business Operations', 'Telecom - General')
+
+    # DocuSign (Contracts)
+    if 'docusign' in domain or 'docusign' in subject.lower():
+        return ('Business Operations', 'DocuSign Contracts')
+
+    # === CLIENT WORK ===
+
+    # Green Output / Energy Avengers (App Development Client)
+    if 'greenoutput.com.au' in domain or 'energyavengers' in domain:
+        return ('Client Work', 'Energy Avengers Project')
+
+    # Brighter Access (Client)
+    if 'brighteraccess' in domain or 'Brighter Access' in subject:
+        return ('Client Work', 'Brighter Access')
+
+    # Waterfall Way Designs (Business Partner)
+    if 'waterfallwaydesigns' in domain:
+        return ('Client Work', 'Waterfall Way Designs')
+
+    # Target Impact
+    if 'targetimpact.com.au' in domain:
+        return ('Client Work', 'Target Impact')
+
+    # MerlinFX
+    if 'merlinfx.com.au' in domain:
+        return ('Client Work', 'MerlinFX')
+
+    # Solar/Energy related (Energy Avengers ecosystem)
+    if 'solarairenergy.com.au' in domain or 'solarconnected.com.au' in domain:
+        return ('Client Work', 'Energy Avengers Ecosystem')
+
+    if 'eonadvisory.com.au' in domain or 'australianpowerbrokers.com.au' in domain:
+        return ('Client Work', 'Energy Avengers Ecosystem')
+
+    if 'fyconsulting.com.au' in domain:
+        return ('Client Work', 'Energy Avengers Ecosystem')
+
+    if 'convergedesign.com.au' in domain:
+        return ('Client Work', 'Energy Avengers Ecosystem')
+
+    # MYP Corp (Disability Services Software)
+    if '1myp.com' in domain or 'mypcorp' in domain or 'MYP' in subject:
+        return ('Business Operations', 'MYP Software')
+
+    # === MICROSOFT SERVICES ===
+
+    # Microsoft Support Cases
+    if re.search(r'\[Case.*#|Case #|TrackingID', subject, re.I) or 'support.microsoft.com' in domain:
+        return ('Microsoft', 'Support Cases')
+
+    # Microsoft Billing/Invoices
+    if 'Microsoft invoice' in subject or 'credit card was declined' in subject:
+        return ('Microsoft', 'Billing')
+
+    # Microsoft Subscriptions
+    if 'subscription' in subject.lower() and 'microsoft' in sender.lower():
+        return ('Microsoft', 'Subscriptions')
+
+    # SharePoint/Teams
+    if 'sharepointonline.com' in domain or 'Teams' in subject:
+        return ('Microsoft', 'SharePoint/Teams')
+
+    # O365 Service Updates
+    if 'o365su' in sender or ('digest' in subject.lower() and 'microsoft' in sender.lower()):
+        return ('Microsoft', 'Service Updates')
+
+    # General Microsoft
+    if 'microsoft.com' in domain:
+        return ('Microsoft', 'General')
+
+    # === DEVELOPER TOOLS ===
+
+    # GitHub CI/CD
+    if re.search(r'\[FSSCoding', subject):
+        return ('Developer', 'GitHub CI/CD Failures')
+
+    # GitHub Issues/PRs
+    if 'github.com' in domain:
+        if 'linuxmint' in subject or 'cinnamon' in subject:
+            return ('Developer', 'Open Source Contributions')
+        if 'Pheromind' in subject or 'ChrisRoyse' in subject:
+            return ('Developer', 'GitHub Collaborations')
+        return ('Developer', 'GitHub Notifications')
+
+    # Neo4j
+    if 'neo4j.com' in domain:
+        if 'webinar' in subject.lower() or 'Webinar' in subject:
+            return ('Developer', 'Neo4j Webinars')
+        if 'NODES' in subject or 'GraphTalk' in subject:
+            return ('Developer', 'Neo4j Conference')
+        return ('Developer', 'Neo4j')
+
+    # Cursor (AI IDE)
+    if 'cursor.com' in domain or 'cursor.so' in domain or 'Cursor' in subject:
+        return ('Developer', 'Cursor IDE')
+
+    # Tailscale
+    if 'tailscale.com' in domain:
+        return ('Developer', 'Tailscale')
+
+    # Hugging Face
+    if 'huggingface' in domain or 'Hugging Face' in subject:
+        return ('Developer', 'Hugging Face')
+
+    # Stripe (Payment Failures)
+    if 'stripe.com' in domain:
+        return ('Billing', 'Stripe Payments')
+
+    # Contabo (Hosting)
+    if 'contabo.com' in domain:
+        return ('Developer', 'Contabo Hosting')
+
+    # SendGrid
+    if 'sendgrid' in subject.lower():
+        return ('Developer', 'SendGrid')
+
+    # Twilio
+    if 'twilio.com' in domain:
+        return ('Developer', 'Twilio')
+
+    # Brave Search API
+    if 'brave.com' in domain:
+        return ('Developer', 'Brave Search API')
+
+    # PyPI
+    if 'pypi' in subject.lower() or 'pypi.org' in domain:
+        return ('Developer', 'PyPI')
+
+    # NVIDIA/CUDA
+    if 'CUDA' in subject or 'nvidia' in domain:
+        return ('Developer', 'NVIDIA/CUDA')
+
+    # Inception Labs / AI Tools
+    if 'inceptionlabs.ai' in domain:
+        return ('Developer', 'AI Tools')
+
+    # === LEARNING ===
+
+    # Computer Enhance (Casey Muratori) / Substack
+    if 'computerenhance' in sender or 'substack.com' in domain:
+        return ('Learning', 'Substack/Newsletters')
+
+    # Odoo
+    if 'odoo.com' in domain:
+        return ('Learning', 'Odoo ERP')
+
+    # Mozilla Firefox
+    if 'mozilla.org' in domain:
+        return ('Developer', 'Mozilla Firefox')
+
+    # === PERSONAL / COMMUNITY ===
+
+    # Grandfather Gatherings (Personal Community)
+    if 'Grandfather Gather' in subject:
+        return ('Personal', 'Grandfather Gatherings')
+
+    # Mailchimp newsletters (often personal)
+    if 'mailchimpapp.com' in domain:
+        return ('Personal', 'Personal Newsletters')
+
+    # Community Events
+    if 'Community Working Bee' in subject:
+        return ('Personal', 'Community Events')
+
+    # Personal emails (Gmail/Hotmail)
+    if 'gmail.com' in domain or 'hotmail.com' in domain or 'bigpond.com' in domain:
+        return ('Personal', 'Personal Contacts')
+
+    # FSS Internal
+    if 'foxsoftwaresolutions.com.au' in domain:
+        return ('Business Operations', 'FSS Internal')
+
+    # === FINANCIAL ===
+
+    # eToro
+    if 'etoro.com' in domain:
+        return ('Financial', 'eToro Trading')
+
+    # Dell
+    if 'dell.com' in domain or 'Dell' in subject:
+        return ('Business Operations', 'Dell Hardware')
+
+    # Insurance
+    if 'KT Insurance' in subject or 'insurance' in subject.lower():
+        return ('Business Operations', 'Insurance')
+
+    # SBSCH Payments
+    if 'SBSCH' in subject:
+        return ('Business Operations', 'SBSCH Payments')
+
+    # iCare NSW
+    if 'icare.nsw.gov.au' in domain:
+        return ('Business Operations', 'iCare NSW')
+
+    # Vodafone
+    if 'vodafone.com.au' in domain:
+        return ('Business Operations', 'Telecom - Vodafone')
+
+    # === MISC ===
+
+    # Undeliverable/Bounces
+    if 'Undeliverable' in subject:
+        return ('System', 'Email Bounces')
+
+    # Security
+    if re.search(r'Security Alert|Login detected|security code|Verify', subject, re.I):
+        return ('Security', 'Security Alerts')
+
+    # Password Reset
+    if 'password' in subject.lower():
+        return ('Security', 'Password')
+
+    # Calendly
+    if 'calendly.com' in domain:
+        return ('Business Operations', 'Calendly')
+
+    # Trello
+    if 'trello.com' in domain:
+        return ('Business Operations', 'Trello')
+
+    # Scorptec
+    if 'scorptec' in domain:
+        return ('Business Operations', 'Hardware Vendor')
+
+    # Webcentral
+    if 'webcentral.com.au' in domain:
+        return ('Business Operations', 'Web Hosting')
+
+    # Bluetti (Hardware)
+    if 'bluettipower.com' in domain:
+        return ('Business Operations', 'Hardware - Power')
+
+    # ABS Surveys
+    if 'abs.gov.au' in domain:
+        return ('Business Operations', 'Government - ABS')
+
+    # Qualtrics/Surveys
+    if 'qualtrics' in domain:
+        return ('Business Operations', 'Surveys')
+
+    return ('Uncategorized', 'Unknown')
+
+
+def extract_case_ids(emails):
+    """Extract Microsoft support case IDs and tracking IDs from emails."""
+    case_patterns = [
+        (r'Case\s*#?\s*:?\s*(\d{8})', 'Microsoft Case'),
+        (r'\[Case\s*#?\s*:?\s*(\d{8})\]', 'Microsoft Case'),
+        (r'TrackingID#(\d{16})', 'Tracking ID'),
+    ]
+
+    cases = defaultdict(list)
+    for email in emails:
+        subject = email.subject or ""
+        for pattern, case_type in case_patterns:
+            match = re.search(pattern, subject, re.I)
+            if match:
+                case_id = match.group(1)
+                cases[case_id].append({
+                    'type': case_type,
+                    'subject': subject,
+                    'date': str(email.date) if email.date else None,
+                    'sender': email.sender
+                })
+    return dict(cases)
+
+
+def analyze_time_distribution(emails):
+    """Analyze email distribution over time."""
+    by_year = Counter()
+    by_month = Counter()
+    by_day_of_week = Counter()
+
+    day_names = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
+
+    for email in emails:
+        if email.date:
+            try:
+                by_year[email.date.year] += 1
+                by_month[f"{email.date.year}-{email.date.month:02d}"] += 1
+                by_day_of_week[day_names[email.date.weekday()]] += 1
+            except:
+                pass
+
+    return {
+        'by_year': dict(by_year.most_common()),
+        'by_month': dict(sorted(by_month.items())),
+        'by_day_of_week': {d: by_day_of_week.get(d, 0) for d in day_names}
+    }
+
+
+def main():
+    email_dir = "/home/bob/Documents/Email Manager/emails/brett-microsoft"
+    output_dir = Path(__file__).parent.parent / "data"
+    output_dir.mkdir(exist_ok=True)
+
+    print("="*70)
+    print("BRETT MICROSOFT (OUTLOOK) DATASET ANALYSIS")
+    print("="*70)
+    print(f"\nSource: {email_dir}")
+    print(f"Output: {output_dir}")
+
+    # Parse emails
+    print("\nParsing emails...")
+    parser = LocalFileParser(email_dir)
+    emails = parser.parse_emails()
+    print(f"Total emails: {len(emails)}")
+
+    # Date range
+    dates = [e.date for e in emails if e.date]
+    if dates:
+        dates.sort()
+        print(f"Date range: {dates[0].strftime('%Y-%m-%d')} to {dates[-1].strftime('%Y-%m-%d')}")
+
+    # Classify all emails
+    print("\nClassifying emails...")
+
+    category_counts = Counter()
+    subcategory_counts = Counter()
+    by_category = defaultdict(list)
+    by_subcategory = defaultdict(list)
+
+    for email in emails:
+        category, subcategory = classify_email(email)
+        category_counts[category] += 1
+        subcategory_counts[f"{category}: {subcategory}"] += 1
+        by_category[category].append(email)
+        by_subcategory[subcategory].append(email)
+
+    # Print category summary
+    print("\n" + "="*70)
+    print("TOP-LEVEL CATEGORY SUMMARY")
+    print("="*70)
+
+    for category, count in category_counts.most_common():
+        pct = count / len(emails) * 100
+        bar = "█" * int(pct / 2)
+        print(f"\n{category} ({count} emails, {pct:.1f}%)")
+        print(f"  {bar}")
+
+        # Show subcategories
+        subcats = Counter()
+        for email in by_category[category]:
+            _, subcat = classify_email(email)
+            subcats[subcat] += 1
+
+        for subcat, subcount in subcats.most_common():
+            print(f"    - {subcat}: {subcount}")
+
+    # Analyze senders
+    print("\n" + "="*70)
+    print("TOP SENDERS BY VOLUME")
+    print("="*70)
+
+    sender_counts = Counter(e.sender for e in emails)
+    for sender, count in sender_counts.most_common(15):
+        pct = count / len(emails) * 100
+        print(f"  {count:4d} ({pct:4.1f}%)  {sender}")
+
+    # Time analysis
+    print("\n" + "="*70)
+    print("TIME DISTRIBUTION")
+    print("="*70)
+
+    time_dist = analyze_time_distribution(emails)
+
+    print("\nBy Year:")
+    for year, count in sorted(time_dist['by_year'].items()):
+        bar = "█" * (count // 10)
+        print(f"  {year}: {count:4d} {bar}")
+
+    print("\nBy Day of Week:")
+    for day, count in time_dist['by_day_of_week'].items():
+        bar = "█" * (count // 5)
+        print(f"  {day}: {count:3d} {bar}")
+
+    # Extract case IDs
+    print("\n" + "="*70)
+    print("MICROSOFT SUPPORT CASES TRACKED")
+    print("="*70)
+
+    cases = extract_case_ids(emails)
+    if cases:
+        for case_id, occurrences in sorted(cases.items()):
+            print(f"\n  Case/Tracking: {case_id} ({len(occurrences)} emails)")
+            for occ in occurrences[:3]:
+                print(f"    - {occ['date']}: {occ['subject'][:50]}...")
+    else:
+        print("  No case IDs detected")
+
+    # Actionable insights
+    print("\n" + "="*70)
+    print("INBOX CHARACTER ASSESSMENT")
+    print("="*70)
+
+    business_pct = (category_counts.get('Business Operations', 0) +
+                    category_counts.get('Client Work', 0) +
+                    category_counts.get('Developer', 0)) / len(emails) * 100
+    personal_pct = category_counts.get('Personal', 0) / len(emails) * 100
+
+    print(f"\n  Business/Professional: {business_pct:.1f}%")
+    print(f"  Personal: {personal_pct:.1f}%")
+    print(f"\n  ASSESSMENT: This is a {'BUSINESS' if business_pct > 50 else 'MIXED'} inbox")
+
+    # Save analysis data
+    analysis_data = {
+        'metadata': {
+            'total_emails': len(emails),
+            'inbox_type': 'microsoft',
+            'inbox_character': 'business' if business_pct > 50 else 'mixed',
+            'date_range': {
+                'start': str(dates[0]) if dates else None,
+                'end': str(dates[-1]) if dates else None
+            },
+            'analyzed_at': datetime.now().isoformat()
+        },
+        'categories': dict(category_counts),
+        'subcategories': dict(subcategory_counts),
+        'top_senders': dict(sender_counts.most_common(50)),
+        'time_distribution': time_dist,
+        'support_cases': cases,
+        'classification_accuracy': {
+            'categorized': len(emails) - category_counts.get('Uncategorized', 0),
+            'uncategorized': category_counts.get('Uncategorized', 0),
+            'accuracy_pct': (len(emails) - category_counts.get('Uncategorized', 0)) / len(emails) * 100
+        }
+    }
+
+    output_file = output_dir / "brett_microsoft_analysis.json"
+    with open(output_file, 'w') as f:
+        json.dump(analysis_data, f, indent=2)
+
+    print(f"\n\nAnalysis saved to: {output_file}")
+    print("\n" + "="*70)
+    print(f"CLASSIFICATION ACCURACY: {analysis_data['classification_accuracy']['accuracy_pct']:.1f}%")
+    print(f"({analysis_data['classification_accuracy']['categorized']} categorized, "
+          f"{analysis_data['classification_accuracy']['uncategorized']} uncategorized)")
+    print("="*70)
+
+
+if __name__ == '__main__':
+    main()

tools/generate_html_report.py

@@ -0,0 +1,642 @@
+#!/usr/bin/env python3
+"""
+Generate interactive HTML report from email classification results.
+
+Usage:
+    python tools/generate_html_report.py --input results.json --output report.html
+"""
+
+import argparse
+import json
+from pathlib import Path
+from datetime import datetime
+from collections import Counter, defaultdict
+from html import escape
+
+
+def load_results(input_path: str) -> dict:
+    """Load classification results from JSON."""
+    with open(input_path) as f:
+        return json.load(f)
+
+
+def extract_domain(sender: str) -> str:
+    """Extract domain from email address."""
+    if not sender:
+        return "unknown"
+    if "@" in sender:
+        return sender.split("@")[-1].lower()
+    return sender.lower()
+
+
+def format_date(date_str: str) -> str:
+    """Format ISO date string for display."""
+    if not date_str:
+        return "N/A"
+    try:
+        dt = datetime.fromisoformat(date_str.replace("Z", "+00:00"))
+        return dt.strftime("%Y-%m-%d %H:%M")
+    except:
+        return date_str[:16] if len(date_str) > 16 else date_str
+
+
+def truncate(text: str, max_len: int = 60) -> str:
+    """Truncate text with ellipsis."""
+    if not text:
+        return ""
+    if len(text) <= max_len:
+        return text
+    return text[:max_len-3] + "..."
+
+
+def generate_html_report(results: dict, output_path: str):
+    """Generate interactive HTML report."""
+
+    metadata = results.get("metadata", {})
+    classifications = results.get("classifications", [])
+
+    # Calculate statistics
+    total = len(classifications)
+    categories = Counter(c["category"] for c in classifications)
+    methods = Counter(c["method"] for c in classifications)
+
+    # Group by category
+    by_category = defaultdict(list)
+    for c in classifications:
+        by_category[c["category"]].append(c)
+
+    # Sort categories by count
+    sorted_categories = sorted(categories.keys(), key=lambda x: categories[x], reverse=True)
+
+    # Sender statistics
+    sender_domains = Counter(extract_domain(c.get("sender", "")) for c in classifications)
+    top_senders = Counter(c.get("sender", "unknown") for c in classifications).most_common(20)
+
+    # Confidence distribution
+    high_conf = sum(1 for c in classifications if c.get("confidence", 0) >= 0.7)
+    med_conf = sum(1 for c in classifications if 0.5 <= c.get("confidence", 0) < 0.7)
+    low_conf = sum(1 for c in classifications if c.get("confidence", 0) < 0.5)
+
+    # Generate HTML
+    html = f'''<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Email Classification Report</title>
+    <style>
+        :root {{
+            --bg-primary: #1a1a2e;
+            --bg-secondary: #16213e;
+            --bg-card: #0f3460;
+            --text-primary: #eee;
+            --text-secondary: #aaa;
+            --accent: #e94560;
+            --accent-hover: #ff6b6b;
+            --success: #00d9a5;
+            --warning: #ffc107;
+            --border: #2a2a4a;
+        }}
+
+        * {{
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }}
+
+        body {{
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+            background: var(--bg-primary);
+            color: var(--text-primary);
+            line-height: 1.6;
+        }}
+
+        .container {{
+            max-width: 1400px;
+            margin: 0 auto;
+            padding: 20px;
+        }}
+
+        header {{
+            background: var(--bg-secondary);
+            padding: 30px;
+            border-radius: 12px;
+            margin-bottom: 30px;
+            border: 1px solid var(--border);
+        }}
+
+        header h1 {{
+            font-size: 2rem;
+            margin-bottom: 10px;
+            color: var(--accent);
+        }}
+
+        .meta-info {{
+            display: flex;
+            flex-wrap: wrap;
+            gap: 20px;
+            margin-top: 15px;
+            color: var(--text-secondary);
+            font-size: 0.9rem;
+        }}
+
+        .meta-info span {{
+            background: var(--bg-card);
+            padding: 5px 12px;
+            border-radius: 20px;
+        }}
+
+        .stats-grid {{
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 20px;
+            margin-bottom: 30px;
+        }}
+
+        .stat-card {{
+            background: var(--bg-secondary);
+            padding: 20px;
+            border-radius: 12px;
+            border: 1px solid var(--border);
+            text-align: center;
+        }}
+
+        .stat-card .value {{
+            font-size: 2.5rem;
+            font-weight: bold;
+            color: var(--accent);
+        }}
+
+        .stat-card .label {{
+            color: var(--text-secondary);
+            font-size: 0.9rem;
+            margin-top: 5px;
+        }}
+
+        .tabs {{
+            display: flex;
+            flex-wrap: wrap;
+            gap: 10px;
+            margin-bottom: 20px;
+            border-bottom: 2px solid var(--border);
+            padding-bottom: 10px;
+        }}
+
+        .tab {{
+            padding: 10px 20px;
+            background: var(--bg-secondary);
+            border: 1px solid var(--border);
+            border-radius: 8px 8px 0 0;
+            cursor: pointer;
+            transition: all 0.2s;
+            color: var(--text-secondary);
+        }}
+
+        .tab:hover {{
+            background: var(--bg-card);
+            color: var(--text-primary);
+        }}
+
+        .tab.active {{
+            background: var(--accent);
+            color: white;
+            border-color: var(--accent);
+        }}
+
+        .tab .count {{
+            background: rgba(255,255,255,0.2);
+            padding: 2px 8px;
+            border-radius: 10px;
+            font-size: 0.8rem;
+            margin-left: 8px;
+        }}
+
+        .tab-content {{
+            display: none;
+        }}
+
+        .tab-content.active {{
+            display: block;
+        }}
+
+        .email-table {{
+            width: 100%;
+            border-collapse: collapse;
+            background: var(--bg-secondary);
+            border-radius: 12px;
+            overflow: hidden;
+        }}
+
+        .email-table th {{
+            background: var(--bg-card);
+            padding: 15px;
+            text-align: left;
+            font-weight: 600;
+            color: var(--text-primary);
+            position: sticky;
+            top: 0;
+        }}
+
+        .email-table td {{
+            padding: 12px 15px;
+            border-bottom: 1px solid var(--border);
+            color: var(--text-secondary);
+        }}
+
+        .email-table tr:hover td {{
+            background: var(--bg-card);
+            color: var(--text-primary);
+        }}
+
+        .email-table .subject {{
+            max-width: 400px;
+            color: var(--text-primary);
+        }}
+
+        .email-table .sender {{
+            max-width: 250px;
+        }}
+
+        .confidence {{
+            display: inline-block;
+            padding: 3px 10px;
+            border-radius: 12px;
+            font-size: 0.85rem;
+            font-weight: 500;
+        }}
+
+        .confidence.high {{
+            background: rgba(0, 217, 165, 0.2);
+            color: var(--success);
+        }}
+
+        .confidence.medium {{
+            background: rgba(255, 193, 7, 0.2);
+            color: var(--warning);
+        }}
+
+        .confidence.low {{
+            background: rgba(233, 69, 96, 0.2);
+            color: var(--accent);
+        }}
+
+        .method-badge {{
+            display: inline-block;
+            padding: 3px 8px;
+            border-radius: 4px;
+            font-size: 0.75rem;
+            text-transform: uppercase;
+        }}
+
+        .method-ml {{
+            background: rgba(0, 217, 165, 0.2);
+            color: var(--success);
+        }}
+
+        .method-rule {{
+            background: rgba(100, 149, 237, 0.2);
+            color: cornflowerblue;
+        }}
+
+        .method-llm {{
+            background: rgba(255, 193, 7, 0.2);
+            color: var(--warning);
+        }}
+
+        .section {{
+            background: var(--bg-secondary);
+            padding: 25px;
+            border-radius: 12px;
+            margin-bottom: 30px;
+            border: 1px solid var(--border);
+        }}
+
+        .section h2 {{
+            margin-bottom: 20px;
+            color: var(--accent);
+            font-size: 1.3rem;
+        }}
+
+        .chart-bar {{
+            display: flex;
+            align-items: center;
+            margin-bottom: 10px;
+        }}
+
+        .chart-bar .label {{
+            width: 150px;
+            font-size: 0.9rem;
+            color: var(--text-secondary);
+        }}
+
+        .chart-bar .bar-container {{
+            flex: 1;
+            height: 24px;
+            background: var(--bg-card);
+            border-radius: 4px;
+            overflow: hidden;
+            margin: 0 15px;
+        }}
+
+        .chart-bar .bar {{
+            height: 100%;
+            background: linear-gradient(90deg, var(--accent), var(--accent-hover));
+            transition: width 0.5s ease;
+        }}
+
+        .chart-bar .value {{
+            width: 80px;
+            text-align: right;
+            font-size: 0.9rem;
+        }}
+
+        .sender-list {{
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+            gap: 10px;
+        }}
+
+        .sender-item {{
+            display: flex;
+            justify-content: space-between;
+            padding: 10px 15px;
+            background: var(--bg-card);
+            border-radius: 8px;
+            font-size: 0.9rem;
+        }}
+
+        .sender-item .email {{
+            color: var(--text-secondary);
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+            max-width: 220px;
+        }}
+
+        .sender-item .count {{
+            color: var(--accent);
+            font-weight: bold;
+        }}
+
+        .search-box {{
+            width: 100%;
+            padding: 12px 20px;
+            background: var(--bg-card);
+            border: 1px solid var(--border);
+            border-radius: 8px;
+            color: var(--text-primary);
+            font-size: 1rem;
+            margin-bottom: 20px;
+        }}
+
+        .search-box:focus {{
+            outline: none;
+            border-color: var(--accent);
+        }}
+
+        .table-container {{
+            max-height: 600px;
+            overflow-y: auto;
+            border-radius: 12px;
+        }}
+
+        .attachment-icon {{
+            color: var(--warning);
+        }}
+
+        footer {{
+            text-align: center;
+            padding: 20px;
+            color: var(--text-secondary);
+            font-size: 0.85rem;
+        }}
+    </style>
+</head>
+<body>
+    <div class="container">
+        <header>
+            <h1>Email Classification Report</h1>
+            <p>Automated analysis of email inbox</p>
+            <div class="meta-info">
+                <span>Generated: {datetime.now().strftime("%Y-%m-%d %H:%M")}</span>
+                <span>Source: {escape(metadata.get("source", "unknown"))}</span>
+                <span>Total Emails: {total:,}</span>
+            </div>
+        </header>
+
+        <div class="stats-grid">
+            <div class="stat-card">
+                <div class="value">{total:,}</div>
+                <div class="label">Total Emails</div>
+            </div>
+            <div class="stat-card">
+                <div class="value">{len(categories)}</div>
+                <div class="label">Categories</div>
+            </div>
+            <div class="stat-card">
+                <div class="value">{high_conf}</div>
+                <div class="label">High Confidence (&ge;70%)</div>
+            </div>
+            <div class="stat-card">
+                <div class="value">{len(sender_domains)}</div>
+                <div class="label">Unique Domains</div>
+            </div>
+        </div>
+
+        <div class="section">
+            <h2>Category Distribution</h2>
+            {"".join(f'''
+            <div class="chart-bar">
+                <div class="label">{escape(cat)}</div>
+                <div class="bar-container">
+                    <div class="bar" style="width: {categories[cat]/total*100:.1f}%"></div>
+                </div>
+                <div class="value">{categories[cat]:,} ({categories[cat]/total*100:.1f}%)</div>
+            </div>
+            ''' for cat in sorted_categories)}
+        </div>
+
+        <div class="section">
+            <h2>Classification Methods</h2>
+            {"".join(f'''
+            <div class="chart-bar">
+                <div class="label">{escape(method.upper())}</div>
+                <div class="bar-container">
+                    <div class="bar" style="width: {methods[method]/total*100:.1f}%"></div>
+                </div>
+                <div class="value">{methods[method]:,} ({methods[method]/total*100:.1f}%)</div>
+            </div>
+            ''' for method in sorted(methods.keys()))}
+        </div>
+
+        <div class="section">
+            <h2>Confidence Distribution</h2>
+            <div class="chart-bar">
+                <div class="label">High (&ge;70%)</div>
+                <div class="bar-container">
+                    <div class="bar" style="width: {high_conf/total*100:.1f}%; background: linear-gradient(90deg, #00d9a5, #00ffcc);"></div>
+                </div>
+                <div class="value">{high_conf:,} ({high_conf/total*100:.1f}%)</div>
+            </div>
+            <div class="chart-bar">
+                <div class="label">Medium (50-70%)</div>
+                <div class="bar-container">
+                    <div class="bar" style="width: {med_conf/total*100:.1f}%; background: linear-gradient(90deg, #ffc107, #ffdb58);"></div>
+                </div>
+                <div class="value">{med_conf:,} ({med_conf/total*100:.1f}%)</div>
+            </div>
+            <div class="chart-bar">
+                <div class="label">Low (&lt;50%)</div>
+                <div class="bar-container">
+                    <div class="bar" style="width: {low_conf/total*100:.1f}%; background: linear-gradient(90deg, #e94560, #ff6b6b);"></div>
+                </div>
+                <div class="value">{low_conf:,} ({low_conf/total*100:.1f}%)</div>
+            </div>
+        </div>
+
+        <div class="section">
+            <h2>Top Senders</h2>
+            <div class="sender-list">
+                {"".join(f'''
+                <div class="sender-item">
+                    <span class="email" title="{escape(sender)}">{escape(truncate(sender, 35))}</span>
+                    <span class="count">{count}</span>
+                </div>
+                ''' for sender, count in top_senders)}
+            </div>
+        </div>
+
+        <div class="section">
+            <h2>Emails by Category</h2>
+
+            <div class="tabs">
+                <div class="tab active" onclick="showTab('all')">All<span class="count">{total}</span></div>
+                {"".join(f'''<div class="tab" onclick="showTab('{escape(cat)}')">{escape(cat)}<span class="count">{categories[cat]}</span></div>''' for cat in sorted_categories)}
+            </div>
+
+            <input type="text" class="search-box" placeholder="Search by subject, sender..." onkeyup="filterTable(this.value)">
+
+            <div id="tab-all" class="tab-content active">
+                <div class="table-container">
+                    <table class="email-table" id="email-table-all">
+                        <thead>
+                            <tr>
+                                <th>Date</th>
+                                <th>Subject</th>
+                                <th>Sender</th>
+                                <th>Category</th>
+                                <th>Confidence</th>
+                                <th>Method</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            {"".join(generate_email_row(c) for c in sorted(classifications, key=lambda x: x.get("date") or "", reverse=True))}
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+
+            {"".join(f'''
+            <div id="tab-{escape(cat)}" class="tab-content">
+                <div class="table-container">
+                    <table class="email-table">
+                        <thead>
+                            <tr>
+                                <th>Date</th>
+                                <th>Subject</th>
+                                <th>Sender</th>
+                                <th>Confidence</th>
+                                <th>Method</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            {"".join(generate_email_row(c, show_category=False) for c in sorted(by_category[cat], key=lambda x: x.get("date") or "", reverse=True))}
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+            ''' for cat in sorted_categories)}
+        </div>
+
+        <footer>
+            Generated by Email Sorter | {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
+        </footer>
+    </div>
+
+    <script>
+        function showTab(tabId) {{
+            // Hide all tabs
+            document.querySelectorAll('.tab-content').forEach(el => el.classList.remove('active'));
+            document.querySelectorAll('.tab').forEach(el => el.classList.remove('active'));
+
+            // Show selected tab
+            document.getElementById('tab-' + tabId).classList.add('active');
+            event.target.classList.add('active');
+        }}
+
+        function filterTable(query) {{
+            query = query.toLowerCase();
+            document.querySelectorAll('.tab-content.active tbody tr').forEach(row => {{
+                const text = row.textContent.toLowerCase();
+                row.style.display = text.includes(query) ? '' : 'none';
+            }});
+        }}
+    </script>
+</body>
+</html>
+'''
+
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write(html)
+
+    print(f"Report generated: {output_path}")
+    print(f"  Total emails: {total:,}")
+    print(f"  Categories: {len(categories)}")
+    print(f"  Top category: {sorted_categories[0]} ({categories[sorted_categories[0]]:,})")
+
+
+def generate_email_row(c: dict, show_category: bool = True) -> str:
+    """Generate HTML table row for an email."""
+    conf = c.get("confidence", 0)
+    conf_class = "high" if conf >= 0.7 else "medium" if conf >= 0.5 else "low"
+    method = c.get("method", "unknown")
+    method_class = f"method-{method}"
+
+    attachment_icon = '<span class="attachment-icon" title="Has attachments">📎</span> ' if c.get("has_attachments") else ""
+
+    category_col = f'<td>{escape(c.get("category", "unknown"))}</td>' if show_category else ""
+
+    return f'''
+        <tr data-search="{escape(c.get('subject', ''))} {escape(c.get('sender', ''))}">
+            <td>{format_date(c.get("date"))}</td>
+            <td class="subject">{attachment_icon}{escape(truncate(c.get("subject", "No subject"), 70))}</td>
+            <td class="sender" title="{escape(c.get('sender', ''))}">{escape(truncate(c.get("sender_name") or c.get("sender", ""), 35))}</td>
+            {category_col}
+            <td><span class="confidence {conf_class}">{conf*100:.0f}%</span></td>
+            <td><span class="method-badge {method_class}">{method}</span></td>
+        </tr>
+    '''
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate HTML report from classification results")
+    parser.add_argument("--input", "-i", required=True, help="Path to results.json")
+    parser.add_argument("--output", "-o", default=None, help="Output HTML file path")
+
+    args = parser.parse_args()
+
+    input_path = Path(args.input)
+    if not input_path.exists():
+        print(f"Error: Input file not found: {input_path}")
+        return 1
+
+    output_path = args.output or str(input_path.parent / "report.html")
+
+    results = load_results(args.input)
+    generate_html_report(results, output_path)
+
+    return 0
+
+
+if __name__ == "__main__":
+    exit(main())