feat: dark theme, hover text fixes, login RLS token, AI provider fallback, status cards rendering, optional cutoff, improved error visibility

.streamlit/secrets.toml

@@ -0,0 +1,15 @@
+# Supabase connection
+SUPABASE_URL = "https://oudjcqhyldpncjbxohsg.supabase.co"
+SUPABASE_KEY ="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im91ZGpjcWh5bGRwbmNqYnhvaHNnIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTUzMDgyNDQsImV4cCI6MjA3MDg4NDI0NH0.SYwTtCe3r7WOZ25CRggL-lBkvGPjKnQhY_dT4Kjv9Dg"
+
+# App settings
+APP_TZ = "America/Toronto"
+
+# Hugging Face
+HF_TOKEN = "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"
+
+# Optional VLM model provider
+PROVIDER = "nebius"
+GEMMA_MODEL = "google/gemma-3-27b-it"
+NEBIUS_API_KEY = "eyJhbGciOiJIUzI1NiIsImtpZCI6IlV6SXJWd1h0dnprLVRvdzlLZWstc0M1akptWXBvX1VaVkxUZlpnMDRlOFUiLCJ0eXAiOiJKV1QifQ.eyJzdWIiOiJnb29nbGUtb2F1dGgyfDEwMjk4MzMxNjQ1OTQzNjA5ODYxMyIsInNjb3BlIjoib3BlbmlkIG9mZmxpbmVfYWNjZXNzIiwiaXNzIjoiYXBpX2tleV9pc3N1ZXIiLCJhdWQiOlsiaHR0cHM6Ly9uZWJpdXMtaW5mZXJlbmNlLmV1LmF1dGgwLmNvbS9hcGkvdjIvIl0sImV4cCI6MTkxNTEzMTE3MiwidXVpZCI6IjJmOTUxZmM1LWEyNTgtNDg5OC1iNWI4LTkwZTljY2RkZjU2NSIsIm5hbWUiOiJjYXJlIGNvdW50IGFwcCIsImV4cGlyZXNfYXQiOiIyMDMwLTA5LTA4VDIwOjUyOjUyKzAwMDAifQ.awAHOieD93pCnYmFMgRQ64-i6yZdO0XvXczD4eS6xEI"
+NEBIUS_BASE_URL = "https://api.nebius.ai/v1"

.streamlit/secrets_backup_20250923_195857.toml

@@ -0,0 +1,15 @@
+# Supabase connection
+SUPABASE_URL = "https://oudjcqhyldpncjbxohsg.supabase.co"
+SUPABASE_KEY ="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im91ZGpjcWh5bGRwbmNqYnhvaHNnIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTUzMDgyNDQsImV4cCI6MjA3MDg4NDI0NH0.SYwTtCe3r7WOZ25CRggL-lBkvGPjKnQhY_dT4Kjv9Dg"
+
+# App settings
+APP_TZ = "America/Toronto"
+
+# Hugging Face
+HF_TOKEN = "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"
+
+# Optional VLM model provider
+PROVIDER = "nebius"
+GEMMA_MODEL = "google/gemma-3-27b-it"
+NEBIUS_API_KEY = "eyJhbGciOiJIUzI1NiIsImtpZCI6IlV6SXJWd1h0dnprLVRvdzlLZWstc0M1akptWXBvX1VaVkxUZlpnMDRlOFUiLCJ0eXAiOiJKV1QifQ.eyJzdWIiOiJnb29nbGUtb2F1dGgyfDEwMjk4MzMxNjQ1OTQzNjA5ODYxMyIsInNjb3BlIjoib3BlbmlkIG9mZmxpbmVfYWNjZXNzIiwiaXNzIjoiYXBpX2tleV9pc3N1ZXIiLCJhdWQiOlsiaHR0cHM6Ly9uZWJpdXMtaW5mZXJlbmNlLmV1LmF1dGgwLmNvbS9hcGkvdjIvIl0sImV4cCI6MTkxNTEzMTE3MiwidXVpZCI6IjJmOTUxZmM1LWEyNTgtNDg5OC1iNWI4LTkwZTljY2RkZjU2NSIsIm5hbWUiOiJjYXJlIGNvdW50IGFwcCIsImV4cGlyZXNfYXQiOiIyMDMwLTA5LTA4VDIwOjUyOjUyKzAwMDAifQ.awAHOieD93pCnYmFMgRQ64-i6yZdO0XvXczD4eS6xEI"
+NEBIUS_BASE_URL = "https://api.nebius.ai/v1"

COLOR_SCHEME_UPDATE.md

@@ -0,0 +1,85 @@
+# Care Count - Laurier University Color Scheme Update
+
+## 🎨 Color Scheme Changes
+
+The Care Count app has been updated to match the Wilfrid Laurier University website color scheme for a more professional and cohesive brand experience.
+
+### Updated Color Palette
+
+| Element | Old Color | New Color | Description |
+|---------|-----------|-----------|-------------|
+| **Primary Purple** | `#6d28d9` | `#6b46c1` | More vibrant Laurier purple |
+| **Primary Gold** | `#fde047` | `#fbbf24` | Warmer, more professional gold |
+| **Background** | `#0b1420` (dark) | `#f9fafb` (light gray) | Clean, light background |
+| **Secondary Background** | `#0f1a2a` (dark) | `#312e81` (purple) | Subtle purple accent |
+| **Card Background** | Dark theme | White | Clean, professional cards |
+| **Text Color** | `#f3f4f6` (light) | `#1f2937` (dark) | High contrast dark text |
+
+### Design Changes
+
+#### 1. **Hero Section**
+- **Background**: Solid Laurier purple (`#6b46c1`)
+- **Layout**: Left-aligned text (matching Laurier website)
+- **Typography**: Larger, more prominent headings
+- **Effects**: Subtle gradient overlay for depth
+
+#### 2. **Cards & Components**
+- **Background**: Clean white cards with subtle shadows
+- **Borders**: Light gray borders with purple hover effects
+- **Hover Effects**: Subtle lift animation with purple accent
+
+#### 3. **Status Cards**
+- **Background**: White with light shadows
+- **Values**: Purple text for metrics
+- **Labels**: Dark gray for better readability
+
+#### 4. **Form Elements**
+- **Inputs**: White background with light gray borders
+- **Focus States**: Purple border with subtle glow
+- **Buttons**: Laurier purple with white text
+
+#### 5. **Overall Layout**
+- **Background**: Light gray (`#f9fafb`) for better readability
+- **Typography**: Dark text for high contrast
+- **Spacing**: Consistent with Laurier design principles
+
+### Benefits of the New Color Scheme
+
+1. **Brand Consistency**: Matches Laurier University's official colors
+2. **Better Readability**: Light background with dark text improves accessibility
+3. **Professional Appearance**: Clean, modern design that builds trust
+4. **Improved Contrast**: Better visibility for all users
+5. **Mobile Friendly**: Light theme works better on mobile devices
+
+### Technical Implementation
+
+The color scheme is implemented using CSS custom properties (variables) in the `ui_improvements.py` file:
+
+```css
+:root {
+    --primary-purple: #6b46c1;  /* Laurier purple */
+    --primary-gold: #fbbf24;    /* Laurier gold */
+    --primary-dark: #1e1b4b;    /* Deep purple background */
+    --secondary-dark: #312e81;  /* Slightly lighter purple */
+    /* ... other colors */
+}
+```
+
+### Accessibility Improvements
+
+- **High Contrast**: Dark text on light background meets WCAG guidelines
+- **Focus States**: Clear purple focus indicators
+- **Color Independence**: Information not conveyed by color alone
+- **Readable Typography**: Improved font weights and sizes
+
+### Future Considerations
+
+The new color scheme provides a solid foundation for:
+- **Dark Mode Toggle**: Easy to implement with CSS variables
+- **Brand Customization**: Colors can be easily adjusted
+- **Seasonal Themes**: Framework supports theme variations
+- **Accessibility**: Built-in support for high contrast modes
+
+---
+
+**Result**: The Care Count app now has a professional, Laurier-branded appearance that matches the university's website while maintaining excellent usability and accessibility.

DEPLOYMENT_QUICK_REFERENCE.md

@@ -0,0 +1,157 @@
+# Care Count - Deployment Quick Reference
+
+## 🚀 Quick Commands
+
+### Start the App
+```bash
+streamlit run streamlit_app.py
+```
+**Access at:** http://localhost:8501
+
+### Test the App
+```bash
+# Run all tests
+python test_app.py test
+
+# Create backup
+python test_app.py backup "description"
+
+# Restore from backup
+python test_app.py restore backup_name
+```
+
+### Deploy Modern UI
+```bash
+# Deploy with testing
+python deploy_modern.py deploy
+
+# List backups
+python deploy_modern.py list
+
+# Rollback
+python deploy_modern.py rollback backup_name
+
+# Test only
+python deploy_modern.py test
+```
+
+## 📁 Important Files
+
+| File | Purpose |
+|------|---------|
+| `streamlit_app.py` | Main app (now modern version) |
+| `streamlit_app_modern.py` | Modern UI source |
+| `ui_improvements.py` | UI component library |
+| `test_app.py` | Testing framework |
+| `deploy_modern.py` | Deployment script |
+| `.streamlit/secrets.toml` | Configuration |
+| `backups/` | Automatic backups |
+
+## 🔧 Configuration
+
+### Required Secrets
+```toml
+# .streamlit/secrets.toml
+SUPABASE_URL = "https://your-project.supabase.co"
+SUPABASE_KEY = "your-anon-key"
+```
+
+### Optional Configuration
+```toml
+APP_TZ = "America/Toronto"
+CUTOFF_HOUR = "20"
+INACTIVITY_MIN = "30"
+PROVIDER = "nebius"
+GEMMA_MODEL = "google/gemma-3-27b-it"
+```
+
+## 🧪 Testing Checklist
+
+- [ ] App starts without errors
+- [ ] Authentication flow works
+- [ ] Visit management functions
+- [ ] Item identification works
+- [ ] Item logging functions
+- [ ] Responsive design works
+- [ ] All buttons and forms work
+
+## 🚨 Troubleshooting
+
+### App Won't Start
+1. Check if port 8501 is free
+2. Verify all dependencies installed
+3. Check secrets configuration
+4. Review error logs
+
+### Authentication Issues
+1. Verify Supabase URL and key
+2. Check network connectivity
+3. Review OTP email delivery
+4. Check database permissions
+
+### UI Issues
+1. Clear browser cache
+2. Check for JavaScript errors
+3. Verify CSS loading
+4. Test on different browsers
+
+### Rollback Process
+1. List available backups: `python deploy_modern.py list`
+2. Rollback to previous version: `python deploy_modern.py rollback backup_name`
+3. Verify app functionality
+4. Check logs for issues
+
+## 📊 Monitoring
+
+### Log Files
+- `care_count.log` - Application logs
+- `test_results.log` - Test results
+- `deployment.log` - Deployment logs
+- `backups/deployment_log_*.json` - Deployment history
+
+### Health Checks
+- App accessible at http://localhost:8501
+- All UI elements loading
+- Database connectivity working
+- AI services responding
+
+## 🔄 Maintenance
+
+### Daily
+- Check app accessibility
+- Review error logs
+- Monitor performance
+
+### Weekly
+- Run comprehensive tests
+- Review user feedback
+- Check backup integrity
+
+### Monthly
+- Update dependencies
+- Review security logs
+- Performance optimization
+
+## 📞 Emergency Procedures
+
+### App Down
+1. Check if process is running
+2. Review error logs
+3. Restart app: `streamlit run streamlit_app.py`
+4. If issues persist, rollback to last working version
+
+### Data Issues
+1. Check database connectivity
+2. Verify Supabase configuration
+3. Review data integrity
+4. Contact database administrator
+
+### Security Concerns
+1. Review access logs
+2. Check for unauthorized access
+3. Verify authentication flow
+4. Update credentials if needed
+
+---
+
+**Remember:** Always create a backup before making changes!

UI_IMPROVEMENTS_GUIDE.md

@@ -0,0 +1,287 @@
+# Care Count - Modern UI/UX Improvements Guide
+
+## 🎯 Overview
+
+This guide documents the comprehensive UI/UX improvements made to the Care Count application, bringing it to industry-standard quality while maintaining all backend functionality.
+
+## 🚀 What's New
+
+### 1. Modern Design System
+- **Industry-standard color palette** with Laurier theme (purple & gold)
+- **Consistent typography** using Inter font family
+- **Responsive design** that works on all devices
+- **Accessibility improvements** with proper focus states and ARIA labels
+- **Modern shadows and animations** for better visual hierarchy
+
+### 2. Enhanced User Experience
+- **Improved authentication flow** with better error handling
+- **Modern form components** with better validation
+- **Enhanced status cards** with real-time updates
+- **Better visual feedback** for all user actions
+- **Improved loading states** and progress indicators
+
+### 3. Professional UI Components
+- **Modern cards and containers** with hover effects
+- **Enhanced buttons** with proper states (primary, secondary, danger)
+- **Better form inputs** with improved styling
+- **Professional badges** for status indicators
+- **Responsive grid layouts** for better organization
+
+## 📁 File Structure
+
+```
+care-count-starter/
+├── streamlit_app.py              # Original app (backed up)
+├── streamlit_app_modern.py       # Modern UI version
+├── ui_improvements.py            # UI component library
+├── test_app.py                   # Testing framework
+├── deploy_modern.py              # Deployment script
+├── backups/                      # Automatic backups
+│   ├── backup_YYYYMMDD_HHMMSS/
+│   └── deployment_log_*.json
+└── UI_IMPROVEMENTS_GUIDE.md      # This guide
+```
+
+## 🛠️ Key Improvements
+
+### Authentication Flow
+- **Modern hero section** with gradient background
+- **Better form validation** with clear error messages
+- **Enhanced OTP verification** with improved UX
+- **Professional loading states** during authentication
+
+### Dashboard
+- **Modern status cards** with hover effects
+- **Real-time metrics** with better visual presentation
+- **Responsive grid layout** that adapts to screen size
+- **Professional typography** with proper hierarchy
+
+### Visit Management
+- **Enhanced visit tracking** with better visual feedback
+- **Modern button styling** with proper states
+- **Improved form layouts** with better spacing
+- **Professional status indicators**
+
+### Item Identification
+- **Better camera interface** with improved styling
+- **Enhanced file upload** with drag-and-drop styling
+- **Modern AI feedback** with processing indicators
+- **Professional result display**
+
+### Item Logging
+- **Improved form design** with better organization
+- **Enhanced validation** with clear error messages
+- **Modern input styling** with focus states
+- **Professional success/error feedback**
+
+## 🧪 Testing & Quality Assurance
+
+### Automated Testing
+- **Comprehensive test suite** (`test_app.py`)
+- **UI element validation** to ensure all components work
+- **Performance testing** for load times and responsiveness
+- **Accessibility testing** for proper focus management
+
+### Safe Deployment
+- **Automatic backups** before any changes
+- **Rollback capability** to previous versions
+- **Deployment logging** for audit trails
+- **Error handling** with graceful fallbacks
+
+## 🔧 Usage Instructions
+
+### Running the Modern App
+```bash
+# The modern app is now the default
+streamlit run streamlit_app.py
+```
+
+### Testing the App
+```bash
+# Run comprehensive tests
+python test_app.py test
+
+# Create a backup
+python test_app.py backup "description"
+
+# Restore from backup
+python test_app.py restore backup_name
+```
+
+### Deployment Management
+```bash
+# Deploy modern UI (with testing)
+python deploy_modern.py deploy
+
+# List available backups
+python deploy_modern.py list
+
+# Rollback to previous version
+python deploy_modern.py rollback backup_name
+
+# Run tests only
+python deploy_modern.py test
+```
+
+## 🎨 Design System
+
+### Color Palette
+- **Primary Purple**: `#6d28d9` - Main brand color
+- **Primary Gold**: `#fde047` - Accent color
+- **Dark Background**: `#0b1420` - Main background
+- **Secondary Dark**: `#0f1a2a` - Card backgrounds
+- **Accent Blue**: `#3b82f6` - Information elements
+- **Success Green**: `#10b981` - Success states
+- **Warning Orange**: `#f59e0b` - Warning states
+- **Error Red**: `#ef4444` - Error states
+
+### Typography
+- **Font Family**: Inter (system fallbacks)
+- **Headings**: 700 weight, -0.025em letter spacing
+- **Body Text**: 400 weight, 1.6 line height
+- **Small Text**: 0.75rem for captions
+
+### Spacing System
+- **Base Unit**: 0.25rem (4px)
+- **Common Spacing**: 1rem, 1.5rem, 2rem, 3rem
+- **Component Padding**: 1rem to 2rem
+- **Grid Gaps**: 1rem to 1.5rem
+
+### Border Radius
+- **Small**: 0.375rem (6px)
+- **Medium**: 0.5rem (8px)
+- **Large**: 0.75rem (12px)
+- **Extra Large**: 1rem (16px)
+
+## 📱 Responsive Design
+
+### Breakpoints
+- **Mobile**: < 768px
+- **Tablet**: 768px - 1024px
+- **Desktop**: > 1024px
+
+### Mobile Optimizations
+- **Single column layouts** on mobile
+- **Touch-friendly buttons** (44px minimum)
+- **Optimized spacing** for small screens
+- **Simplified navigation** for mobile users
+
+## ♿ Accessibility Features
+
+### Keyboard Navigation
+- **Tab order** properly managed
+- **Focus indicators** clearly visible
+- **Keyboard shortcuts** for common actions
+- **Skip links** for screen readers
+
+### Screen Reader Support
+- **Semantic HTML** structure
+- **ARIA labels** for complex components
+- **Alt text** for all images
+- **Descriptive link text**
+
+### Visual Accessibility
+- **High contrast** color combinations
+- **Large touch targets** (44px minimum)
+- **Clear visual hierarchy** with proper headings
+- **Consistent focus states**
+
+## 🔒 Security & Privacy
+
+### Enhanced Logging
+- **Comprehensive event logging** for audit trails
+- **User action tracking** for accountability
+- **Error logging** for debugging
+- **Performance monitoring** for optimization
+
+### Data Protection
+- **Secure authentication** with OTP
+- **Session management** with automatic timeouts
+- **Input validation** to prevent injection attacks
+- **Error handling** that doesn't expose sensitive data
+
+## 🚀 Performance Optimizations
+
+### Loading Performance
+- **Optimized CSS** with minimal overhead
+- **Efficient image processing** for AI recognition
+- **Lazy loading** for non-critical components
+- **Caching strategies** for repeated operations
+
+### User Experience
+- **Smooth animations** (60fps target)
+- **Instant feedback** for user actions
+- **Progressive loading** for better perceived performance
+- **Error recovery** with graceful fallbacks
+
+## 📊 Analytics & Monitoring
+
+### User Analytics
+- **Visit tracking** with detailed metrics
+- **Item processing** statistics
+- **User engagement** measurements
+- **Performance metrics** monitoring
+
+### System Monitoring
+- **Error tracking** with detailed logs
+- **Performance monitoring** for optimization
+- **Usage analytics** for feature improvement
+- **Health checks** for system reliability
+
+## 🔄 Maintenance & Updates
+
+### Version Control
+- **Automatic backups** before any changes
+- **Rollback capability** to previous versions
+- **Change logging** for audit trails
+- **Testing framework** for safe updates
+
+### Monitoring
+- **Health checks** for system status
+- **Performance monitoring** for optimization
+- **Error tracking** for quick resolution
+- **User feedback** collection for improvements
+
+## 🎯 Future Enhancements
+
+### Planned Features
+- **Dark/light theme toggle**
+- **Advanced analytics dashboard**
+- **Mobile app version**
+- **Offline capability**
+- **Multi-language support**
+
+### Technical Improvements
+- **Microservices architecture**
+- **Real-time updates** with WebSockets
+- **Advanced caching** strategies
+- **Performance optimization** for large datasets
+
+## 📞 Support & Documentation
+
+### Getting Help
+- **Comprehensive logging** for debugging
+- **Error messages** with helpful suggestions
+- **Documentation** for all features
+- **Testing framework** for validation
+
+### Contributing
+- **Clear code structure** for easy maintenance
+- **Comprehensive testing** for reliability
+- **Documentation** for all changes
+- **Version control** for safe updates
+
+---
+
+## 🎉 Conclusion
+
+The Care Count application now features a modern, industry-standard UI/UX that provides:
+
+- **Professional appearance** that builds trust
+- **Intuitive user experience** that reduces training time
+- **Responsive design** that works on all devices
+- **Accessibility features** that include all users
+- **Robust testing** that ensures reliability
+- **Safe deployment** with rollback capabilities
+
+The improvements maintain all existing functionality while significantly enhancing the user experience and making the application more maintainable and scalable for future development.

backups/deployment_log_20250923_202620.json

@@ -0,0 +1,62 @@
+[
+  {
+    "timestamp": "2025-09-23T20:26:01.318778",
+    "step": "testing",
+    "status": "STARTED",
+    "details": "Running pre-deployment tests"
+  },
+  {
+    "timestamp": "2025-09-23T20:26:12.234228",
+    "step": "import_test",
+    "status": "SUCCESS",
+    "details": "Modern app imports successfully"
+  },
+  {
+    "timestamp": "2025-09-23T20:26:12.235170",
+    "step": "ui_import_test",
+    "status": "SUCCESS",
+    "details": "UI improvements import successfully"
+  },
+  {
+    "timestamp": "2025-09-23T20:26:13.554936",
+    "step": "app_tests",
+    "status": "SUCCESS",
+    "details": "All app tests passed"
+  },
+  {
+    "timestamp": "2025-09-23T20:26:13.555445",
+    "step": "testing",
+    "status": "SUCCESS",
+    "details": "All tests passed"
+  },
+  {
+    "timestamp": "2025-09-23T20:26:13.555876",
+    "step": "deployment",
+    "status": "STARTED",
+    "details": "Deploying modern UI"
+  },
+  {
+    "timestamp": "2025-09-23T20:26:15.675932",
+    "step": "stop_app",
+    "status": "SUCCESS",
+    "details": "Stopped current app"
+  },
+  {
+    "timestamp": "2025-09-23T20:26:15.826651",
+    "step": "backup_creation",
+    "status": "SUCCESS",
+    "details": "Created backup: pre_modern_deployment_20250923_202615"
+  },
+  {
+    "timestamp": "2025-09-23T20:26:15.830996",
+    "step": "file_replacement",
+    "status": "SUCCESS",
+    "details": "Replaced app with modern version"
+  },
+  {
+    "timestamp": "2025-09-23T20:26:20.853515",
+    "step": "app_start",
+    "status": "SUCCESS",
+    "details": "Modern app started successfully"
+  }
+]

backups/deployment_log_20250923_203633.json

@@ -0,0 +1,62 @@
+[
+  {
+    "timestamp": "2025-09-23T20:36:21.190830",
+    "step": "testing",
+    "status": "STARTED",
+    "details": "Running pre-deployment tests"
+  },
+  {
+    "timestamp": "2025-09-23T20:36:25.672280",
+    "step": "import_test",
+    "status": "SUCCESS",
+    "details": "Modern app imports successfully"
+  },
+  {
+    "timestamp": "2025-09-23T20:36:25.672495",
+    "step": "ui_import_test",
+    "status": "SUCCESS",
+    "details": "UI improvements import successfully"
+  },
+  {
+    "timestamp": "2025-09-23T20:36:26.198747",
+    "step": "app_tests",
+    "status": "SUCCESS",
+    "details": "All app tests passed"
+  },
+  {
+    "timestamp": "2025-09-23T20:36:26.199337",
+    "step": "testing",
+    "status": "SUCCESS",
+    "details": "All tests passed"
+  },
+  {
+    "timestamp": "2025-09-23T20:36:26.199731",
+    "step": "deployment",
+    "status": "STARTED",
+    "details": "Deploying modern UI"
+  },
+  {
+    "timestamp": "2025-09-23T20:36:28.278741",
+    "step": "stop_app",
+    "status": "SUCCESS",
+    "details": "Stopped current app"
+  },
+  {
+    "timestamp": "2025-09-23T20:36:28.394861",
+    "step": "backup_creation",
+    "status": "SUCCESS",
+    "details": "Created backup: pre_modern_deployment_20250923_203628"
+  },
+  {
+    "timestamp": "2025-09-23T20:36:28.398794",
+    "step": "file_replacement",
+    "status": "SUCCESS",
+    "details": "Replaced app with modern version"
+  },
+  {
+    "timestamp": "2025-09-23T20:36:33.420662",
+    "step": "app_start",
+    "status": "SUCCESS",
+    "details": "Modern app started successfully"
+  }
+]

backups/deployment_log_20250923_204101.json

@@ -0,0 +1 @@
+[]

backups/deployment_log_20250923_204113.json

@@ -0,0 +1,14 @@
+[
+  {
+    "timestamp": "2025-09-23T20:41:07.876272",
+    "step": "rollback",
+    "status": "STARTED",
+    "details": "Rolling back to pre_modern_deployment_20250923_203628"
+  },
+  {
+    "timestamp": "2025-09-23T20:41:13.010207",
+    "step": "rollback",
+    "status": "SUCCESS",
+    "details": "Rolled back to pre_modern_deployment_20250923_203628"
+  }
+]

backups/deployment_log_20250923_205215.json

@@ -0,0 +1,62 @@
+[
+  {
+    "timestamp": "2025-09-23T20:52:02.354828",
+    "step": "testing",
+    "status": "STARTED",
+    "details": "Running pre-deployment tests"
+  },
+  {
+    "timestamp": "2025-09-23T20:52:07.829354",
+    "step": "import_test",
+    "status": "SUCCESS",
+    "details": "Modern app imports successfully"
+  },
+  {
+    "timestamp": "2025-09-23T20:52:07.829616",
+    "step": "ui_import_test",
+    "status": "SUCCESS",
+    "details": "UI improvements import successfully"
+  },
+  {
+    "timestamp": "2025-09-23T20:52:08.502096",
+    "step": "app_tests",
+    "status": "SUCCESS",
+    "details": "All app tests passed"
+  },
+  {
+    "timestamp": "2025-09-23T20:52:08.502609",
+    "step": "testing",
+    "status": "SUCCESS",
+    "details": "All tests passed"
+  },
+  {
+    "timestamp": "2025-09-23T20:52:08.503427",
+    "step": "deployment",
+    "status": "STARTED",
+    "details": "Deploying modern UI"
+  },
+  {
+    "timestamp": "2025-09-23T20:52:10.618570",
+    "step": "stop_app",
+    "status": "SUCCESS",
+    "details": "Stopped current app"
+  },
+  {
+    "timestamp": "2025-09-23T20:52:10.729497",
+    "step": "backup_creation",
+    "status": "SUCCESS",
+    "details": "Created backup: pre_modern_deployment_20250923_205210"
+  },
+  {
+    "timestamp": "2025-09-23T20:52:10.733425",
+    "step": "file_replacement",
+    "status": "SUCCESS",
+    "details": "Replaced app with modern version"
+  },
+  {
+    "timestamp": "2025-09-23T20:52:15.751869",
+    "step": "app_start",
+    "status": "SUCCESS",
+    "details": "Modern app started successfully"
+  }
+]

backups/deployment_log_20250924_092715.json

@@ -0,0 +1 @@
+[]

backups/hero_section_html_fix_20250923_203834/requirements.txt

@@ -0,0 +1,9 @@
+streamlit>=1.33
+pandas>=2.1
+Pillow>=10.1
+supabase>=2.5
+huggingface_hub>=0.24.6
+requests>=2.31
+python-dotenv>=1.0.0
+pytz>=2023.3
+

backups/hero_section_html_fix_20250923_203834/secrets.toml

@@ -0,0 +1,15 @@
+# Supabase connection
+SUPABASE_URL = "https://oudjcqhyldpncjbxohsg.supabase.co"
+SUPABASE_KEY ="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im91ZGpjcWh5bGRwbmNqYnhvaHNnIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTUzMDgyNDQsImV4cCI6MjA3MDg4NDI0NH0.SYwTtCe3r7WOZ25CRggL-lBkvGPjKnQhY_dT4Kjv9Dg"
+
+# App settings
+APP_TZ = "America/Toronto"
+
+# Hugging Face
+HF_TOKEN = "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"
+
+# Optional VLM model provider
+PROVIDER = "nebius"
+GEMMA_MODEL = "google/gemma-3-27b-it"
+NEBIUS_API_KEY = "eyJhbGciOiJIUzI1NiIsImtpZCI6IlV6SXJWd1h0dnprLVRvdzlLZWstc0M1akptWXBvX1VaVkxUZlpnMDRlOFUiLCJ0eXAiOiJKV1QifQ.eyJzdWIiOiJnb29nbGUtb2F1dGgyfDEwMjk4MzMxNjQ1OTQzNjA5ODYxMyIsInNjb3BlIjoib3BlbmlkIG9mZmxpbmVfYWNjZXNzIiwiaXNzIjoiYXBpX2tleV9pc3N1ZXIiLCJhdWQiOlsiaHR0cHM6Ly9uZWJpdXMtaW5mZXJlbmNlLmV1LmF1dGgwLmNvbS9hcGkvdjIvIl0sImV4cCI6MTkxNTEzMTE3MiwidXVpZCI6IjJmOTUxZmM1LWEyNTgtNDg5OC1iNWI4LTkwZTljY2RkZjU2NSIsIm5hbWUiOiJjYXJlIGNvdW50IGFwcCIsImV4cGlyZXNfYXQiOiIyMDMwLTA5LTA4VDIwOjUyOjUyKzAwMDAifQ.awAHOieD93pCnYmFMgRQ64-i6yZdO0XvXczD4eS6xEI"
+NEBIUS_BASE_URL = "https://api.nebius.ai/v1"

backups/hero_section_html_fix_20250923_203834/streamlit_app.py

@@ -0,0 +1,891 @@
+# --- Care Count (Volunteers → Visits → Items) ---
+# Modern UI/UX with industry-standard design patterns
+# Enhanced version with improved user experience
+
+from __future__ import annotations
+
+import os, io, time, base64, re, uuid, json
+from datetime import datetime, timedelta
+from typing import Optional
+import logging
+
+import pytz
+import requests
+import pandas as pd
+import streamlit as st
+from PIL import Image, ImageOps, ImageEnhance
+from supabase import create_client, Client
+
+# Import our modern UI components
+from ui_improvements import ModernUIComponents, apply_modern_ui, create_modern_layout
+
+# ------------------------ Enhanced Logging ------------------------
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('care_count.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# ------------------------ App config ------------------------
+os.environ.setdefault("HOME", "/tmp")
+os.environ["STREAMLIT_BROWSER_GATHER_USAGE_STATS"] = "false"
+
+TZ             = os.getenv("APP_TZ", "America/Toronto")
+CUTOFF_HOUR    = int(os.getenv("CUTOFF_HOUR", "20"))   # 8pm local
+INACTIVITY_MIN = int(os.getenv("INACTIVITY_MIN", "30"))
+
+def local_now() -> datetime:
+    return datetime.now(pytz.timezone(TZ))
+
+# Enhanced page config with modern settings
+st.set_page_config(
+    page_title="Care Count - Volunteer Management",
+    page_icon="💜",
+    layout="wide",
+    initial_sidebar_state="expanded",
+    menu_items={
+        'Get Help': 'https://github.com/your-repo/care-count',
+        'Report a bug': "https://github.com/your-repo/care-count/issues",
+        'About': "# Care Count\nVolunteer management system for community impact tracking"
+    }
+)
+
+# Apply modern UI styling
+apply_modern_ui()
+
+# ------------------------ Enhanced Secrets Management ------------------------
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except Exception:
+    pass
+
+try:
+    _SECRETS = getattr(st, "secrets", {})
+except Exception:
+    _SECRETS = {}
+
+def _is_useful(val: Optional[str]) -> bool:
+    return val is not None and str(val).strip() != ""
+
+def get_secret(name: str, default: Optional[str] = None) -> Optional[str]:
+    """Enhanced secret management with logging"""
+    v = os.getenv(name)
+    if _is_useful(v):
+        logger.info(f"Secret {name} loaded from environment")
+        return v
+
+    try:
+        if hasattr(_SECRETS, "get"):
+            v = _SECRETS.get(name, default)
+            if _is_useful(v):
+                logger.info(f"Secret {name} loaded from Streamlit secrets")
+                return v
+    except Exception as e:
+        logger.warning(f"Failed to load secret {name} from Streamlit secrets: {e}")
+
+    return default
+
+def require_secret(name: str) -> str:
+    """Enhanced secret requirement with better error handling"""
+    v = get_secret(name, None)
+    if not _is_useful(v):
+        st.error(
+            f"🔐 **Configuration Error**\n\n"
+            f"Missing required configuration: `{name}`\n\n"
+            f"Please ensure this is set in your environment variables or `.streamlit/secrets.toml` file.\n\n"
+            f"For help, check the [documentation](https://github.com/your-repo/care-count#configuration)."
+        )
+        st.stop()
+    return str(v)
+
+# Required Supabase credentials
+SUPABASE_URL = require_secret("SUPABASE_URL")
+SUPABASE_KEY = require_secret("SUPABASE_KEY")
+
+# Initialize Supabase client with error handling
+try:
+sb: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+    logger.info("Supabase client initialized successfully")
+except Exception as e:
+    st.error(f"Failed to connect to Supabase: {e}")
+    logger.error(f"Supabase connection failed: {e}")
+    st.stop()
+
+# Optional provider/config
+PROVIDER         = (get_secret("PROVIDER", "nebius") or "nebius").strip().lower()
+GEMMA_MODEL      = (get_secret("GEMMA_MODEL", "google/gemma-3-27b-it") or "google/gemma-3-27b-it").strip()
+NEBIUS_API_KEY   = get_secret("NEBIUS_API_KEY")
+NEBIUS_BASE_URL  = get_secret("NEBIUS_BASE_URL", "https://api.nebius.ai/v1")
+FEATH_API_KEY    = get_secret("FEATHERLESS_API_KEY")
+FEATH_BASE_URL   = get_secret("FEATHERLESS_BASE_URL", "https://api.featherless.ai/v1")
+
+# ------------------------ Enhanced Event Logging ------------------------
+def log_event(action: str, actor: Optional[str], details: dict, level: str = "info"):
+    """Enhanced event logging with multiple levels"""
+    log_data = {
+        "timestamp": datetime.utcnow().isoformat(),
+        "action": action,
+        "actor_email": actor,
+        "details": details,
+        "level": level
+    }
+    
+    # Log to file
+    if level == "error":
+        logger.error(f"Event: {action} by {actor} - {details}")
+    elif level == "warning":
+        logger.warning(f"Event: {action} by {actor} - {details}")
+    else:
+        logger.info(f"Event: {action} by {actor} - {details}")
+    
+    # Log to database
+    try:
+        sb.table("events").insert(log_data).execute()
+    except Exception as e:
+        logger.error(f"Failed to log event to database: {e}")
+
+# ------------------------ Modern Authentication UI ------------------------
+def auth_block() -> tuple[bool, Optional[str]]:
+    """Enhanced authentication with modern UI"""
+    if "auth_email" not in st.session_state:
+        st.session_state["auth_email"] = None
+    if "user_email" in st.session_state:
+        return True, st.session_state["user_email"]
+
+    # Modern hero section for login
+    st.markdown(ModernUIComponents.create_hero_section(
+        "Care Count",
+        "Thanks for showing up for the community today. Snap items, keep visits tidy, and help us understand the impact of your time."
+    ), unsafe_allow_html=True)
+
+    # Modern login form
+    with st.container():
+        st.markdown('<div class="modern-card">', unsafe_allow_html=True)
+        st.subheader("🔐 Sign In")
+        st.markdown("Enter your email to receive a secure login code.")
+        
+        with st.form("otp_request", clear_on_submit=False):
+            email = st.text_input(
+                "Email Address", 
+                value=st.session_state.get("auth_email") or "", 
+                placeholder="your.email@example.com",
+                help="We'll send you a secure 6-digit code"
+            )
+            
+            col1, col2, col3 = st.columns([1, 2, 1])
+            with col2:
+                send = st.form_submit_button("📧 Send Login Code", use_container_width=True)
+            
+        if send:
+            if not email or "@" not in email:
+                    st.error("Please enter a valid email address.")
+            else:
+                try:
+                        with st.spinner("Sending login code..."):
+                    sb.auth.sign_in_with_otp({"email": email, "shouldCreateUser": True})
+                    st.session_state["auth_email"] = email
+                            st.success("✅ Login code sent! Check your email.")
+                            log_event("otp_requested", email, {"method": "email"})
+                except Exception as e:
+                        st.error(f"❌ Could not send code: {e}")
+                        log_event("otp_failed", email, {"error": str(e)}, "error")
+
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    # OTP verification form
+    if st.session_state.get("auth_email"):
+        with st.container():
+            st.markdown('<div class="modern-card">', unsafe_allow_html=True)
+            st.subheader("🔢 Verify Code")
+            st.markdown(f"Enter the 6-digit code sent to **{st.session_state['auth_email']}**")
+            
+            with st.form("otp_verify", clear_on_submit=True):
+                code = st.text_input(
+                    "Verification Code", 
+                    max_chars=6,
+                    placeholder="123456",
+                    help="Enter the 6-digit code from your email"
+                )
+                
+                col1, col2, col3 = st.columns([1, 2, 1])
+                with col2:
+                    ok = st.form_submit_button("✅ Verify & Start Shift", use_container_width=True)
+                
+            if ok:
+                    if len(code) != 6 or not code.isdigit():
+                        st.error("Please enter a valid 6-digit code.")
+                    else:
+                try:
+                            with st.spinner("Verifying code..."):
+                    res = sb.auth.verify_otp({"email": st.session_state["auth_email"], "token": code, "type": "email"})
+                    if res and res.user:
+                        email = st.session_state["auth_email"]
+                                    
+                                    # Enhanced volunteer upsert
+                                    volunteer_data = {
+                            "email": email,
+                            "last_login_at": datetime.utcnow().isoformat(),
+                            "shift_started_at": datetime.utcnow().isoformat(),
+                                        "shift_ended_at": None,
+                                        "login_count": 1  # Track login frequency
+                                    }
+                                    
+                                    sb.table("volunteers").upsert(volunteer_data, on_conflict="email").execute()
+                                    
+                        st.session_state["user_email"] = email
+                        st.session_state["shift_started"] = True
+                        st.session_state["last_activity_at"] = local_now()
+                                    
+                                    log_event("login_success", email, {"method": "otp"})
+                                    st.success("🎉 Welcome back! Your shift has started.")
+                                    st.balloons()
+                        return True, email
+                except Exception as e:
+                            st.error(f"❌ Verification failed: {e}")
+                            log_event("otp_verification_failed", st.session_state["auth_email"], {"error": str(e)}, "error")
+            
+            st.markdown('</div>', unsafe_allow_html=True)
+    
+    return False, None
+
+def end_shift(email: str, reason: str):
+    """Enhanced shift ending with better logging"""
+    try:
+        end_time = datetime.utcnow().isoformat()
+        sb.table("volunteers").update({"shift_ended_at": end_time}).eq("email", email).execute()
+        log_event("shift_end", email, {"reason": reason, "end_time": end_time})
+    except Exception as e:
+        logger.error(f"Failed to end shift for {email}: {e}")
+
+def guard_cutoff_and_idle(email: str):
+    """Enhanced session management with better UX"""
+    now = local_now()
+    last = st.session_state.get("last_activity_at")
+    
+    if last and (now - last).total_seconds() > INACTIVITY_MIN * 60:
+        end_shift(email, "inactivity")
+        st.session_state.clear()
+        st.warning("⏰ You were logged out due to inactivity. Thank you for volunteering today!")
+        st.stop()
+    
+    st.session_state["last_activity_at"] = now
+
+    cutoff = now.replace(hour=CUTOFF_HOUR, minute=0, second=0, microsecond=0)
+    if now >= cutoff:
+        end_shift(email, "cutoff_8pm")
+        st.session_state.clear()
+        st.info("🌅 We close the day at 8pm. Your shift has been ended. Thank you so much!")
+        st.stop()
+
+# ------------------------ Main App Flow ------------------------
+def main():
+    """Main application flow with modern UI"""
+    
+    # Authentication
+signed_in, user_email = auth_block()
+if not signed_in:
+    st.stop()
+    
+guard_cutoff_and_idle(user_email)
+
+    # Modern welcome section
+    st.markdown(ModernUIComponents.create_hero_section(
+        "Care Count Dashboard",
+        "Manage visits, track items, and make a difference in your community.",
+        user_email
+    ))
+
+    # Enhanced status cards
+    vrow = fetch_volunteer_row(user_email) or {}
+    shift_started_at = vrow.get("shift_started_at")
+    lifetime_hours = vrow.get("total_hours", 0)
+    
+    mins_active = 0
+    try:
+        if shift_started_at:
+            t0 = datetime.fromisoformat(str(shift_started_at).replace("Z","+00:00"))
+            mins_active = max(0, int((datetime.utcnow() - t0).total_seconds() // 60))
+    except Exception:
+        pass
+
+    status_data = {
+        "shift_active": f"{mins_active} min",
+        "items_today": items_today(user_email),
+        "lifetime_hours": f"{round(float(lifetime_hours), 1)} hrs" if isinstance(lifetime_hours, (int, float)) else "0.0 hrs"
+    }
+    
+    st.markdown(ModernUIComponents.create_status_cards(status_data), unsafe_allow_html=True)
+
+    # Modern sign-out button
+    col1, col2, col3 = st.columns([1, 1, 1])
+    with col2:
+        if st.button("🔒 Sign Out", use_container_width=True, type="secondary"):
+        end_shift(user_email, "manual")
+        st.session_state.clear()
+            st.success("✅ Signed out successfully. See you next time!")
+            st.rerun()
+
+    # Enhanced visit management section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "🪪 Visit Management",
+        "Start and manage student visits with unique tracking codes"
+    ), unsafe_allow_html=True)
+    
+    active_visit = st.session_state.get("active_visit")
+    
+    col1, col2, col3 = st.columns([1, 1, 1])
+    
+    with col1:
+        if not active_visit and st.button("🚀 Start New Visit", use_container_width=True, type="primary"):
+            try:
+                with st.spinner("Creating visit..."):
+                    payload = {
+                        "visit_code": fallback_visit_code(),
+                        "started_at": datetime.utcnow().isoformat(),
+                        "ended_at": None,
+                        "created_by": user_email
+                    }
+                    v = sb.table("visits").insert(payload).execute().data[0]
+                    if not v.get("visit_code"):
+                        v["visit_code"] = payload["visit_code"]
+                    st.session_state["active_visit"] = v
+                    st.success(f"✅ Visit #{v['id']} started")
+                    st.info(f"**Visit Code:** `{v['visit_code']}`")
+                    log_event("visit_start", user_email, {"visit_id": v["id"], "visit_code": v["visit_code"]})
+                    st.rerun()
+            except Exception as e:
+                st.error(f"❌ Could not start visit: {e}")
+                log_event("visit_start_failed", user_email, {"error": str(e)}, "error")
+
+    with col2:
+        if active_visit and st.button("🏁 End Visit", use_container_width=True, type="secondary"):
+            try:
+                with st.spinner("Ending visit..."):
+                    sb.table("visits").update({"ended_at": datetime.utcnow().isoformat()}) \
+                      .eq("id", active_visit["id"]).execute()
+                    st.success("✅ Visit completed successfully")
+                    log_event("visit_end", user_email, {"visit_id": active_visit["id"]})
+                    st.session_state.pop("active_visit", None)
+                    st.rerun()
+            except Exception as e:
+                st.error(f"❌ Could not end visit: {e}")
+                log_event("visit_end_failed", user_email, {"error": str(e)}, "error")
+
+    with col3:
+        if st.session_state.get("active_visit"):
+            v = st.session_state["active_visit"]
+            st.info(f"**Active Visit:** #{v['id']}\n**Code:** {v.get('visit_code','')}")
+        else:
+            st.info("No active visit")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced item identification section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📸 Item Identification",
+        "Use AI-powered image recognition to identify items quickly and accurately"
+    ), unsafe_allow_html=True)
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("📷 Camera Capture")
+        cam = st.camera_input("Take a photo of the item", help="Position the item clearly in the frame")
+    
+    with col2:
+        st.subheader("📁 File Upload")
+        up = st.file_uploader(
+            "Upload an image", 
+            type=["png","jpg","jpeg"],
+            help="Supported formats: PNG, JPG, JPEG"
+        )
+
+    img_file = cam or up
+    if img_file:
+        try:
+            img = Image.open(img_file).convert("RGB")
+            st.image(img, use_container_width=True, caption="Captured Image")
+            
+            if st.button("🔍 Identify Item with AI", use_container_width=True, type="primary"):
+                with st.spinner("Analyzing image with AI..."):
+                    t0 = time.time()
+                    try:
+                        pre = preprocess_for_label(img)
+                        raw = gemma_item_name(_to_png_bytes(pre))
+                        processing_time = time.time() - t0
+                        
+                        norm = normalize_item_name(raw)
+                        
+                        if raw:
+                            st.success(f"🤖 **AI Detection:** {raw}")
+                        st.info(f"✨ **Normalized:** {norm or '(unknown)'} · ⏱️ {processing_time:.2f}s")
+                        
+                        st.session_state["scanned_item_name"] = norm or raw or ""
+                        st.session_state["last_activity_at"] = local_now()
+                        
+                        log_event("item_identified", user_email, {
+                            "raw_name": raw,
+                            "normalized_name": norm,
+                            "processing_time": processing_time
+                        })
+                        
+                    except Exception as e:
+                        st.error(f"❌ AI identification failed: {e}")
+                        log_event("ai_identification_failed", user_email, {"error": str(e)}, "error")
+        except Exception as e:
+            st.error(f"❌ Failed to process image: {e}")
+            log_event("image_processing_failed", user_email, {"error": str(e)}, "error")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced item logging section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📬 Item Logging",
+        "Log items to the current visit with detailed information"
+    ), unsafe_allow_html=True)
+    
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        item_name = st.text_input(
+            "Item Name", 
+            value=st.session_state.get("scanned_item_name",""),
+            placeholder="Enter item name or use AI detection above",
+            help="Required field - item name for tracking"
+        )
+    
+    with col2:
+        quantity = st.number_input(
+            "Quantity", 
+            min_value=1, 
+            max_value=9999, 
+            step=1, 
+            value=1,
+            help="Number of items"
+        )
+    
+    col3, col4 = st.columns(2)
+    
+    with col3:
+        category = st.text_input(
+            "Category (optional)", 
+            placeholder="e.g., Food, Hygiene, Clothing",
+            help="Item category for better organization"
+        )
+    
+    with col4:
+        unit = st.text_input(
+            "Unit (optional)", 
+            placeholder="e.g., 500 mL, 1 L, 250 g",
+            help="Unit of measurement"
+        )
+    
+    barcode = st.text_input(
+        "Barcode (optional)", 
+        placeholder="Scan or enter barcode",
+        help="Product barcode for inventory tracking"
+    )
+
+    save_disabled = not st.session_state.get("active_visit")
+    if st.button("✅ Save Item to Visit", disabled=save_disabled, use_container_width=True, type="primary"):
+        v = st.session_state.get("active_visit")
+        if not v:
+            st.warning("⚠️ Please start a visit first before logging items.")
+        else:
+            name_clean = clean_text(item_name, 120)
+            if not name_clean:
+                st.warning("⚠️ Item name is required.")
+            else:
+                with st.spinner("Saving item..."):
+                    ts_iso = datetime.utcnow().isoformat()
+                    ingest_id = deterministic_ingest_id(int(v["id"]), user_email, name_clean, int(quantity), ts_iso)
+                    
+                    try:
+                        ok, msg = try_rpc_ingest(
+                            email=user_email, v_id=int(v["id"]), name=name_clean, qty=int(quantity),
+                            category=clean_text(category, 80), unit=clean_text(unit, 40),
+                            barcode=clean_text(barcode, 64), ts_iso=ts_iso, ingest_id=ingest_id
+                        )
+                        
+                        if ok:
+                            st.success("✅ Item logged successfully!")
+                            log_event("item_logged", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                        else:
+                            st.warning(f"⚠️ {msg}. Trying fallback method...")
+                            fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                                   clean_text(category,80), clean_text(unit,40),
+                                                   clean_text(barcode,64), ts_iso, ingest_id)
+                            st.success("✅ Item logged successfully (fallback method)!")
+                            log_event("item_logged_fallback", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                    except Exception as e:
+                        try:
+                            fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                                   clean_text(category,80), clean_text(unit,40),
+                                                   clean_text(barcode,64), ts_iso, ingest_id)
+                            st.success("✅ Item logged successfully (fallback method)!")
+                            log_event("item_logged_fallback", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                        except Exception as e2:
+                            st.error(f"❌ Failed to log item: {e2}")
+                            log_event("item_log_failed", user_email, {"error": str(e2)}, "error")
+                    
+                    st.session_state["last_activity_at"] = local_now()
+                    st.session_state["scanned_item_name"] = name_clean
+                    st.rerun()
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced visit items view
+    if st.session_state.get("active_visit"):
+        st.markdown(ModernUIComponents.create_modern_form_section(
+            "🧾 Current Visit Items",
+            "Review and manage items in the current visit"
+        ), unsafe_allow_html=True)
+        
+        rows = load_items_for_visit(int(st.session_state["active_visit"]["id"]))
+        if rows:
+            df = pd.DataFrame(rows)
+            
+            # Enhanced dataframe display
+            st.dataframe(
+                df, 
+                use_container_width=True,
+                hide_index=True,
+                column_config={
+                    "timestamp": st.column_config.DatetimeColumn("Time", format="MM/DD/YY HH:mm"),
+                    "item_name": st.column_config.TextColumn("Item Name", width="medium"),
+                    "qty": st.column_config.NumberColumn("Quantity", width="small"),
+                    "category": st.column_config.TextColumn("Category", width="small"),
+                    "unit": st.column_config.TextColumn("Unit", width="small")
+                }
+            )
+            
+            # Enhanced delete functionality
+            with st.expander("🗑️ Delete Item (if mis-logged)"):
+                if rows:
+                    item_options = {f"{r['item_name']} (Qty: {r['qty']})": r["id"] for r in rows if "id" in r}
+                    selected_item = st.selectbox("Select item to delete", list(item_options.keys()))
+                    
+                    if st.button("🗑️ Delete Selected Item", type="secondary"):
+                        item_id = item_options[selected_item]
+                        try:
+                            # Try both tables safely
+                            try:
+                                delete_item("visit_items_p", int(item_id))
+                            except Exception:
+                                delete_item("visit_items", int(item_id))
+                            
+                            st.success("✅ Item deleted successfully")
+                            log_event("item_deleted", user_email, {"item_id": item_id})
+                            st.rerun()
+                        except Exception as e:
+                            st.error(f"❌ Failed to delete item: {e}")
+                            log_event("item_delete_failed", user_email, {"error": str(e)}, "error")
+                else:
+                    st.info("No items to delete")
+        else:
+            st.info("📝 No items logged for this visit yet.")
+        
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced analytics section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📈 Today's Analytics",
+        "Real-time insights into today's volunteer activity"
+    ), unsafe_allow_html=True)
+    
+    try:
+        daily = sb.table("v_daily_activity").select("*").execute().data
+        today_str = local_now().strftime("%Y-%m-%d")
+        today = next((r for r in daily if str(r.get("day",""))[:10]==today_str), None)
+        
+        if today:
+            visits = int(today.get("visits", 0))
+            items = int(today.get("items", 0))
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                st.metric("Total Visits Today", visits, delta=None)
+            with col2:
+                st.metric("Total Items Processed", items, delta=None)
+            
+            # Progress indicator
+            if visits > 0:
+                st.markdown(ModernUIComponents.create_progress_indicator(
+                    items, visits * 10, "Items per Visit Target"
+                ), unsafe_allow_html=True)
+        else:
+            st.info("📊 Analytics data will appear here as activity increases.")
+            
+    except Exception as e:
+        st.info("📊 Analytics view will be available once the database view is set up.")
+        logger.warning(f"Analytics view not available: {e}")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced footer with helpful information
+    st.markdown("""
+    <div class="modern-card" style="margin-top: var(--space-8); text-align: center;">
+        <h4>💡 Quick Tips</h4>
+        <p style="color: var(--gray-400); margin: 0;">
+            When you're done, please <strong>End Visit</strong> and <strong>Sign out</strong>.<br>
+            We'll auto-sign you out after inactivity or at 8pm local time. 💜
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+
+# ------------------------ Helper Functions (Enhanced) ------------------------
+def fetch_volunteer_row(email: str) -> dict | None:
+    """Enhanced volunteer data fetching with error handling"""
+    try:
+        return sb.table("volunteers").select("*").eq("email", email).single().execute().data
+    except Exception as e:
+        logger.warning(f"Failed to fetch volunteer data for {email}: {e}")
+        return None
+
+def items_today(email: str) -> int:
+    """Enhanced item counting with better error handling"""
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        # Try partitioned table first
+        data = sb.table("visit_items_p").select("id,timestamp,volunteer") \
+                .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                .eq("volunteer", email).execute().data
+        return len(data or [])
+    except Exception:
+        try:
+            data = sb.table("visit_items").select("id,timestamp,volunteer") \
+                    .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                    .eq("volunteer", email).execute().data
+            return len(data or [])
+        except Exception as e:
+            logger.warning(f"Failed to count items for {email}: {e}")
+            return 0
+
+def fallback_visit_code() -> str:
+    """Enhanced visit code generation with better uniqueness"""
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        todays = sb.table("visits").select("id,started_at").gte("started_at", f"{day} 00:00:00") \
+                 .lte("started_at", f"{day} 23:59:59").execute().data or []
+        seq = len(todays) + 1
+except Exception:
+        seq = int(time.time()) % 1000
+    return f"V-{seq}-{local_now().strftime('%Y%m%d')}-{str(uuid.uuid4())[:6]}"
+
+def _to_png_bytes(img: Image.Image) -> bytes:
+    """Convert image to PNG bytes"""
+    b = io.BytesIO()
+    img.save(b, format="PNG")
+    return b.getvalue()
+
+def preprocess_for_label(img: Image.Image) -> Image.Image:
+    """Enhanced image preprocessing for better AI recognition"""
+    img = img.convert("RGB")
+    w, h = img.size
+    scale = 1024 / max(w, h) if max(w, h) > 1024 else 1.0
+    if scale < 1.0: 
+        img = img.resize((int(w * scale), int(h * scale)))
+    img = ImageOps.autocontrast(img, cutoff=2)
+    img = ImageEnhance.Brightness(img).enhance(1.06)
+    img = ImageEnhance.Contrast(img).enhance(1.05)
+    img = ImageEnhance.Sharpness(img).enhance(1.15)
+    return img
+
+def gemma_item_name(img_bytes: bytes) -> str:
+    """Enhanced AI item identification with better error handling"""
+    try:
+        if PROVIDER == "nebius":
+            if not NEBIUS_API_KEY: 
+                raise RuntimeError("NEBIUS_API_KEY missing")
+            return _openai_style_chat(NEBIUS_BASE_URL, NEBIUS_API_KEY, GEMMA_MODEL, img_bytes)
+        elif PROVIDER == "featherless":
+            if not FEATH_API_KEY: 
+                raise RuntimeError("FEATHERLESS_API_KEY missing")
+            return _openai_style_chat(FEATH_BASE_URL, FEATH_API_KEY, GEMMA_MODEL, img_bytes)
+        else:
+            raise RuntimeError(f"Unknown PROVIDER: {PROVIDER}")
+    except Exception as e:
+        logger.error(f"AI identification failed: {e}")
+        raise
+
+def _openai_style_chat(base_url: str, api_key: str, model_id: str, img_bytes: bytes) -> str:
+    """Enhanced API communication with better error handling"""
+    b64 = base64.b64encode(img_bytes).decode("utf-8")
+    url = f"{base_url.rstrip('/')}/chat/completions"
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    payload = {
+        "model": model_id,
+        "temperature": 0,
+        "messages": [
+            {"role": "system", "content": "You label item being held in the image for a food bank. Return ONLY the item name."},
+            {"role": "user", "content": [
+                {"type": "text", "text": "What is the name of the item in the picture? Return only the item name."},
+                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}}
+            ]}
+        ]
+    }
+    
+    try:
+    r = requests.post(url, json=payload, headers=headers, timeout=90)
+    if r.status_code != 200:
+        raise RuntimeError(f"LLM HTTP {r.status_code}: {r.text[:200]}")
+    data = r.json()
+    return (data["choices"][0]["message"]["content"] or "").strip()
+    except requests.exceptions.Timeout:
+        raise RuntimeError("AI service timeout - please try again")
+    except requests.exceptions.RequestException as e:
+        raise RuntimeError(f"AI service error: {e}")
+
+def normalize_item_name(s: str) -> str:
+    """Enhanced item name normalization"""
+    s = (s or "").strip()
+    if not s: 
+        return ""
+    
+    # Enhanced brand and type recognition
+BRANDS = {
+    "whiskas","tetley","kellogg's","kelloggs","campbell's","campbells","heinz",
+    "nestle","kraft","general mills","cheerios","oreo","oreos","pringles","lays","doritos",
+    "ice river","green bottle","great value","wheat thins","vegetable thins","raid"
+}
+GENERIC_TYPES = {
+    "water","toothpaste","deodorant","antiperspirant","soap","shampoo","conditioner",
+    "lotion","tea","coffee","cereal","pasta","rice","beans","sauce","salsa","cleaner",
+    "peanut butter","jam","jelly","tuna","chicken","beef","flour","sugar","salt","oil",
+    "crackers","cookies","soup","insect killer","spray"
+}
+    
+    low = re.sub(r"[®™]", "", s.lower())
+    for b in BRANDS: 
+        low = low.replace(b, "")
+    
+    chosen = None
+    for t in GENERIC_TYPES:
+        if t in low: 
+            chosen = t
+            break
+    
+    cleaned = " ".join(low.split())
+    return (chosen or cleaned.title())[:120]
+
+def clean_text(v: Optional[str], maxlen: int = 120) -> Optional[str]:
+    """Enhanced text cleaning"""
+    if not v: 
+        return None
+    v = re.sub(r"\s+", " ", v).strip()
+    return v[:maxlen] if v else None
+
+def deterministic_ingest_id(v_id: int, email: str, name: str, qty: int, ts_iso: str) -> str:
+    """Enhanced ID generation for data integrity"""
+    key = f"visit_items::{v_id}::{email}::{name}::{qty}::{ts_iso}"
+    return str(uuid.uuid5(uuid.NAMESPACE_URL, key))
+
+def try_rpc_ingest(email: str, v_id: int, name: str, qty: int,
+                   category: Optional[str], unit: Optional[str],
+                   barcode: Optional[str], ts_iso: str, ingest_id: str) -> tuple[bool,str]:
+    """Enhanced RPC ingestion with better error handling"""
+    try:
+        res = sb.rpc("safe_ingest_visit_item", {
+            "p_email": email,
+            "p_visit_id": v_id,
+            "p_item_name": name,
+            "p_qty": qty,
+            "p_category": category,
+            "p_unit": unit,
+            "p_barcode": barcode,
+            "p_ts": ts_iso,
+            "p_ingest_id": ingest_id
+        }).execute()
+        
+        rows = res.data if isinstance(res.data, list) else []
+        if rows:
+            r0 = rows[0]
+            ok = bool(r0.get("ok", False))
+            msg = str(r0.get("msg", ""))
+            return ok, msg or ("ok" if ok else "failed")
+        return True, "ok"
+    except Exception as e:
+        logger.warning(f"RPC ingest failed, using fallback: {e}")
+        raise e
+
+def fallback_direct_insert(email: str, v_id: int, name: str, qty: int,
+                           category: Optional[str], unit: Optional[str],
+                           barcode: Optional[str], ts_iso: str, ingest_id: str) -> None:
+    """Enhanced fallback insertion with better error handling"""
+    payload = {
+        "visit_id": v_id,
+        "timestamp": ts_iso,
+        "volunteer": email,
+        "item_name": name,
+        "category": category,
+        "unit": unit,
+        "qty": qty,
+        "barcode": barcode,
+        "weather_type": None,
+        "temp_c": None,
+        "ingest_id": ingest_id
+    }
+    
+    try:
+        sb.table("visit_items_p").insert(payload).execute()
+    except Exception:
+        # Legacy table fallback
+        payload.pop("ingest_id", None)
+        sb.table("visit_items").insert(payload).execute()
+
+def load_items_for_visit(visit_id: int) -> list[dict]:
+    """Enhanced item loading with better error handling"""
+    try:
+        return sb.table("visit_items_p").select("*").eq("visit_id", visit_id) \
+            .order("timestamp", desc=True).limit(500).execute().data or []
+    except Exception:
+        try:
+            return sb.table("visit_items").select("*").eq("visit_id", visit_id) \
+                .order("timestamp", desc=True).limit(500).execute().data or []
+        except Exception as e:
+            logger.warning(f"Failed to load items for visit {visit_id}: {e}")
+            return []
+
+def delete_item(table: str, item_id: int):
+    """Enhanced item deletion with better error handling"""
+    try:
+        sb.table(table).delete().eq("id", item_id).execute()
+    except Exception as e:
+        logger.error(f"Failed to delete item {item_id} from {table}: {e}")
+        raise e
+
+# ------------------------ App Configuration Display ------------------------
+st.sidebar.markdown("### ⚙️ Configuration")
+st.sidebar.info(f"""
+**Provider:** `{PROVIDER}`  
+**Model:** `{GEMMA_MODEL}`  
+**Timezone:** `{TZ}`  
+**Cutoff:** {CUTOFF_HOUR}:00 PM  
+**Inactivity:** {INACTIVITY_MIN} min
+""")
+
+# ------------------------ Main App Execution ------------------------
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        logger.error(f"Application error: {e}")
+        st.error(f"❌ Application error: {e}")
+        st.info("Please refresh the page or contact support if the issue persists.")

backups/indentation_fix_20250923_203937/requirements.txt

@@ -0,0 +1,9 @@
+streamlit>=1.33
+pandas>=2.1
+Pillow>=10.1
+supabase>=2.5
+huggingface_hub>=0.24.6
+requests>=2.31
+python-dotenv>=1.0.0
+pytz>=2023.3
+

backups/indentation_fix_20250923_203937/secrets.toml

@@ -0,0 +1,15 @@
+# Supabase connection
+SUPABASE_URL = "https://oudjcqhyldpncjbxohsg.supabase.co"
+SUPABASE_KEY ="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im91ZGpjcWh5bGRwbmNqYnhvaHNnIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTUzMDgyNDQsImV4cCI6MjA3MDg4NDI0NH0.SYwTtCe3r7WOZ25CRggL-lBkvGPjKnQhY_dT4Kjv9Dg"
+
+# App settings
+APP_TZ = "America/Toronto"
+
+# Hugging Face
+HF_TOKEN = "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"
+
+# Optional VLM model provider
+PROVIDER = "nebius"
+GEMMA_MODEL = "google/gemma-3-27b-it"
+NEBIUS_API_KEY = "eyJhbGciOiJIUzI1NiIsImtpZCI6IlV6SXJWd1h0dnprLVRvdzlLZWstc0M1akptWXBvX1VaVkxUZlpnMDRlOFUiLCJ0eXAiOiJKV1QifQ.eyJzdWIiOiJnb29nbGUtb2F1dGgyfDEwMjk4MzMxNjQ1OTQzNjA5ODYxMyIsInNjb3BlIjoib3BlbmlkIG9mZmxpbmVfYWNjZXNzIiwiaXNzIjoiYXBpX2tleV9pc3N1ZXIiLCJhdWQiOlsiaHR0cHM6Ly9uZWJpdXMtaW5mZXJlbmNlLmV1LmF1dGgwLmNvbS9hcGkvdjIvIl0sImV4cCI6MTkxNTEzMTE3MiwidXVpZCI6IjJmOTUxZmM1LWEyNTgtNDg5OC1iNWI4LTkwZTljY2RkZjU2NSIsIm5hbWUiOiJjYXJlIGNvdW50IGFwcCIsImV4cGlyZXNfYXQiOiIyMDMwLTA5LTA4VDIwOjUyOjUyKzAwMDAifQ.awAHOieD93pCnYmFMgRQ64-i6yZdO0XvXczD4eS6xEI"
+NEBIUS_BASE_URL = "https://api.nebius.ai/v1"

backups/indentation_fix_20250923_203937/streamlit_app.py

@@ -0,0 +1,891 @@
+# --- Care Count (Volunteers → Visits → Items) ---
+# Modern UI/UX with industry-standard design patterns
+# Enhanced version with improved user experience
+
+from __future__ import annotations
+
+import os, io, time, base64, re, uuid, json
+from datetime import datetime, timedelta
+from typing import Optional
+import logging
+
+import pytz
+import requests
+import pandas as pd
+import streamlit as st
+from PIL import Image, ImageOps, ImageEnhance
+from supabase import create_client, Client
+
+# Import our modern UI components
+from ui_improvements import ModernUIComponents, apply_modern_ui, create_modern_layout
+
+# ------------------------ Enhanced Logging ------------------------
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('care_count.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# ------------------------ App config ------------------------
+os.environ.setdefault("HOME", "/tmp")
+os.environ["STREAMLIT_BROWSER_GATHER_USAGE_STATS"] = "false"
+
+TZ             = os.getenv("APP_TZ", "America/Toronto")
+CUTOFF_HOUR    = int(os.getenv("CUTOFF_HOUR", "20"))   # 8pm local
+INACTIVITY_MIN = int(os.getenv("INACTIVITY_MIN", "30"))
+
+def local_now() -> datetime:
+    return datetime.now(pytz.timezone(TZ))
+
+# Enhanced page config with modern settings
+st.set_page_config(
+    page_title="Care Count - Volunteer Management",
+    page_icon="💜",
+    layout="wide",
+    initial_sidebar_state="expanded",
+    menu_items={
+        'Get Help': 'https://github.com/your-repo/care-count',
+        'Report a bug': "https://github.com/your-repo/care-count/issues",
+        'About': "# Care Count\nVolunteer management system for community impact tracking"
+    }
+)
+
+# Apply modern UI styling
+apply_modern_ui()
+
+# ------------------------ Enhanced Secrets Management ------------------------
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except Exception:
+    pass
+
+try:
+    _SECRETS = getattr(st, "secrets", {})
+except Exception:
+    _SECRETS = {}
+
+def _is_useful(val: Optional[str]) -> bool:
+    return val is not None and str(val).strip() != ""
+
+def get_secret(name: str, default: Optional[str] = None) -> Optional[str]:
+    """Enhanced secret management with logging"""
+    v = os.getenv(name)
+    if _is_useful(v):
+        logger.info(f"Secret {name} loaded from environment")
+        return v
+
+    try:
+        if hasattr(_SECRETS, "get"):
+            v = _SECRETS.get(name, default)
+            if _is_useful(v):
+                logger.info(f"Secret {name} loaded from Streamlit secrets")
+                return v
+    except Exception as e:
+        logger.warning(f"Failed to load secret {name} from Streamlit secrets: {e}")
+
+    return default
+
+def require_secret(name: str) -> str:
+    """Enhanced secret requirement with better error handling"""
+    v = get_secret(name, None)
+    if not _is_useful(v):
+        st.error(
+            f"🔐 **Configuration Error**\n\n"
+            f"Missing required configuration: `{name}`\n\n"
+            f"Please ensure this is set in your environment variables or `.streamlit/secrets.toml` file.\n\n"
+            f"For help, check the [documentation](https://github.com/your-repo/care-count#configuration)."
+        )
+        st.stop()
+    return str(v)
+
+# Required Supabase credentials
+SUPABASE_URL = require_secret("SUPABASE_URL")
+SUPABASE_KEY = require_secret("SUPABASE_KEY")
+
+# Initialize Supabase client with error handling
+try:
+sb: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+    logger.info("Supabase client initialized successfully")
+except Exception as e:
+    st.error(f"Failed to connect to Supabase: {e}")
+    logger.error(f"Supabase connection failed: {e}")
+    st.stop()
+
+# Optional provider/config
+PROVIDER         = (get_secret("PROVIDER", "nebius") or "nebius").strip().lower()
+GEMMA_MODEL      = (get_secret("GEMMA_MODEL", "google/gemma-3-27b-it") or "google/gemma-3-27b-it").strip()
+NEBIUS_API_KEY   = get_secret("NEBIUS_API_KEY")
+NEBIUS_BASE_URL  = get_secret("NEBIUS_BASE_URL", "https://api.nebius.ai/v1")
+FEATH_API_KEY    = get_secret("FEATHERLESS_API_KEY")
+FEATH_BASE_URL   = get_secret("FEATHERLESS_BASE_URL", "https://api.featherless.ai/v1")
+
+# ------------------------ Enhanced Event Logging ------------------------
+def log_event(action: str, actor: Optional[str], details: dict, level: str = "info"):
+    """Enhanced event logging with multiple levels"""
+    log_data = {
+        "timestamp": datetime.utcnow().isoformat(),
+        "action": action,
+        "actor_email": actor,
+        "details": details,
+        "level": level
+    }
+    
+    # Log to file
+    if level == "error":
+        logger.error(f"Event: {action} by {actor} - {details}")
+    elif level == "warning":
+        logger.warning(f"Event: {action} by {actor} - {details}")
+    else:
+        logger.info(f"Event: {action} by {actor} - {details}")
+    
+    # Log to database
+    try:
+        sb.table("events").insert(log_data).execute()
+    except Exception as e:
+        logger.error(f"Failed to log event to database: {e}")
+
+# ------------------------ Modern Authentication UI ------------------------
+def auth_block() -> tuple[bool, Optional[str]]:
+    """Enhanced authentication with modern UI"""
+    if "auth_email" not in st.session_state:
+        st.session_state["auth_email"] = None
+    if "user_email" in st.session_state:
+        return True, st.session_state["user_email"]
+
+    # Modern hero section for login
+    st.markdown(ModernUIComponents.create_hero_section(
+        "Care Count",
+        "Thanks for showing up for the community today. Snap items, keep visits tidy, and help us understand the impact of your time."
+    ), unsafe_allow_html=True)
+
+    # Modern login form
+    with st.container():
+        st.markdown('<div class="modern-card">', unsafe_allow_html=True)
+        st.subheader("🔐 Sign In")
+        st.markdown("Enter your email to receive a secure login code.")
+        
+        with st.form("otp_request", clear_on_submit=False):
+            email = st.text_input(
+                "Email Address", 
+                value=st.session_state.get("auth_email") or "", 
+                placeholder="your.email@example.com",
+                help="We'll send you a secure 6-digit code"
+            )
+            
+            col1, col2, col3 = st.columns([1, 2, 1])
+            with col2:
+                send = st.form_submit_button("📧 Send Login Code", use_container_width=True)
+            
+        if send:
+            if not email or "@" not in email:
+                    st.error("Please enter a valid email address.")
+            else:
+                try:
+                        with st.spinner("Sending login code..."):
+                    sb.auth.sign_in_with_otp({"email": email, "shouldCreateUser": True})
+                    st.session_state["auth_email"] = email
+                            st.success("✅ Login code sent! Check your email.")
+                            log_event("otp_requested", email, {"method": "email"})
+                except Exception as e:
+                        st.error(f"❌ Could not send code: {e}")
+                        log_event("otp_failed", email, {"error": str(e)}, "error")
+
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    # OTP verification form
+    if st.session_state.get("auth_email"):
+        with st.container():
+            st.markdown('<div class="modern-card">', unsafe_allow_html=True)
+            st.subheader("🔢 Verify Code")
+            st.markdown(f"Enter the 6-digit code sent to **{st.session_state['auth_email']}**")
+            
+            with st.form("otp_verify", clear_on_submit=True):
+                code = st.text_input(
+                    "Verification Code", 
+                    max_chars=6,
+                    placeholder="123456",
+                    help="Enter the 6-digit code from your email"
+                )
+                
+                col1, col2, col3 = st.columns([1, 2, 1])
+                with col2:
+                    ok = st.form_submit_button("✅ Verify & Start Shift", use_container_width=True)
+                
+            if ok:
+                    if len(code) != 6 or not code.isdigit():
+                        st.error("Please enter a valid 6-digit code.")
+                    else:
+                try:
+                            with st.spinner("Verifying code..."):
+                    res = sb.auth.verify_otp({"email": st.session_state["auth_email"], "token": code, "type": "email"})
+                    if res and res.user:
+                        email = st.session_state["auth_email"]
+                                    
+                                    # Enhanced volunteer upsert
+                                    volunteer_data = {
+                            "email": email,
+                            "last_login_at": datetime.utcnow().isoformat(),
+                            "shift_started_at": datetime.utcnow().isoformat(),
+                                        "shift_ended_at": None,
+                                        "login_count": 1  # Track login frequency
+                                    }
+                                    
+                                    sb.table("volunteers").upsert(volunteer_data, on_conflict="email").execute()
+                                    
+                        st.session_state["user_email"] = email
+                        st.session_state["shift_started"] = True
+                        st.session_state["last_activity_at"] = local_now()
+                                    
+                                    log_event("login_success", email, {"method": "otp"})
+                                    st.success("🎉 Welcome back! Your shift has started.")
+                                    st.balloons()
+                        return True, email
+                except Exception as e:
+                            st.error(f"❌ Verification failed: {e}")
+                            log_event("otp_verification_failed", st.session_state["auth_email"], {"error": str(e)}, "error")
+            
+            st.markdown('</div>', unsafe_allow_html=True)
+    
+    return False, None
+
+def end_shift(email: str, reason: str):
+    """Enhanced shift ending with better logging"""
+    try:
+        end_time = datetime.utcnow().isoformat()
+        sb.table("volunteers").update({"shift_ended_at": end_time}).eq("email", email).execute()
+        log_event("shift_end", email, {"reason": reason, "end_time": end_time})
+    except Exception as e:
+        logger.error(f"Failed to end shift for {email}: {e}")
+
+def guard_cutoff_and_idle(email: str):
+    """Enhanced session management with better UX"""
+    now = local_now()
+    last = st.session_state.get("last_activity_at")
+    
+    if last and (now - last).total_seconds() > INACTIVITY_MIN * 60:
+        end_shift(email, "inactivity")
+        st.session_state.clear()
+        st.warning("⏰ You were logged out due to inactivity. Thank you for volunteering today!")
+        st.stop()
+    
+    st.session_state["last_activity_at"] = now
+
+    cutoff = now.replace(hour=CUTOFF_HOUR, minute=0, second=0, microsecond=0)
+    if now >= cutoff:
+        end_shift(email, "cutoff_8pm")
+        st.session_state.clear()
+        st.info("🌅 We close the day at 8pm. Your shift has been ended. Thank you so much!")
+        st.stop()
+
+# ------------------------ Main App Flow ------------------------
+def main():
+    """Main application flow with modern UI"""
+    
+    # Authentication
+signed_in, user_email = auth_block()
+if not signed_in:
+    st.stop()
+    
+guard_cutoff_and_idle(user_email)
+
+    # Modern welcome section
+    st.markdown(ModernUIComponents.create_hero_section(
+        "Care Count Dashboard",
+        "Manage visits, track items, and make a difference in your community.",
+        user_email
+    ))
+
+    # Enhanced status cards
+    vrow = fetch_volunteer_row(user_email) or {}
+    shift_started_at = vrow.get("shift_started_at")
+    lifetime_hours = vrow.get("total_hours", 0)
+    
+    mins_active = 0
+    try:
+        if shift_started_at:
+            t0 = datetime.fromisoformat(str(shift_started_at).replace("Z","+00:00"))
+            mins_active = max(0, int((datetime.utcnow() - t0).total_seconds() // 60))
+    except Exception:
+        pass
+
+    status_data = {
+        "shift_active": f"{mins_active} min",
+        "items_today": items_today(user_email),
+        "lifetime_hours": f"{round(float(lifetime_hours), 1)} hrs" if isinstance(lifetime_hours, (int, float)) else "0.0 hrs"
+    }
+    
+    st.markdown(ModernUIComponents.create_status_cards(status_data), unsafe_allow_html=True)
+
+    # Modern sign-out button
+    col1, col2, col3 = st.columns([1, 1, 1])
+    with col2:
+        if st.button("🔒 Sign Out", use_container_width=True, type="secondary"):
+        end_shift(user_email, "manual")
+        st.session_state.clear()
+            st.success("✅ Signed out successfully. See you next time!")
+            st.rerun()
+
+    # Enhanced visit management section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "🪪 Visit Management",
+        "Start and manage student visits with unique tracking codes"
+    ), unsafe_allow_html=True)
+    
+    active_visit = st.session_state.get("active_visit")
+    
+    col1, col2, col3 = st.columns([1, 1, 1])
+    
+    with col1:
+        if not active_visit and st.button("🚀 Start New Visit", use_container_width=True, type="primary"):
+            try:
+                with st.spinner("Creating visit..."):
+                    payload = {
+                        "visit_code": fallback_visit_code(),
+                        "started_at": datetime.utcnow().isoformat(),
+                        "ended_at": None,
+                        "created_by": user_email
+                    }
+                    v = sb.table("visits").insert(payload).execute().data[0]
+                    if not v.get("visit_code"):
+                        v["visit_code"] = payload["visit_code"]
+                    st.session_state["active_visit"] = v
+                    st.success(f"✅ Visit #{v['id']} started")
+                    st.info(f"**Visit Code:** `{v['visit_code']}`")
+                    log_event("visit_start", user_email, {"visit_id": v["id"], "visit_code": v["visit_code"]})
+                    st.rerun()
+            except Exception as e:
+                st.error(f"❌ Could not start visit: {e}")
+                log_event("visit_start_failed", user_email, {"error": str(e)}, "error")
+
+    with col2:
+        if active_visit and st.button("🏁 End Visit", use_container_width=True, type="secondary"):
+            try:
+                with st.spinner("Ending visit..."):
+                    sb.table("visits").update({"ended_at": datetime.utcnow().isoformat()}) \
+                      .eq("id", active_visit["id"]).execute()
+                    st.success("✅ Visit completed successfully")
+                    log_event("visit_end", user_email, {"visit_id": active_visit["id"]})
+                    st.session_state.pop("active_visit", None)
+                    st.rerun()
+            except Exception as e:
+                st.error(f"❌ Could not end visit: {e}")
+                log_event("visit_end_failed", user_email, {"error": str(e)}, "error")
+
+    with col3:
+        if st.session_state.get("active_visit"):
+            v = st.session_state["active_visit"]
+            st.info(f"**Active Visit:** #{v['id']}\n**Code:** {v.get('visit_code','')}")
+        else:
+            st.info("No active visit")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced item identification section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📸 Item Identification",
+        "Use AI-powered image recognition to identify items quickly and accurately"
+    ), unsafe_allow_html=True)
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("📷 Camera Capture")
+        cam = st.camera_input("Take a photo of the item", help="Position the item clearly in the frame")
+    
+    with col2:
+        st.subheader("📁 File Upload")
+        up = st.file_uploader(
+            "Upload an image", 
+            type=["png","jpg","jpeg"],
+            help="Supported formats: PNG, JPG, JPEG"
+        )
+
+    img_file = cam or up
+    if img_file:
+        try:
+            img = Image.open(img_file).convert("RGB")
+            st.image(img, use_container_width=True, caption="Captured Image")
+            
+            if st.button("🔍 Identify Item with AI", use_container_width=True, type="primary"):
+                with st.spinner("Analyzing image with AI..."):
+                    t0 = time.time()
+                    try:
+                        pre = preprocess_for_label(img)
+                        raw = gemma_item_name(_to_png_bytes(pre))
+                        processing_time = time.time() - t0
+                        
+                        norm = normalize_item_name(raw)
+                        
+                        if raw:
+                            st.success(f"🤖 **AI Detection:** {raw}")
+                        st.info(f"✨ **Normalized:** {norm or '(unknown)'} · ⏱️ {processing_time:.2f}s")
+                        
+                        st.session_state["scanned_item_name"] = norm or raw or ""
+                        st.session_state["last_activity_at"] = local_now()
+                        
+                        log_event("item_identified", user_email, {
+                            "raw_name": raw,
+                            "normalized_name": norm,
+                            "processing_time": processing_time
+                        })
+                        
+                    except Exception as e:
+                        st.error(f"❌ AI identification failed: {e}")
+                        log_event("ai_identification_failed", user_email, {"error": str(e)}, "error")
+        except Exception as e:
+            st.error(f"❌ Failed to process image: {e}")
+            log_event("image_processing_failed", user_email, {"error": str(e)}, "error")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced item logging section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📬 Item Logging",
+        "Log items to the current visit with detailed information"
+    ), unsafe_allow_html=True)
+    
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        item_name = st.text_input(
+            "Item Name", 
+            value=st.session_state.get("scanned_item_name",""),
+            placeholder="Enter item name or use AI detection above",
+            help="Required field - item name for tracking"
+        )
+    
+    with col2:
+        quantity = st.number_input(
+            "Quantity", 
+            min_value=1, 
+            max_value=9999, 
+            step=1, 
+            value=1,
+            help="Number of items"
+        )
+    
+    col3, col4 = st.columns(2)
+    
+    with col3:
+        category = st.text_input(
+            "Category (optional)", 
+            placeholder="e.g., Food, Hygiene, Clothing",
+            help="Item category for better organization"
+        )
+    
+    with col4:
+        unit = st.text_input(
+            "Unit (optional)", 
+            placeholder="e.g., 500 mL, 1 L, 250 g",
+            help="Unit of measurement"
+        )
+    
+    barcode = st.text_input(
+        "Barcode (optional)", 
+        placeholder="Scan or enter barcode",
+        help="Product barcode for inventory tracking"
+    )
+
+    save_disabled = not st.session_state.get("active_visit")
+    if st.button("✅ Save Item to Visit", disabled=save_disabled, use_container_width=True, type="primary"):
+        v = st.session_state.get("active_visit")
+        if not v:
+            st.warning("⚠️ Please start a visit first before logging items.")
+        else:
+            name_clean = clean_text(item_name, 120)
+            if not name_clean:
+                st.warning("⚠️ Item name is required.")
+            else:
+                with st.spinner("Saving item..."):
+                    ts_iso = datetime.utcnow().isoformat()
+                    ingest_id = deterministic_ingest_id(int(v["id"]), user_email, name_clean, int(quantity), ts_iso)
+                    
+                    try:
+                        ok, msg = try_rpc_ingest(
+                            email=user_email, v_id=int(v["id"]), name=name_clean, qty=int(quantity),
+                            category=clean_text(category, 80), unit=clean_text(unit, 40),
+                            barcode=clean_text(barcode, 64), ts_iso=ts_iso, ingest_id=ingest_id
+                        )
+                        
+                        if ok:
+                            st.success("✅ Item logged successfully!")
+                            log_event("item_logged", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                        else:
+                            st.warning(f"⚠️ {msg}. Trying fallback method...")
+                            fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                                   clean_text(category,80), clean_text(unit,40),
+                                                   clean_text(barcode,64), ts_iso, ingest_id)
+                            st.success("✅ Item logged successfully (fallback method)!")
+                            log_event("item_logged_fallback", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                    except Exception as e:
+                        try:
+                            fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                                   clean_text(category,80), clean_text(unit,40),
+                                                   clean_text(barcode,64), ts_iso, ingest_id)
+                            st.success("✅ Item logged successfully (fallback method)!")
+                            log_event("item_logged_fallback", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                        except Exception as e2:
+                            st.error(f"❌ Failed to log item: {e2}")
+                            log_event("item_log_failed", user_email, {"error": str(e2)}, "error")
+                    
+                    st.session_state["last_activity_at"] = local_now()
+                    st.session_state["scanned_item_name"] = name_clean
+                    st.rerun()
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced visit items view
+    if st.session_state.get("active_visit"):
+        st.markdown(ModernUIComponents.create_modern_form_section(
+            "🧾 Current Visit Items",
+            "Review and manage items in the current visit"
+        ), unsafe_allow_html=True)
+        
+        rows = load_items_for_visit(int(st.session_state["active_visit"]["id"]))
+        if rows:
+            df = pd.DataFrame(rows)
+            
+            # Enhanced dataframe display
+            st.dataframe(
+                df, 
+                use_container_width=True,
+                hide_index=True,
+                column_config={
+                    "timestamp": st.column_config.DatetimeColumn("Time", format="MM/DD/YY HH:mm"),
+                    "item_name": st.column_config.TextColumn("Item Name", width="medium"),
+                    "qty": st.column_config.NumberColumn("Quantity", width="small"),
+                    "category": st.column_config.TextColumn("Category", width="small"),
+                    "unit": st.column_config.TextColumn("Unit", width="small")
+                }
+            )
+            
+            # Enhanced delete functionality
+            with st.expander("🗑️ Delete Item (if mis-logged)"):
+                if rows:
+                    item_options = {f"{r['item_name']} (Qty: {r['qty']})": r["id"] for r in rows if "id" in r}
+                    selected_item = st.selectbox("Select item to delete", list(item_options.keys()))
+                    
+                    if st.button("🗑️ Delete Selected Item", type="secondary"):
+                        item_id = item_options[selected_item]
+                        try:
+                            # Try both tables safely
+                            try:
+                                delete_item("visit_items_p", int(item_id))
+                            except Exception:
+                                delete_item("visit_items", int(item_id))
+                            
+                            st.success("✅ Item deleted successfully")
+                            log_event("item_deleted", user_email, {"item_id": item_id})
+                            st.rerun()
+                        except Exception as e:
+                            st.error(f"❌ Failed to delete item: {e}")
+                            log_event("item_delete_failed", user_email, {"error": str(e)}, "error")
+                else:
+                    st.info("No items to delete")
+        else:
+            st.info("📝 No items logged for this visit yet.")
+        
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced analytics section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📈 Today's Analytics",
+        "Real-time insights into today's volunteer activity"
+    ), unsafe_allow_html=True)
+    
+    try:
+        daily = sb.table("v_daily_activity").select("*").execute().data
+        today_str = local_now().strftime("%Y-%m-%d")
+        today = next((r for r in daily if str(r.get("day",""))[:10]==today_str), None)
+        
+        if today:
+            visits = int(today.get("visits", 0))
+            items = int(today.get("items", 0))
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                st.metric("Total Visits Today", visits, delta=None)
+            with col2:
+                st.metric("Total Items Processed", items, delta=None)
+            
+            # Progress indicator
+            if visits > 0:
+                st.markdown(ModernUIComponents.create_progress_indicator(
+                    items, visits * 10, "Items per Visit Target"
+                ), unsafe_allow_html=True)
+        else:
+            st.info("📊 Analytics data will appear here as activity increases.")
+            
+    except Exception as e:
+        st.info("📊 Analytics view will be available once the database view is set up.")
+        logger.warning(f"Analytics view not available: {e}")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced footer with helpful information
+    st.markdown("""
+    <div class="modern-card" style="margin-top: var(--space-8); text-align: center;">
+        <h4>💡 Quick Tips</h4>
+        <p style="color: var(--gray-400); margin: 0;">
+            When you're done, please <strong>End Visit</strong> and <strong>Sign out</strong>.<br>
+            We'll auto-sign you out after inactivity or at 8pm local time. 💜
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+
+# ------------------------ Helper Functions (Enhanced) ------------------------
+def fetch_volunteer_row(email: str) -> dict | None:
+    """Enhanced volunteer data fetching with error handling"""
+    try:
+        return sb.table("volunteers").select("*").eq("email", email).single().execute().data
+    except Exception as e:
+        logger.warning(f"Failed to fetch volunteer data for {email}: {e}")
+        return None
+
+def items_today(email: str) -> int:
+    """Enhanced item counting with better error handling"""
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        # Try partitioned table first
+        data = sb.table("visit_items_p").select("id,timestamp,volunteer") \
+                .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                .eq("volunteer", email).execute().data
+        return len(data or [])
+    except Exception:
+        try:
+            data = sb.table("visit_items").select("id,timestamp,volunteer") \
+                    .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                    .eq("volunteer", email).execute().data
+            return len(data or [])
+        except Exception as e:
+            logger.warning(f"Failed to count items for {email}: {e}")
+            return 0
+
+def fallback_visit_code() -> str:
+    """Enhanced visit code generation with better uniqueness"""
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        todays = sb.table("visits").select("id,started_at").gte("started_at", f"{day} 00:00:00") \
+                 .lte("started_at", f"{day} 23:59:59").execute().data or []
+        seq = len(todays) + 1
+except Exception:
+        seq = int(time.time()) % 1000
+    return f"V-{seq}-{local_now().strftime('%Y%m%d')}-{str(uuid.uuid4())[:6]}"
+
+def _to_png_bytes(img: Image.Image) -> bytes:
+    """Convert image to PNG bytes"""
+    b = io.BytesIO()
+    img.save(b, format="PNG")
+    return b.getvalue()
+
+def preprocess_for_label(img: Image.Image) -> Image.Image:
+    """Enhanced image preprocessing for better AI recognition"""
+    img = img.convert("RGB")
+    w, h = img.size
+    scale = 1024 / max(w, h) if max(w, h) > 1024 else 1.0
+    if scale < 1.0: 
+        img = img.resize((int(w * scale), int(h * scale)))
+    img = ImageOps.autocontrast(img, cutoff=2)
+    img = ImageEnhance.Brightness(img).enhance(1.06)
+    img = ImageEnhance.Contrast(img).enhance(1.05)
+    img = ImageEnhance.Sharpness(img).enhance(1.15)
+    return img
+
+def gemma_item_name(img_bytes: bytes) -> str:
+    """Enhanced AI item identification with better error handling"""
+    try:
+        if PROVIDER == "nebius":
+            if not NEBIUS_API_KEY: 
+                raise RuntimeError("NEBIUS_API_KEY missing")
+            return _openai_style_chat(NEBIUS_BASE_URL, NEBIUS_API_KEY, GEMMA_MODEL, img_bytes)
+        elif PROVIDER == "featherless":
+            if not FEATH_API_KEY: 
+                raise RuntimeError("FEATHERLESS_API_KEY missing")
+            return _openai_style_chat(FEATH_BASE_URL, FEATH_API_KEY, GEMMA_MODEL, img_bytes)
+        else:
+            raise RuntimeError(f"Unknown PROVIDER: {PROVIDER}")
+    except Exception as e:
+        logger.error(f"AI identification failed: {e}")
+        raise
+
+def _openai_style_chat(base_url: str, api_key: str, model_id: str, img_bytes: bytes) -> str:
+    """Enhanced API communication with better error handling"""
+    b64 = base64.b64encode(img_bytes).decode("utf-8")
+    url = f"{base_url.rstrip('/')}/chat/completions"
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    payload = {
+        "model": model_id,
+        "temperature": 0,
+        "messages": [
+            {"role": "system", "content": "You label item being held in the image for a food bank. Return ONLY the item name."},
+            {"role": "user", "content": [
+                {"type": "text", "text": "What is the name of the item in the picture? Return only the item name."},
+                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}}
+            ]}
+        ]
+    }
+    
+    try:
+    r = requests.post(url, json=payload, headers=headers, timeout=90)
+    if r.status_code != 200:
+        raise RuntimeError(f"LLM HTTP {r.status_code}: {r.text[:200]}")
+    data = r.json()
+    return (data["choices"][0]["message"]["content"] or "").strip()
+    except requests.exceptions.Timeout:
+        raise RuntimeError("AI service timeout - please try again")
+    except requests.exceptions.RequestException as e:
+        raise RuntimeError(f"AI service error: {e}")
+
+def normalize_item_name(s: str) -> str:
+    """Enhanced item name normalization"""
+    s = (s or "").strip()
+    if not s: 
+        return ""
+    
+    # Enhanced brand and type recognition
+BRANDS = {
+    "whiskas","tetley","kellogg's","kelloggs","campbell's","campbells","heinz",
+    "nestle","kraft","general mills","cheerios","oreo","oreos","pringles","lays","doritos",
+    "ice river","green bottle","great value","wheat thins","vegetable thins","raid"
+}
+GENERIC_TYPES = {
+    "water","toothpaste","deodorant","antiperspirant","soap","shampoo","conditioner",
+    "lotion","tea","coffee","cereal","pasta","rice","beans","sauce","salsa","cleaner",
+    "peanut butter","jam","jelly","tuna","chicken","beef","flour","sugar","salt","oil",
+    "crackers","cookies","soup","insect killer","spray"
+}
+    
+    low = re.sub(r"[®™]", "", s.lower())
+    for b in BRANDS: 
+        low = low.replace(b, "")
+    
+    chosen = None
+    for t in GENERIC_TYPES:
+        if t in low: 
+            chosen = t
+            break
+    
+    cleaned = " ".join(low.split())
+    return (chosen or cleaned.title())[:120]
+
+def clean_text(v: Optional[str], maxlen: int = 120) -> Optional[str]:
+    """Enhanced text cleaning"""
+    if not v: 
+        return None
+    v = re.sub(r"\s+", " ", v).strip()
+    return v[:maxlen] if v else None
+
+def deterministic_ingest_id(v_id: int, email: str, name: str, qty: int, ts_iso: str) -> str:
+    """Enhanced ID generation for data integrity"""
+    key = f"visit_items::{v_id}::{email}::{name}::{qty}::{ts_iso}"
+    return str(uuid.uuid5(uuid.NAMESPACE_URL, key))
+
+def try_rpc_ingest(email: str, v_id: int, name: str, qty: int,
+                   category: Optional[str], unit: Optional[str],
+                   barcode: Optional[str], ts_iso: str, ingest_id: str) -> tuple[bool,str]:
+    """Enhanced RPC ingestion with better error handling"""
+    try:
+        res = sb.rpc("safe_ingest_visit_item", {
+            "p_email": email,
+            "p_visit_id": v_id,
+            "p_item_name": name,
+            "p_qty": qty,
+            "p_category": category,
+            "p_unit": unit,
+            "p_barcode": barcode,
+            "p_ts": ts_iso,
+            "p_ingest_id": ingest_id
+        }).execute()
+        
+        rows = res.data if isinstance(res.data, list) else []
+        if rows:
+            r0 = rows[0]
+            ok = bool(r0.get("ok", False))
+            msg = str(r0.get("msg", ""))
+            return ok, msg or ("ok" if ok else "failed")
+        return True, "ok"
+    except Exception as e:
+        logger.warning(f"RPC ingest failed, using fallback: {e}")
+        raise e
+
+def fallback_direct_insert(email: str, v_id: int, name: str, qty: int,
+                           category: Optional[str], unit: Optional[str],
+                           barcode: Optional[str], ts_iso: str, ingest_id: str) -> None:
+    """Enhanced fallback insertion with better error handling"""
+    payload = {
+        "visit_id": v_id,
+        "timestamp": ts_iso,
+        "volunteer": email,
+        "item_name": name,
+        "category": category,
+        "unit": unit,
+        "qty": qty,
+        "barcode": barcode,
+        "weather_type": None,
+        "temp_c": None,
+        "ingest_id": ingest_id
+    }
+    
+    try:
+        sb.table("visit_items_p").insert(payload).execute()
+    except Exception:
+        # Legacy table fallback
+        payload.pop("ingest_id", None)
+        sb.table("visit_items").insert(payload).execute()
+
+def load_items_for_visit(visit_id: int) -> list[dict]:
+    """Enhanced item loading with better error handling"""
+    try:
+        return sb.table("visit_items_p").select("*").eq("visit_id", visit_id) \
+            .order("timestamp", desc=True).limit(500).execute().data or []
+    except Exception:
+        try:
+            return sb.table("visit_items").select("*").eq("visit_id", visit_id) \
+                .order("timestamp", desc=True).limit(500).execute().data or []
+        except Exception as e:
+            logger.warning(f"Failed to load items for visit {visit_id}: {e}")
+            return []
+
+def delete_item(table: str, item_id: int):
+    """Enhanced item deletion with better error handling"""
+    try:
+        sb.table(table).delete().eq("id", item_id).execute()
+    except Exception as e:
+        logger.error(f"Failed to delete item {item_id} from {table}: {e}")
+        raise e
+
+# ------------------------ App Configuration Display ------------------------
+st.sidebar.markdown("### ⚙️ Configuration")
+st.sidebar.info(f"""
+**Provider:** `{PROVIDER}`  
+**Model:** `{GEMMA_MODEL}`  
+**Timezone:** `{TZ}`  
+**Cutoff:** {CUTOFF_HOUR}:00 PM  
+**Inactivity:** {INACTIVITY_MIN} min
+""")
+
+# ------------------------ Main App Execution ------------------------
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        logger.error(f"Application error: {e}")
+        st.error(f"❌ Application error: {e}")
+        st.info("Please refresh the page or contact support if the issue persists.")

backups/pre_modern_deployment_20250923_202615/backup_metadata.json

@@ -0,0 +1,32 @@
+{
+  "backup_name": "pre_modern_deployment_20250923_202615",
+  "timestamp": "20250923_202615",
+  "description": "pre_modern_deployment",
+  "files_backed_up": [
+    "streamlit_app.py",
+    "streamlit_app_modern.py",
+    ".streamlit/secrets.toml",
+    "requirements.txt",
+    "ui_improvements.py",
+    "test_app.py"
+  ],
+  "git_status": {
+    "modified_files": [
+      "M requirements.txt",
+      " M streamlit_app.py",
+      "?? .streamlit/",
+      "?? .venv/",
+      "?? __pycache__/",
+      "?? backups/",
+      "?? care_count.log",
+      "?? deploy_modern.py",
+      "?? deployment.log",
+      "?? streamlit_app_backup_20250923_195853.py",
+      "?? streamlit_app_modern.py",
+      "?? test_app.py",
+      "?? test_results.log",
+      "?? ui_improvements.py"
+    ],
+    "return_code": 0
+  }
+}

backups/pre_modern_deployment_20250923_202615/requirements.txt

@@ -0,0 +1,9 @@
+streamlit>=1.33
+pandas>=2.1
+Pillow>=10.1
+supabase>=2.5
+huggingface_hub>=0.24.6
+requests>=2.31
+python-dotenv>=1.0.0
+pytz>=2023.3
+

backups/pre_modern_deployment_20250923_202615/secrets.toml

@@ -0,0 +1,15 @@
+# Supabase connection
+SUPABASE_URL = "https://oudjcqhyldpncjbxohsg.supabase.co"
+SUPABASE_KEY ="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im91ZGpjcWh5bGRwbmNqYnhvaHNnIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTUzMDgyNDQsImV4cCI6MjA3MDg4NDI0NH0.SYwTtCe3r7WOZ25CRggL-lBkvGPjKnQhY_dT4Kjv9Dg"
+
+# App settings
+APP_TZ = "America/Toronto"
+
+# Hugging Face
+HF_TOKEN = "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"
+
+# Optional VLM model provider
+PROVIDER = "nebius"
+GEMMA_MODEL = "google/gemma-3-27b-it"
+NEBIUS_API_KEY = "eyJhbGciOiJIUzI1NiIsImtpZCI6IlV6SXJWd1h0dnprLVRvdzlLZWstc0M1akptWXBvX1VaVkxUZlpnMDRlOFUiLCJ0eXAiOiJKV1QifQ.eyJzdWIiOiJnb29nbGUtb2F1dGgyfDEwMjk4MzMxNjQ1OTQzNjA5ODYxMyIsInNjb3BlIjoib3BlbmlkIG9mZmxpbmVfYWNjZXNzIiwiaXNzIjoiYXBpX2tleV9pc3N1ZXIiLCJhdWQiOlsiaHR0cHM6Ly9uZWJpdXMtaW5mZXJlbmNlLmV1LmF1dGgwLmNvbS9hcGkvdjIvIl0sImV4cCI6MTkxNTEzMTE3MiwidXVpZCI6IjJmOTUxZmM1LWEyNTgtNDg5OC1iNWI4LTkwZTljY2RkZjU2NSIsIm5hbWUiOiJjYXJlIGNvdW50IGFwcCIsImV4cGlyZXNfYXQiOiIyMDMwLTA5LTA4VDIwOjUyOjUyKzAwMDAifQ.awAHOieD93pCnYmFMgRQ64-i6yZdO0XvXczD4eS6xEI"
+NEBIUS_BASE_URL = "https://api.nebius.ai/v1"

backups/pre_modern_deployment_20250923_202615/streamlit_app.py

@@ -0,0 +1,612 @@
+# --- Care Count (Volunteers → Visits → Items) ---
+# Delightful Laurier-themed UX + enterprise data hygiene
+# - OTP email login (Supabase)
+# - Shift tracking & idle/8pm auto sign-out
+# - Human-friendly visit_code (with DB trigger or safe fallback)
+# - VLM-assisted item name
+# - RPC ingest with validation/quarantine (fallback to direct insert)
+# - Volunteer Impact card (today + lifetime)
+
+from __future__ import annotations
+
+import os, io, time, base64, re, uuid, json
+from datetime import datetime, timedelta
+from typing import Optional
+
+import pytz
+import requests
+import pandas as pd
+import streamlit as st
+from PIL import Image, ImageOps, ImageEnhance
+from supabase import create_client, Client
+
+# ------------------------ App config ------------------------
+os.environ.setdefault("HOME", "/tmp")
+os.environ["STREAMLIT_BROWSER_GATHER_USAGE_STATS"] = "false"
+
+TZ             = os.getenv("APP_TZ", "America/Toronto")
+CUTOFF_HOUR    = int(os.getenv("CUTOFF_HOUR", "20"))   # 8pm local
+INACTIVITY_MIN = int(os.getenv("INACTIVITY_MIN", "30"))
+
+def local_now() -> datetime:
+    return datetime.now(pytz.timezone(TZ))
+
+st.set_page_config(page_title="Care Count", layout="centered")
+st.markdown("""
+<style>
+/* Laurier theme vibes */
+:root { --cc-purple:#6d28d9; --cc-gold:#fde047; --cc-bg:#0b1420; --cc-panel:#0f1a2a; --cc-border:#1d2a44; }
+.block-container { padding-top: 2rem; }
+h1, h2, .stMarkdown h1, .stMarkdown h2 { letter-spacing:.2px }
+.cc-pill { display:inline-block; padding:4px 10px; border-radius:999px; background:var(--cc-gold); color:#111827; font-weight:700; font-size:12px; }
+.cc-hint { background:#10233b; border:1px solid #1f3b5b; color:#e6e8f0; padding:12px 16px; border-radius:10px; }
+.cc-hero { background:#0f1a2a; border:1px solid #1f2a44; padding:16px 18px; border-radius:14px; }
+.cc-btn-primary button { background:var(--cc-purple)!important; color:#fff!important; border:0!important; }
+.cc-danger button { background:#7f1d1d!important; color:#fff!important; }
+.status-card { display:flex; gap:16px; flex-wrap:wrap; }
+.card { background:#0f1a2a; border:1px solid #1f2a44; border-radius:14px; padding:14px 16px; min-width:200px; }
+.card h4 { margin:0 0 6px 0; font-size:0.95rem; color:#cbd5e1 }
+.card .big { font-size:1.6rem; font-weight:700; color:#e5e7eb }
+.small { color:#9aa3b2; font-size:12px }
+</style>
+""", unsafe_allow_html=True)
+
+st.title("💜💛 Care Count")
+st.caption("Thanks for showing up for the community today. Snap items, keep visits tidy, and help us understand the impact of your time.")
+
+# ------------------------ Secrets & client ------------------------
+# Robust env/secrets helpers that work with Streamlit (st.secrets) and .env/CI.
+# Order of precedence: OS env > Streamlit secrets > default.
+
+# Optional: allow plain `python` runs to pick up a local .env if present
+try:
+    from dotenv import load_dotenv  # pip install python-dotenv (optional)
+    load_dotenv()
+except Exception:
+    pass
+
+# Make Streamlit secrets safe to access even when not launched via `streamlit run`
+try:
+    _SECRETS = getattr(st, "secrets", {})
+except Exception:
+    _SECRETS = {}
+
+def _is_useful(val: Optional[str]) -> bool:
+    return val is not None and str(val).strip() != ""
+
+def get_secret(name: str, default: Optional[str] = None) -> Optional[str]:
+    """
+    Flat TOML usage:
+      SUPABASE_URL = "..."
+      SUPABASE_KEY = "..."
+    Looks in OS env first, then st.secrets, else returns default.
+    """
+    # 1) OS env
+    v = os.getenv(name)
+    if _is_useful(v):
+        return v
+
+    # 2) Streamlit secrets (flat)
+    try:
+        if hasattr(_SECRETS, "get"):
+            v = _SECRETS.get(name, default)
+            if _is_useful(v):
+                return v
+    except Exception:
+        pass
+
+    # 3) default
+    return default
+
+def require_secret(name: str) -> str:
+    """
+    Same as get_secret but fails fast with a clear error if missing/blank.
+    """
+    v = get_secret(name, None)
+    if not _is_useful(v):
+        st.error(
+            f"Missing secret: {name}. "
+            "Ensure it exists as an environment variable or in .streamlit/secrets.toml"
+        )
+        st.stop()
+    return str(v)
+
+# (Optional) lightweight visibility check during setup. Comment out in prod.
+# st.write("Secrets present:",
+#          bool(get_secret("SUPABASE_URL")),
+#          bool(get_secret("SUPABASE_KEY")))
+
+# Required Supabase credentials (flat keys)
+SUPABASE_URL = require_secret("SUPABASE_URL")
+SUPABASE_KEY = require_secret("SUPABASE_KEY")   # anon key (RLS should be ON)
+
+# Initialize Supabase client
+sb: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+
+# Optional provider/config (all flat keys with safe defaults)
+PROVIDER         = (get_secret("PROVIDER", "nebius") or "nebius").strip().lower()
+GEMMA_MODEL      = (get_secret("GEMMA_MODEL", "google/gemma-3-27b-it") or "google/gemma-3-27b-it").strip()
+NEBIUS_API_KEY   = get_secret("NEBIUS_API_KEY")
+NEBIUS_BASE_URL  = get_secret("NEBIUS_BASE_URL", "https://api.nebius.ai/v1")
+FEATH_API_KEY    = get_secret("FEATHERLESS_API_KEY")
+FEATH_BASE_URL   = get_secret("FEATHERLESS_BASE_URL", "https://api.featherless.ai/v1")
+
+
+
+st.caption(f"Provider: `{PROVIDER}` · Model: `{GEMMA_MODEL}` · TZ: `{TZ}`")
+
+# ------------------------ Light events/audit (non-blocking) ------------------------
+def log_event(action: str, actor: Optional[str], details: dict):
+    try:
+        sb.table("events").insert({"actor_email": actor, "action": action, "details": details}).execute()
+    except Exception:
+        pass
+
+# ------------------------ Auth (Email OTP) ------------------------
+def auth_block() -> tuple[bool, Optional[str]]:
+    if "auth_email" not in st.session_state:
+        st.session_state["auth_email"] = None
+    if "user_email" in st.session_state:
+        return True, st.session_state["user_email"]
+
+    st.subheader("Sign in")
+    with st.form("otp_request", clear_on_submit=False, border=False):
+        email = st.text_input("Email", value=st.session_state.get("auth_email") or "", autocomplete="email")
+        send = st.form_submit_button("Send login code")
+        if send:
+            if not email or "@" not in email:
+                st.error("Please enter a valid email.")
+            else:
+                try:
+                    sb.auth.sign_in_with_otp({"email": email, "shouldCreateUser": True})
+                    st.session_state["auth_email"] = email
+                    st.success("We emailed you a one-time code. Enter it to continue.")
+                except Exception as e:
+                    st.error(f"Could not send code: {e}")
+
+    if st.session_state.get("auth_email"):
+        with st.form("otp_verify", clear_on_submit=True, border=False):
+            code = st.text_input("Enter 6-digit code", max_chars=6)
+            ok = st.form_submit_button("Verify & start shift")
+            if ok:
+                try:
+                    res = sb.auth.verify_otp({"email": st.session_state["auth_email"], "token": code, "type": "email"})
+                    if res and res.user:
+                        email = st.session_state["auth_email"]
+                        # Idempotent upsert for volunteer & start shift
+                        sb.table("volunteers").upsert({
+                            "email": email,
+                            "last_login_at": datetime.utcnow().isoformat(),
+                            "shift_started_at": datetime.utcnow().isoformat(),
+                            "shift_ended_at": None
+                        }, on_conflict="email").execute()
+                        st.session_state["user_email"] = email
+                        st.session_state["shift_started"] = True
+                        st.session_state["last_activity_at"] = local_now()
+                        log_event("login", email, {"method":"otp"})
+                        st.toast("Welcome back! Shift started. 💜", icon="✅")
+                        return True, email
+                except Exception as e:
+                    st.error(f"Verification failed: {e}")
+    return False, None
+
+def end_shift(email: str, reason: str):
+    try:
+        sb.table("volunteers").update({"shift_ended_at": datetime.utcnow().isoformat()}).eq("email", email).execute()
+        log_event("shift_end", email, {"reason": reason})
+    except Exception:
+        pass
+
+def guard_cutoff_and_idle(email: str):
+    now = local_now()
+    last = st.session_state.get("last_activity_at")
+    if last and (now - last).total_seconds() > INACTIVITY_MIN * 60:
+        end_shift(email, "inactivity")
+        st.session_state.clear()
+        st.info("You were logged out due to inactivity. Thank you for volunteering today!")
+        st.stop()
+    st.session_state["last_activity_at"] = now
+
+    cutoff = now.replace(hour=CUTOFF_HOUR, minute=0, second=0, microsecond=0)
+    if now >= cutoff:
+        end_shift(email, "cutoff_8pm")
+        st.session_state.clear()
+        st.info("We close the day at 8pm. Your shift has been ended. Thank you so much!")
+        st.stop()
+
+signed_in, user_email = auth_block()
+if not signed_in:
+    st.stop()
+guard_cutoff_and_idle(user_email)
+
+# Welcome banner (visceral, kind)
+st.markdown(
+    f"""<div class="cc-hero">
+    <div class="small">Welcome,</div>
+    <div style="font-weight:800;font-size:1.15rem"> {user_email}</div>
+    <div class="small">Thank you for showing up for the community today. 💜💛</div>
+    </div>""",
+    unsafe_allow_html=True
+)
+
+# Sign-out button (prominent)
+c_signout = st.columns([1,1,6])[1]
+with c_signout:
+    st.markdown('<div class="cc-btn-primary">', unsafe_allow_html=True)
+    if st.button("🔒 Sign out"):
+        end_shift(user_email, "manual")
+        st.session_state.clear()
+        st.success("Signed out. See you next time!")
+        st.stop()
+    st.markdown('</div>', unsafe_allow_html=True)
+
+# ------------------------ Volunteer Impact card ------------------------
+def fetch_volunteer_row(email: str) -> dict | None:
+    try:
+        return sb.table("volunteers").select("*").eq("email", email).single().execute().data
+    except Exception:
+        return None
+
+def items_today(email: str) -> int:
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        # try partitioned table first
+        data = sb.table("visit_items_p").select("id,timestamp,volunteer") \
+                .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                .eq("volunteer", email).execute().data
+        return len(data or [])
+    except Exception:
+        try:
+            data = sb.table("visit_items").select("id,timestamp,volunteer") \
+                    .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                    .eq("volunteer", email).execute().data
+            return len(data or [])
+        except Exception:
+            return 0
+
+vrow = fetch_volunteer_row(user_email) or {}
+shift_started_at = vrow.get("shift_started_at")
+lifetime_hours = vrow.get("total_hours")  # may not exist yet; handled below
+mins_active = 0
+try:
+    if shift_started_at:
+        t0 = datetime.fromisoformat(str(shift_started_at).replace("Z","+00:00"))
+        mins_active = max(0, int((datetime.utcnow() - t0).total_seconds() // 60))
+except Exception:
+    pass
+
+st.markdown('<div class="status-card">', unsafe_allow_html=True)
+st.markdown(f'<div class="card"><h4>Shift active</h4><div class="big">{mins_active} min</div><div class="small">since you signed in</div></div>', unsafe_allow_html=True)
+st.markdown(f'<div class="card"><h4>Items you logged today</h4><div class="big">{items_today(user_email)}</div></div>', unsafe_allow_html=True)
+if isinstance(lifetime_hours, (int, float)):
+    st.markdown(f'<div class="card"><h4>Lifetime hours</h4><div class="big">{round(float(lifetime_hours),1)}</div></div>', unsafe_allow_html=True)
+st.markdown('</div>', unsafe_allow_html=True)
+
+# ------------------------ Image helpers ------------------------
+def _to_png_bytes(img: Image.Image) -> bytes:
+    b = io.BytesIO(); img.save(b, format="PNG"); return b.getvalue()
+
+def preprocess_for_label(img: Image.Image) -> Image.Image:
+    img = img.convert("RGB")
+    w, h = img.size
+    scale = 1024 / max(w, h) if max(w, h) > 1024 else 1.0
+    if scale < 1.0: img = img.resize((int(w * scale), int(h * scale)))
+    img = ImageOps.autocontrast(img, cutoff=2)
+    img = ImageEnhance.Brightness(img).enhance(1.06)
+    img = ImageEnhance.Contrast(img).enhance(1.05)
+    img = ImageEnhance.Sharpness(img).enhance(1.15)
+    return img
+
+# ------------------------ VLM client ------------------------
+SYSTEM_HINT = "You label item being held in the image for a food bank. Return ONLY the item name."
+
+def _openai_style_chat(base_url: str, api_key: str, model_id: str, img_bytes: bytes) -> str:
+    b64 = base64.b64encode(img_bytes).decode("utf-8")
+    url = f"{base_url.rstrip('/')}/chat/completions"
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    payload = {
+        "model": model_id,
+        "temperature": 0,
+        "messages": [
+            {"role": "system", "content": SYSTEM_HINT},
+            {"role": "user", "content": [
+                {"type": "text", "text": "What is the name of the item in the picture? Return only the item name."},
+                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}}
+            ]}
+        ]
+    }
+    r = requests.post(url, json=payload, headers=headers, timeout=90)
+    if r.status_code != 200:
+        raise RuntimeError(f"LLM HTTP {r.status_code}: {r.text[:200]}")
+    data = r.json()
+    return (data["choices"][0]["message"]["content"] or "").strip()
+
+def gemma_item_name(img_bytes: bytes) -> str:
+    if PROVIDER == "nebius":
+        if not NEBIUS_API_KEY: raise RuntimeError("NEBIUS_API_KEY missing")
+        return _openai_style_chat(NEBIUS_BASE_URL, NEBIUS_API_KEY, GEMMA_MODEL, img_bytes)
+    elif PROVIDER == "featherless":
+        if not FEATH_API_KEY: raise RuntimeError("FEATHERLESS_API_KEY missing")
+        return _openai_style_chat(FEATH_BASE_URL, FEATH_API_KEY, GEMMA_MODEL, img_bytes)
+    else:
+        raise RuntimeError(f"Unknown PROVIDER: {PROVIDER}")
+
+# ------------------------ Normalization ------------------------
+BRANDS = {
+    "whiskas","tetley","kellogg's","kelloggs","campbell's","campbells","heinz",
+    "nestle","kraft","general mills","cheerios","oreo","oreos","pringles","lays","doritos",
+    "ice river","green bottle","great value","wheat thins","vegetable thins","raid"
+}
+GENERIC_TYPES = {
+    "water","toothpaste","deodorant","antiperspirant","soap","shampoo","conditioner",
+    "lotion","tea","coffee","cereal","pasta","rice","beans","sauce","salsa","cleaner",
+    "peanut butter","jam","jelly","tuna","chicken","beef","flour","sugar","salt","oil",
+    "crackers","cookies","soup","insect killer","spray"
+}
+def normalize_item_name(s: str) -> str:
+    s = (s or "").strip()
+    if not s: return ""
+    low = re.sub(r"[®™]", "", s.lower())
+    for b in BRANDS: low = low.replace(b, "")
+    chosen = None
+    for t in GENERIC_TYPES:
+        if t in low: chosen = t; break
+    cleaned = " ".join(low.split())
+    return (chosen or cleaned.title())[:120]
+
+def clean_text(v: Optional[str], maxlen: int = 120) -> Optional[str]:
+    if not v: return None
+    v = re.sub(r"\s+", " ", v).strip()
+    return v[:maxlen] if v else None
+
+# ------------------------ Visit flow ------------------------
+st.subheader("🪪 Anonymous Student Visit")
+
+active_visit = st.session_state.get("active_visit")
+
+def fallback_visit_code() -> str:
+    """Readable visit_code if DB trigger isn't present."""
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        todays = sb.table("visits").select("id,started_at").gte("started_at", f"{day} 00:00:00") \
+                 .lte("started_at", f"{day} 23:59:59").execute().data or []
+        seq = len(todays) + 1
+    except Exception:
+        seq = int(time.time()) % 1000
+    return f"V-{seq}-{local_now().strftime('%Y%m%d')}-{str(uuid.uuid4())[:6]}"
+
+c1, c2, c3 = st.columns(3)
+with c1:
+    st.markdown('<div class="cc-btn-primary">', unsafe_allow_html=True)
+    if not active_visit and st.button("Start Visit"):
+        try:
+            payload = {
+                "visit_code": fallback_visit_code(),  # DB trigger will override if present
+                "started_at": datetime.utcnow().isoformat(),
+                "ended_at": None,
+                "created_by": user_email
+            }
+            v = sb.table("visits").insert(payload).execute().data[0]
+            # If trigger generated code, keep that
+            if not v.get("visit_code"):
+                v["visit_code"] = payload["visit_code"]
+            st.session_state["active_visit"] = v
+            st.success(f"Visit #{v['id']} started · code: **{v['visit_code']}**")
+            log_event("visit_start", user_email, {"visit_id": v["id"], "visit_code": v["visit_code"]})
+        except Exception as e:
+            st.error(f"Could not start visit: {e}")
+    st.markdown('</div>', unsafe_allow_html=True)
+
+with c2:
+    if active_visit and st.button("End Visit (Checkout)"):
+        try:
+            sb.table("visits").update({"ended_at": datetime.utcnow().isoformat()}) \
+              .eq("id", active_visit["id"]).execute()
+            st.success("Visit checked out. Ready for the next student.")
+            log_event("visit_end", user_email, {"visit_id": active_visit["id"]})
+            st.session_state.pop("active_visit", None)
+        except Exception as e:
+            st.error(f"Could not end visit: {e}")
+
+with c3:
+    if st.session_state.get("active_visit"):
+        v = st.session_state["active_visit"]
+        st.caption(f"Active visit_id: {v['id']} · code: {v.get('visit_code','')}")
+    else:
+        st.caption("No active visit.")
+
+# ------------------------ Identify item ------------------------
+st.subheader("📸 Identify item from image")
+
+c4, c5 = st.columns(2)
+with c4: cam = st.camera_input("Use your phone or webcam")
+with c5: up  = st.file_uploader("…or upload an image", type=["png","jpg","jpeg"])
+
+img_file = cam or up
+if img_file:
+    img = Image.open(img_file).convert("RGB")
+    st.image(img, use_container_width=True)
+    if st.button("🔍 Ask model for item name"):
+        t0, raw = time.time(), ""
+        try:
+            pre = preprocess_for_label(img); raw = gemma_item_name(_to_png_bytes(pre))
+        except Exception as e:
+            st.error(f"Provider error: {e}"); log_event("vlm_error", user_email, {"error": str(e)})
+        norm = normalize_item_name(raw)
+        if raw: st.success(f"🧠 Model: **{raw}**")
+        st.info(f"✨ Normalized: **{norm or '(unknown)'}** · ⏱️ {time.time()-t0:.2f}s")
+        st.session_state["scanned_item_name"] = norm or raw or ""
+        st.session_state["last_activity_at"] = local_now()
+
+# ------------------------ Log item ------------------------
+st.subheader("📬 Log item to current visit")
+
+item_name = st.text_input("Item name", value=st.session_state.get("scanned_item_name",""))
+quantity  = st.number_input("Quantity", min_value=1, max_value=9999, step=1, value=1)
+category  = st.text_input("Category (optional)")
+unit      = st.text_input("Unit (optional, e.g., 500 mL, 1 L, 250 g)")
+barcode   = st.text_input("Barcode (optional)")
+
+def deterministic_ingest_id(v_id: int, email: str, name: str, qty: int, ts_iso: str) -> str:
+    key = f"visit_items::{v_id}::{email}::{name}::{qty}::{ts_iso}"
+    return str(uuid.uuid5(uuid.NAMESPACE_URL, key))
+
+def try_rpc_ingest(email: str, v_id: int, name: str, qty: int,
+                   category: Optional[str], unit: Optional[str],
+                   barcode: Optional[str], ts_iso: str, ingest_id: str) -> tuple[bool,str]:
+    """
+    Call the RPC safe_ingest_visit_item if it exists.
+    Returns (ok, msg). If function is missing, raises to trigger fallback.
+    """
+    try:
+        res = sb.rpc("safe_ingest_visit_item", {
+            "p_email": email,
+            "p_visit_id": v_id,
+            "p_item_name": name,
+            "p_qty": qty,
+            "p_category": category,
+            "p_unit": unit,
+            "p_barcode": barcode,
+            "p_ts": ts_iso,
+            "p_ingest_id": ingest_id
+        }).execute()
+        # RPC returns a setof (ok boolean, msg text) — normalize
+        rows = res.data if isinstance(res.data, list) else []
+        if rows:
+            r0 = rows[0]
+            ok = bool(r0.get("ok", False))
+            msg = str(r0.get("msg", ""))
+            return ok, msg or ("ok" if ok else "failed")
+        # Some PostgREST setups return {} — treat as ok
+        return True, "ok"
+    except Exception as e:
+        # If function missing (42883) or not exposed, re-raise to use fallback
+        raise e
+
+def fallback_direct_insert(email: str, v_id: int, name: str, qty: int,
+                           category: Optional[str], unit: Optional[str],
+                           barcode: Optional[str], ts_iso: str, ingest_id: str) -> None:
+    """Write into visit_items_p if present, else visit_items (keeps app working)."""
+    payload = {
+        "visit_id": v_id,
+        "timestamp": ts_iso,
+        "volunteer": email,
+        "item_name": name,
+        "category": category,
+        "unit": unit,
+        "qty": qty,
+        "barcode": barcode,
+        "weather_type": None,
+        "temp_c": None,
+        "ingest_id": ingest_id
+    }
+    try:
+        sb.table("visit_items_p").insert(payload).execute()
+    except Exception:
+        # legacy table fallback
+        payload.pop("ingest_id", None)
+        sb.table("visit_items").insert(payload).execute()
+
+st.markdown('<div class="cc-btn-primary">', unsafe_allow_html=True)
+save_disabled = not st.session_state.get("active_visit")
+if st.button("✅ Save Item to Visit", disabled=save_disabled):
+    v = st.session_state.get("active_visit")
+    if not v:
+        st.warning("Start a visit first, then save items.")
+    else:
+        name_clean = clean_text(item_name, 120)
+        if not name_clean:
+            st.warning("Item name is required.")
+        else:
+            ts_iso = datetime.utcnow().isoformat()
+            ingest_id = deterministic_ingest_id(int(v["id"]), user_email, name_clean, int(quantity), ts_iso)
+            try:
+                ok, msg = try_rpc_ingest(
+                    email=user_email, v_id=int(v["id"]), name=name_clean, qty=int(quantity),
+                    category=clean_text(category, 80), unit=clean_text(unit, 40),
+                    barcode=clean_text(barcode, 64), ts_iso=ts_iso, ingest_id=ingest_id
+                )
+                if ok:
+                    st.success("Item logged ✅")
+                else:
+                    st.warning(f"Ingest said: {msg}. (Will try direct insert.)")
+                    fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                           clean_text(category,80), clean_text(unit,40),
+                                           clean_text(barcode,64), ts_iso, ingest_id)
+                    st.success("Item logged ✅ (fallback)")
+            except Exception as e:
+                # RPC missing or failed → direct insert
+                try:
+                    fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                           clean_text(category,80), clean_text(unit,40),
+                                           clean_text(barcode,64), ts_iso, ingest_id)
+                    st.success("Item logged ✅ (fallback)")
+                except Exception as e2:
+                    st.error(f"Ingest failed: {e2}")
+            st.session_state["last_activity_at"] = local_now()
+            st.session_state["scanned_item_name"] = name_clean
+st.markdown('</div>', unsafe_allow_html=True)
+
+# ------------------------ Visit items view + delete ------------------------
+def load_items_for_visit(visit_id: int) -> list[dict]:
+    # Prefer partitioned table
+    try:
+        return sb.table("visit_items_p").select("*").eq("visit_id", visit_id) \
+            .order("timestamp", desc=True).limit(500).execute().data or []
+    except Exception:
+        try:
+            return sb.table("visit_items").select("*").eq("visit_id", visit_id) \
+                .order("timestamp", desc=True).limit(500).execute().data or []
+        except Exception:
+            return []
+
+def delete_item(table: str, item_id: int):
+    try:
+        sb.table(table).delete().eq("id", item_id).execute()
+    except Exception as e:
+        raise e
+
+if st.session_state.get("active_visit"):
+    st.subheader("🧾 Items in this visit")
+    rows = load_items_for_visit(int(st.session_state["active_visit"]["id"]))
+    if rows:
+        df = pd.DataFrame(rows)
+        st.dataframe(df, use_container_width=True)
+        with st.expander("🗑️ Delete an item (if mis-logged)"):
+            ids = [r["id"] for r in rows if "id" in r]
+            choice = st.selectbox("Choose item id", ids) if ids else None
+            st.markdown('<div class="cc-danger">', unsafe_allow_html=True)
+            if st.button("Delete selected", disabled=not bool(ids)):
+                if choice is None:
+                    st.warning("Pick an id.")
+                else:
+                    # try both tables safely
+                    try:
+                        delete_item("visit_items_p", int(choice))
+                    except Exception:
+                        delete_item("visit_items", int(choice))
+                    st.success("Deleted.")
+            st.markdown('</div>', unsafe_allow_html=True)
+    else:
+        st.caption("No items logged for this visit yet.")
+
+# ------------------------ Analytics (light) ------------------------
+st.subheader("📈 Today")
+try:
+    daily = sb.table("v_daily_activity").select("*").execute().data
+    today_str = local_now().strftime("%Y-%m-%d")
+    today = next((r for r in daily if str(r.get("day",""))[:10]==today_str), None)
+    visits = int(today["visits"]) if today and "visits" in today else 0
+    items  = int(today["items"]) if today and "items" in today else 0
+    st.markdown(f"**Visits:** {visits} · **Items:** {items}")
+except Exception:
+    st.caption("Analytics view unavailable yet.")
+
+# ------------------------ Gentle reminder ------------------------
+st.markdown(
+    """<div class="cc-hint">
+    💡 When you’re done, please <b>End Visit</b> and <b>Sign out</b>.<br>
+    We’ll auto-sign you out after inactivity or at 8pm local time. 💜
+    </div>""",
+    unsafe_allow_html=True
+)

backups/pre_modern_deployment_20250923_202615/streamlit_app_modern.py

@@ -0,0 +1,891 @@
+# --- Care Count (Volunteers → Visits → Items) ---
+# Modern UI/UX with industry-standard design patterns
+# Enhanced version with improved user experience
+
+from __future__ import annotations
+
+import os, io, time, base64, re, uuid, json
+from datetime import datetime, timedelta
+from typing import Optional
+import logging
+
+import pytz
+import requests
+import pandas as pd
+import streamlit as st
+from PIL import Image, ImageOps, ImageEnhance
+from supabase import create_client, Client
+
+# Import our modern UI components
+from ui_improvements import ModernUIComponents, apply_modern_ui, create_modern_layout
+
+# ------------------------ Enhanced Logging ------------------------
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('care_count.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# ------------------------ App config ------------------------
+os.environ.setdefault("HOME", "/tmp")
+os.environ["STREAMLIT_BROWSER_GATHER_USAGE_STATS"] = "false"
+
+TZ             = os.getenv("APP_TZ", "America/Toronto")
+CUTOFF_HOUR    = int(os.getenv("CUTOFF_HOUR", "20"))   # 8pm local
+INACTIVITY_MIN = int(os.getenv("INACTIVITY_MIN", "30"))
+
+def local_now() -> datetime:
+    return datetime.now(pytz.timezone(TZ))
+
+# Enhanced page config with modern settings
+st.set_page_config(
+    page_title="Care Count - Volunteer Management",
+    page_icon="💜",
+    layout="wide",
+    initial_sidebar_state="expanded",
+    menu_items={
+        'Get Help': 'https://github.com/your-repo/care-count',
+        'Report a bug': "https://github.com/your-repo/care-count/issues",
+        'About': "# Care Count\nVolunteer management system for community impact tracking"
+    }
+)
+
+# Apply modern UI styling
+apply_modern_ui()
+
+# ------------------------ Enhanced Secrets Management ------------------------
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except Exception:
+    pass
+
+try:
+    _SECRETS = getattr(st, "secrets", {})
+except Exception:
+    _SECRETS = {}
+
+def _is_useful(val: Optional[str]) -> bool:
+    return val is not None and str(val).strip() != ""
+
+def get_secret(name: str, default: Optional[str] = None) -> Optional[str]:
+    """Enhanced secret management with logging"""
+    v = os.getenv(name)
+    if _is_useful(v):
+        logger.info(f"Secret {name} loaded from environment")
+        return v
+
+    try:
+        if hasattr(_SECRETS, "get"):
+            v = _SECRETS.get(name, default)
+            if _is_useful(v):
+                logger.info(f"Secret {name} loaded from Streamlit secrets")
+                return v
+    except Exception as e:
+        logger.warning(f"Failed to load secret {name} from Streamlit secrets: {e}")
+
+    return default
+
+def require_secret(name: str) -> str:
+    """Enhanced secret requirement with better error handling"""
+    v = get_secret(name, None)
+    if not _is_useful(v):
+        st.error(
+            f"🔐 **Configuration Error**\n\n"
+            f"Missing required configuration: `{name}`\n\n"
+            f"Please ensure this is set in your environment variables or `.streamlit/secrets.toml` file.\n\n"
+            f"For help, check the [documentation](https://github.com/your-repo/care-count#configuration)."
+        )
+        st.stop()
+    return str(v)
+
+# Required Supabase credentials
+SUPABASE_URL = require_secret("SUPABASE_URL")
+SUPABASE_KEY = require_secret("SUPABASE_KEY")
+
+# Initialize Supabase client with error handling
+try:
+    sb: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+    logger.info("Supabase client initialized successfully")
+except Exception as e:
+    st.error(f"Failed to connect to Supabase: {e}")
+    logger.error(f"Supabase connection failed: {e}")
+    st.stop()
+
+# Optional provider/config
+PROVIDER         = (get_secret("PROVIDER", "nebius") or "nebius").strip().lower()
+GEMMA_MODEL      = (get_secret("GEMMA_MODEL", "google/gemma-3-27b-it") or "google/gemma-3-27b-it").strip()
+NEBIUS_API_KEY   = get_secret("NEBIUS_API_KEY")
+NEBIUS_BASE_URL  = get_secret("NEBIUS_BASE_URL", "https://api.nebius.ai/v1")
+FEATH_API_KEY    = get_secret("FEATHERLESS_API_KEY")
+FEATH_BASE_URL   = get_secret("FEATHERLESS_BASE_URL", "https://api.featherless.ai/v1")
+
+# ------------------------ Enhanced Event Logging ------------------------
+def log_event(action: str, actor: Optional[str], details: dict, level: str = "info"):
+    """Enhanced event logging with multiple levels"""
+    log_data = {
+        "timestamp": datetime.utcnow().isoformat(),
+        "action": action,
+        "actor_email": actor,
+        "details": details,
+        "level": level
+    }
+    
+    # Log to file
+    if level == "error":
+        logger.error(f"Event: {action} by {actor} - {details}")
+    elif level == "warning":
+        logger.warning(f"Event: {action} by {actor} - {details}")
+    else:
+        logger.info(f"Event: {action} by {actor} - {details}")
+    
+    # Log to database
+    try:
+        sb.table("events").insert(log_data).execute()
+    except Exception as e:
+        logger.error(f"Failed to log event to database: {e}")
+
+# ------------------------ Modern Authentication UI ------------------------
+def auth_block() -> tuple[bool, Optional[str]]:
+    """Enhanced authentication with modern UI"""
+    if "auth_email" not in st.session_state:
+        st.session_state["auth_email"] = None
+    if "user_email" in st.session_state:
+        return True, st.session_state["user_email"]
+
+    # Modern hero section for login
+    st.markdown(ModernUIComponents.create_hero_section(
+        "Care Count",
+        "Thanks for showing up for the community today. Snap items, keep visits tidy, and help us understand the impact of your time."
+    ))
+
+    # Modern login form
+    with st.container():
+        st.markdown('<div class="modern-card">', unsafe_allow_html=True)
+        st.subheader("🔐 Sign In")
+        st.markdown("Enter your email to receive a secure login code.")
+        
+        with st.form("otp_request", clear_on_submit=False):
+            email = st.text_input(
+                "Email Address", 
+                value=st.session_state.get("auth_email") or "", 
+                placeholder="your.email@example.com",
+                help="We'll send you a secure 6-digit code"
+            )
+            
+            col1, col2, col3 = st.columns([1, 2, 1])
+            with col2:
+                send = st.form_submit_button("📧 Send Login Code", use_container_width=True)
+            
+            if send:
+                if not email or "@" not in email:
+                    st.error("Please enter a valid email address.")
+                else:
+                    try:
+                        with st.spinner("Sending login code..."):
+                            sb.auth.sign_in_with_otp({"email": email, "shouldCreateUser": True})
+                            st.session_state["auth_email"] = email
+                            st.success("✅ Login code sent! Check your email.")
+                            log_event("otp_requested", email, {"method": "email"})
+                    except Exception as e:
+                        st.error(f"❌ Could not send code: {e}")
+                        log_event("otp_failed", email, {"error": str(e)}, "error")
+
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    # OTP verification form
+    if st.session_state.get("auth_email"):
+        with st.container():
+            st.markdown('<div class="modern-card">', unsafe_allow_html=True)
+            st.subheader("🔢 Verify Code")
+            st.markdown(f"Enter the 6-digit code sent to **{st.session_state['auth_email']}**")
+            
+            with st.form("otp_verify", clear_on_submit=True):
+                code = st.text_input(
+                    "Verification Code", 
+                    max_chars=6,
+                    placeholder="123456",
+                    help="Enter the 6-digit code from your email"
+                )
+                
+                col1, col2, col3 = st.columns([1, 2, 1])
+                with col2:
+                    ok = st.form_submit_button("✅ Verify & Start Shift", use_container_width=True)
+                
+                if ok:
+                    if len(code) != 6 or not code.isdigit():
+                        st.error("Please enter a valid 6-digit code.")
+                    else:
+                        try:
+                            with st.spinner("Verifying code..."):
+                                res = sb.auth.verify_otp({"email": st.session_state["auth_email"], "token": code, "type": "email"})
+                                if res and res.user:
+                                    email = st.session_state["auth_email"]
+                                    
+                                    # Enhanced volunteer upsert
+                                    volunteer_data = {
+                                        "email": email,
+                                        "last_login_at": datetime.utcnow().isoformat(),
+                                        "shift_started_at": datetime.utcnow().isoformat(),
+                                        "shift_ended_at": None,
+                                        "login_count": 1  # Track login frequency
+                                    }
+                                    
+                                    sb.table("volunteers").upsert(volunteer_data, on_conflict="email").execute()
+                                    
+                                    st.session_state["user_email"] = email
+                                    st.session_state["shift_started"] = True
+                                    st.session_state["last_activity_at"] = local_now()
+                                    
+                                    log_event("login_success", email, {"method": "otp"})
+                                    st.success("🎉 Welcome back! Your shift has started.")
+                                    st.balloons()
+                                    return True, email
+                        except Exception as e:
+                            st.error(f"❌ Verification failed: {e}")
+                            log_event("otp_verification_failed", st.session_state["auth_email"], {"error": str(e)}, "error")
+            
+            st.markdown('</div>', unsafe_allow_html=True)
+    
+    return False, None
+
+def end_shift(email: str, reason: str):
+    """Enhanced shift ending with better logging"""
+    try:
+        end_time = datetime.utcnow().isoformat()
+        sb.table("volunteers").update({"shift_ended_at": end_time}).eq("email", email).execute()
+        log_event("shift_end", email, {"reason": reason, "end_time": end_time})
+    except Exception as e:
+        logger.error(f"Failed to end shift for {email}: {e}")
+
+def guard_cutoff_and_idle(email: str):
+    """Enhanced session management with better UX"""
+    now = local_now()
+    last = st.session_state.get("last_activity_at")
+    
+    if last and (now - last).total_seconds() > INACTIVITY_MIN * 60:
+        end_shift(email, "inactivity")
+        st.session_state.clear()
+        st.warning("⏰ You were logged out due to inactivity. Thank you for volunteering today!")
+        st.stop()
+    
+    st.session_state["last_activity_at"] = now
+
+    cutoff = now.replace(hour=CUTOFF_HOUR, minute=0, second=0, microsecond=0)
+    if now >= cutoff:
+        end_shift(email, "cutoff_8pm")
+        st.session_state.clear()
+        st.info("🌅 We close the day at 8pm. Your shift has been ended. Thank you so much!")
+        st.stop()
+
+# ------------------------ Main App Flow ------------------------
+def main():
+    """Main application flow with modern UI"""
+    
+    # Authentication
+    signed_in, user_email = auth_block()
+    if not signed_in:
+        st.stop()
+    
+    guard_cutoff_and_idle(user_email)
+
+    # Modern welcome section
+    st.markdown(ModernUIComponents.create_hero_section(
+        "Care Count Dashboard",
+        "Manage visits, track items, and make a difference in your community.",
+        user_email
+    ))
+
+    # Enhanced status cards
+    vrow = fetch_volunteer_row(user_email) or {}
+    shift_started_at = vrow.get("shift_started_at")
+    lifetime_hours = vrow.get("total_hours", 0)
+    
+    mins_active = 0
+    try:
+        if shift_started_at:
+            t0 = datetime.fromisoformat(str(shift_started_at).replace("Z","+00:00"))
+            mins_active = max(0, int((datetime.utcnow() - t0).total_seconds() // 60))
+    except Exception:
+        pass
+
+    status_data = {
+        "shift_active": f"{mins_active} min",
+        "items_today": items_today(user_email),
+        "lifetime_hours": f"{round(float(lifetime_hours), 1)} hrs" if isinstance(lifetime_hours, (int, float)) else "0.0 hrs"
+    }
+    
+    st.markdown(ModernUIComponents.create_status_cards(status_data), unsafe_allow_html=True)
+
+    # Modern sign-out button
+    col1, col2, col3 = st.columns([1, 1, 1])
+    with col2:
+        if st.button("🔒 Sign Out", use_container_width=True, type="secondary"):
+            end_shift(user_email, "manual")
+            st.session_state.clear()
+            st.success("✅ Signed out successfully. See you next time!")
+            st.rerun()
+
+    # Enhanced visit management section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "🪪 Visit Management",
+        "Start and manage student visits with unique tracking codes"
+    ), unsafe_allow_html=True)
+    
+    active_visit = st.session_state.get("active_visit")
+    
+    col1, col2, col3 = st.columns([1, 1, 1])
+    
+    with col1:
+        if not active_visit and st.button("🚀 Start New Visit", use_container_width=True, type="primary"):
+            try:
+                with st.spinner("Creating visit..."):
+                    payload = {
+                        "visit_code": fallback_visit_code(),
+                        "started_at": datetime.utcnow().isoformat(),
+                        "ended_at": None,
+                        "created_by": user_email
+                    }
+                    v = sb.table("visits").insert(payload).execute().data[0]
+                    if not v.get("visit_code"):
+                        v["visit_code"] = payload["visit_code"]
+                    st.session_state["active_visit"] = v
+                    st.success(f"✅ Visit #{v['id']} started")
+                    st.info(f"**Visit Code:** `{v['visit_code']}`")
+                    log_event("visit_start", user_email, {"visit_id": v["id"], "visit_code": v["visit_code"]})
+                    st.rerun()
+            except Exception as e:
+                st.error(f"❌ Could not start visit: {e}")
+                log_event("visit_start_failed", user_email, {"error": str(e)}, "error")
+
+    with col2:
+        if active_visit and st.button("🏁 End Visit", use_container_width=True, type="secondary"):
+            try:
+                with st.spinner("Ending visit..."):
+                    sb.table("visits").update({"ended_at": datetime.utcnow().isoformat()}) \
+                      .eq("id", active_visit["id"]).execute()
+                    st.success("✅ Visit completed successfully")
+                    log_event("visit_end", user_email, {"visit_id": active_visit["id"]})
+                    st.session_state.pop("active_visit", None)
+                    st.rerun()
+            except Exception as e:
+                st.error(f"❌ Could not end visit: {e}")
+                log_event("visit_end_failed", user_email, {"error": str(e)}, "error")
+
+    with col3:
+        if st.session_state.get("active_visit"):
+            v = st.session_state["active_visit"]
+            st.info(f"**Active Visit:** #{v['id']}\n**Code:** {v.get('visit_code','')}")
+        else:
+            st.info("No active visit")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced item identification section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📸 Item Identification",
+        "Use AI-powered image recognition to identify items quickly and accurately"
+    ), unsafe_allow_html=True)
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("📷 Camera Capture")
+        cam = st.camera_input("Take a photo of the item", help="Position the item clearly in the frame")
+    
+    with col2:
+        st.subheader("📁 File Upload")
+        up = st.file_uploader(
+            "Upload an image", 
+            type=["png","jpg","jpeg"],
+            help="Supported formats: PNG, JPG, JPEG"
+        )
+
+    img_file = cam or up
+    if img_file:
+        try:
+            img = Image.open(img_file).convert("RGB")
+            st.image(img, use_container_width=True, caption="Captured Image")
+            
+            if st.button("🔍 Identify Item with AI", use_container_width=True, type="primary"):
+                with st.spinner("Analyzing image with AI..."):
+                    t0 = time.time()
+                    try:
+                        pre = preprocess_for_label(img)
+                        raw = gemma_item_name(_to_png_bytes(pre))
+                        processing_time = time.time() - t0
+                        
+                        norm = normalize_item_name(raw)
+                        
+                        if raw:
+                            st.success(f"🤖 **AI Detection:** {raw}")
+                        st.info(f"✨ **Normalized:** {norm or '(unknown)'} · ⏱️ {processing_time:.2f}s")
+                        
+                        st.session_state["scanned_item_name"] = norm or raw or ""
+                        st.session_state["last_activity_at"] = local_now()
+                        
+                        log_event("item_identified", user_email, {
+                            "raw_name": raw,
+                            "normalized_name": norm,
+                            "processing_time": processing_time
+                        })
+                        
+                    except Exception as e:
+                        st.error(f"❌ AI identification failed: {e}")
+                        log_event("ai_identification_failed", user_email, {"error": str(e)}, "error")
+        except Exception as e:
+            st.error(f"❌ Failed to process image: {e}")
+            log_event("image_processing_failed", user_email, {"error": str(e)}, "error")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced item logging section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📬 Item Logging",
+        "Log items to the current visit with detailed information"
+    ), unsafe_allow_html=True)
+    
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        item_name = st.text_input(
+            "Item Name", 
+            value=st.session_state.get("scanned_item_name",""),
+            placeholder="Enter item name or use AI detection above",
+            help="Required field - item name for tracking"
+        )
+    
+    with col2:
+        quantity = st.number_input(
+            "Quantity", 
+            min_value=1, 
+            max_value=9999, 
+            step=1, 
+            value=1,
+            help="Number of items"
+        )
+    
+    col3, col4 = st.columns(2)
+    
+    with col3:
+        category = st.text_input(
+            "Category (optional)", 
+            placeholder="e.g., Food, Hygiene, Clothing",
+            help="Item category for better organization"
+        )
+    
+    with col4:
+        unit = st.text_input(
+            "Unit (optional)", 
+            placeholder="e.g., 500 mL, 1 L, 250 g",
+            help="Unit of measurement"
+        )
+    
+    barcode = st.text_input(
+        "Barcode (optional)", 
+        placeholder="Scan or enter barcode",
+        help="Product barcode for inventory tracking"
+    )
+
+    save_disabled = not st.session_state.get("active_visit")
+    if st.button("✅ Save Item to Visit", disabled=save_disabled, use_container_width=True, type="primary"):
+        v = st.session_state.get("active_visit")
+        if not v:
+            st.warning("⚠️ Please start a visit first before logging items.")
+        else:
+            name_clean = clean_text(item_name, 120)
+            if not name_clean:
+                st.warning("⚠️ Item name is required.")
+            else:
+                with st.spinner("Saving item..."):
+                    ts_iso = datetime.utcnow().isoformat()
+                    ingest_id = deterministic_ingest_id(int(v["id"]), user_email, name_clean, int(quantity), ts_iso)
+                    
+                    try:
+                        ok, msg = try_rpc_ingest(
+                            email=user_email, v_id=int(v["id"]), name=name_clean, qty=int(quantity),
+                            category=clean_text(category, 80), unit=clean_text(unit, 40),
+                            barcode=clean_text(barcode, 64), ts_iso=ts_iso, ingest_id=ingest_id
+                        )
+                        
+                        if ok:
+                            st.success("✅ Item logged successfully!")
+                            log_event("item_logged", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                        else:
+                            st.warning(f"⚠️ {msg}. Trying fallback method...")
+                            fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                                   clean_text(category,80), clean_text(unit,40),
+                                                   clean_text(barcode,64), ts_iso, ingest_id)
+                            st.success("✅ Item logged successfully (fallback method)!")
+                            log_event("item_logged_fallback", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                    except Exception as e:
+                        try:
+                            fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                                   clean_text(category,80), clean_text(unit,40),
+                                                   clean_text(barcode,64), ts_iso, ingest_id)
+                            st.success("✅ Item logged successfully (fallback method)!")
+                            log_event("item_logged_fallback", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                        except Exception as e2:
+                            st.error(f"❌ Failed to log item: {e2}")
+                            log_event("item_log_failed", user_email, {"error": str(e2)}, "error")
+                    
+                    st.session_state["last_activity_at"] = local_now()
+                    st.session_state["scanned_item_name"] = name_clean
+                    st.rerun()
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced visit items view
+    if st.session_state.get("active_visit"):
+        st.markdown(ModernUIComponents.create_modern_form_section(
+            "🧾 Current Visit Items",
+            "Review and manage items in the current visit"
+        ), unsafe_allow_html=True)
+        
+        rows = load_items_for_visit(int(st.session_state["active_visit"]["id"]))
+        if rows:
+            df = pd.DataFrame(rows)
+            
+            # Enhanced dataframe display
+            st.dataframe(
+                df, 
+                use_container_width=True,
+                hide_index=True,
+                column_config={
+                    "timestamp": st.column_config.DatetimeColumn("Time", format="MM/DD/YY HH:mm"),
+                    "item_name": st.column_config.TextColumn("Item Name", width="medium"),
+                    "qty": st.column_config.NumberColumn("Quantity", width="small"),
+                    "category": st.column_config.TextColumn("Category", width="small"),
+                    "unit": st.column_config.TextColumn("Unit", width="small")
+                }
+            )
+            
+            # Enhanced delete functionality
+            with st.expander("🗑️ Delete Item (if mis-logged)"):
+                if rows:
+                    item_options = {f"{r['item_name']} (Qty: {r['qty']})": r["id"] for r in rows if "id" in r}
+                    selected_item = st.selectbox("Select item to delete", list(item_options.keys()))
+                    
+                    if st.button("🗑️ Delete Selected Item", type="secondary"):
+                        item_id = item_options[selected_item]
+                        try:
+                            # Try both tables safely
+                            try:
+                                delete_item("visit_items_p", int(item_id))
+                            except Exception:
+                                delete_item("visit_items", int(item_id))
+                            
+                            st.success("✅ Item deleted successfully")
+                            log_event("item_deleted", user_email, {"item_id": item_id})
+                            st.rerun()
+                        except Exception as e:
+                            st.error(f"❌ Failed to delete item: {e}")
+                            log_event("item_delete_failed", user_email, {"error": str(e)}, "error")
+                else:
+                    st.info("No items to delete")
+        else:
+            st.info("📝 No items logged for this visit yet.")
+        
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced analytics section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📈 Today's Analytics",
+        "Real-time insights into today's volunteer activity"
+    ), unsafe_allow_html=True)
+    
+    try:
+        daily = sb.table("v_daily_activity").select("*").execute().data
+        today_str = local_now().strftime("%Y-%m-%d")
+        today = next((r for r in daily if str(r.get("day",""))[:10]==today_str), None)
+        
+        if today:
+            visits = int(today.get("visits", 0))
+            items = int(today.get("items", 0))
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                st.metric("Total Visits Today", visits, delta=None)
+            with col2:
+                st.metric("Total Items Processed", items, delta=None)
+            
+            # Progress indicator
+            if visits > 0:
+                st.markdown(ModernUIComponents.create_progress_indicator(
+                    items, visits * 10, "Items per Visit Target"
+                ), unsafe_allow_html=True)
+        else:
+            st.info("📊 Analytics data will appear here as activity increases.")
+            
+    except Exception as e:
+        st.info("📊 Analytics view will be available once the database view is set up.")
+        logger.warning(f"Analytics view not available: {e}")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced footer with helpful information
+    st.markdown("""
+    <div class="modern-card" style="margin-top: var(--space-8); text-align: center;">
+        <h4>💡 Quick Tips</h4>
+        <p style="color: var(--gray-400); margin: 0;">
+            When you're done, please <strong>End Visit</strong> and <strong>Sign out</strong>.<br>
+            We'll auto-sign you out after inactivity or at 8pm local time. 💜
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+
+# ------------------------ Helper Functions (Enhanced) ------------------------
+def fetch_volunteer_row(email: str) -> dict | None:
+    """Enhanced volunteer data fetching with error handling"""
+    try:
+        return sb.table("volunteers").select("*").eq("email", email).single().execute().data
+    except Exception as e:
+        logger.warning(f"Failed to fetch volunteer data for {email}: {e}")
+        return None
+
+def items_today(email: str) -> int:
+    """Enhanced item counting with better error handling"""
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        # Try partitioned table first
+        data = sb.table("visit_items_p").select("id,timestamp,volunteer") \
+                .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                .eq("volunteer", email).execute().data
+        return len(data or [])
+    except Exception:
+        try:
+            data = sb.table("visit_items").select("id,timestamp,volunteer") \
+                    .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                    .eq("volunteer", email).execute().data
+            return len(data or [])
+        except Exception as e:
+            logger.warning(f"Failed to count items for {email}: {e}")
+            return 0
+
+def fallback_visit_code() -> str:
+    """Enhanced visit code generation with better uniqueness"""
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        todays = sb.table("visits").select("id,started_at").gte("started_at", f"{day} 00:00:00") \
+                 .lte("started_at", f"{day} 23:59:59").execute().data or []
+        seq = len(todays) + 1
+    except Exception:
+        seq = int(time.time()) % 1000
+    return f"V-{seq}-{local_now().strftime('%Y%m%d')}-{str(uuid.uuid4())[:6]}"
+
+def _to_png_bytes(img: Image.Image) -> bytes:
+    """Convert image to PNG bytes"""
+    b = io.BytesIO()
+    img.save(b, format="PNG")
+    return b.getvalue()
+
+def preprocess_for_label(img: Image.Image) -> Image.Image:
+    """Enhanced image preprocessing for better AI recognition"""
+    img = img.convert("RGB")
+    w, h = img.size
+    scale = 1024 / max(w, h) if max(w, h) > 1024 else 1.0
+    if scale < 1.0: 
+        img = img.resize((int(w * scale), int(h * scale)))
+    img = ImageOps.autocontrast(img, cutoff=2)
+    img = ImageEnhance.Brightness(img).enhance(1.06)
+    img = ImageEnhance.Contrast(img).enhance(1.05)
+    img = ImageEnhance.Sharpness(img).enhance(1.15)
+    return img
+
+def gemma_item_name(img_bytes: bytes) -> str:
+    """Enhanced AI item identification with better error handling"""
+    try:
+        if PROVIDER == "nebius":
+            if not NEBIUS_API_KEY: 
+                raise RuntimeError("NEBIUS_API_KEY missing")
+            return _openai_style_chat(NEBIUS_BASE_URL, NEBIUS_API_KEY, GEMMA_MODEL, img_bytes)
+        elif PROVIDER == "featherless":
+            if not FEATH_API_KEY: 
+                raise RuntimeError("FEATHERLESS_API_KEY missing")
+            return _openai_style_chat(FEATH_BASE_URL, FEATH_API_KEY, GEMMA_MODEL, img_bytes)
+        else:
+            raise RuntimeError(f"Unknown PROVIDER: {PROVIDER}")
+    except Exception as e:
+        logger.error(f"AI identification failed: {e}")
+        raise
+
+def _openai_style_chat(base_url: str, api_key: str, model_id: str, img_bytes: bytes) -> str:
+    """Enhanced API communication with better error handling"""
+    b64 = base64.b64encode(img_bytes).decode("utf-8")
+    url = f"{base_url.rstrip('/')}/chat/completions"
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    payload = {
+        "model": model_id,
+        "temperature": 0,
+        "messages": [
+            {"role": "system", "content": "You label item being held in the image for a food bank. Return ONLY the item name."},
+            {"role": "user", "content": [
+                {"type": "text", "text": "What is the name of the item in the picture? Return only the item name."},
+                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}}
+            ]}
+        ]
+    }
+    
+    try:
+        r = requests.post(url, json=payload, headers=headers, timeout=90)
+        if r.status_code != 200:
+            raise RuntimeError(f"LLM HTTP {r.status_code}: {r.text[:200]}")
+        data = r.json()
+        return (data["choices"][0]["message"]["content"] or "").strip()
+    except requests.exceptions.Timeout:
+        raise RuntimeError("AI service timeout - please try again")
+    except requests.exceptions.RequestException as e:
+        raise RuntimeError(f"AI service error: {e}")
+
+def normalize_item_name(s: str) -> str:
+    """Enhanced item name normalization"""
+    s = (s or "").strip()
+    if not s: 
+        return ""
+    
+    # Enhanced brand and type recognition
+    BRANDS = {
+        "whiskas","tetley","kellogg's","kelloggs","campbell's","campbells","heinz",
+        "nestle","kraft","general mills","cheerios","oreo","oreos","pringles","lays","doritos",
+        "ice river","green bottle","great value","wheat thins","vegetable thins","raid"
+    }
+    GENERIC_TYPES = {
+        "water","toothpaste","deodorant","antiperspirant","soap","shampoo","conditioner",
+        "lotion","tea","coffee","cereal","pasta","rice","beans","sauce","salsa","cleaner",
+        "peanut butter","jam","jelly","tuna","chicken","beef","flour","sugar","salt","oil",
+        "crackers","cookies","soup","insect killer","spray"
+    }
+    
+    low = re.sub(r"[®™]", "", s.lower())
+    for b in BRANDS: 
+        low = low.replace(b, "")
+    
+    chosen = None
+    for t in GENERIC_TYPES:
+        if t in low: 
+            chosen = t
+            break
+    
+    cleaned = " ".join(low.split())
+    return (chosen or cleaned.title())[:120]
+
+def clean_text(v: Optional[str], maxlen: int = 120) -> Optional[str]:
+    """Enhanced text cleaning"""
+    if not v: 
+        return None
+    v = re.sub(r"\s+", " ", v).strip()
+    return v[:maxlen] if v else None
+
+def deterministic_ingest_id(v_id: int, email: str, name: str, qty: int, ts_iso: str) -> str:
+    """Enhanced ID generation for data integrity"""
+    key = f"visit_items::{v_id}::{email}::{name}::{qty}::{ts_iso}"
+    return str(uuid.uuid5(uuid.NAMESPACE_URL, key))
+
+def try_rpc_ingest(email: str, v_id: int, name: str, qty: int,
+                   category: Optional[str], unit: Optional[str],
+                   barcode: Optional[str], ts_iso: str, ingest_id: str) -> tuple[bool,str]:
+    """Enhanced RPC ingestion with better error handling"""
+    try:
+        res = sb.rpc("safe_ingest_visit_item", {
+            "p_email": email,
+            "p_visit_id": v_id,
+            "p_item_name": name,
+            "p_qty": qty,
+            "p_category": category,
+            "p_unit": unit,
+            "p_barcode": barcode,
+            "p_ts": ts_iso,
+            "p_ingest_id": ingest_id
+        }).execute()
+        
+        rows = res.data if isinstance(res.data, list) else []
+        if rows:
+            r0 = rows[0]
+            ok = bool(r0.get("ok", False))
+            msg = str(r0.get("msg", ""))
+            return ok, msg or ("ok" if ok else "failed")
+        return True, "ok"
+    except Exception as e:
+        logger.warning(f"RPC ingest failed, using fallback: {e}")
+        raise e
+
+def fallback_direct_insert(email: str, v_id: int, name: str, qty: int,
+                           category: Optional[str], unit: Optional[str],
+                           barcode: Optional[str], ts_iso: str, ingest_id: str) -> None:
+    """Enhanced fallback insertion with better error handling"""
+    payload = {
+        "visit_id": v_id,
+        "timestamp": ts_iso,
+        "volunteer": email,
+        "item_name": name,
+        "category": category,
+        "unit": unit,
+        "qty": qty,
+        "barcode": barcode,
+        "weather_type": None,
+        "temp_c": None,
+        "ingest_id": ingest_id
+    }
+    
+    try:
+        sb.table("visit_items_p").insert(payload).execute()
+    except Exception:
+        # Legacy table fallback
+        payload.pop("ingest_id", None)
+        sb.table("visit_items").insert(payload).execute()
+
+def load_items_for_visit(visit_id: int) -> list[dict]:
+    """Enhanced item loading with better error handling"""
+    try:
+        return sb.table("visit_items_p").select("*").eq("visit_id", visit_id) \
+            .order("timestamp", desc=True).limit(500).execute().data or []
+    except Exception:
+        try:
+            return sb.table("visit_items").select("*").eq("visit_id", visit_id) \
+                .order("timestamp", desc=True).limit(500).execute().data or []
+        except Exception as e:
+            logger.warning(f"Failed to load items for visit {visit_id}: {e}")
+            return []
+
+def delete_item(table: str, item_id: int):
+    """Enhanced item deletion with better error handling"""
+    try:
+        sb.table(table).delete().eq("id", item_id).execute()
+    except Exception as e:
+        logger.error(f"Failed to delete item {item_id} from {table}: {e}")
+        raise e
+
+# ------------------------ App Configuration Display ------------------------
+st.sidebar.markdown("### ⚙️ Configuration")
+st.sidebar.info(f"""
+**Provider:** `{PROVIDER}`  
+**Model:** `{GEMMA_MODEL}`  
+**Timezone:** `{TZ}`  
+**Cutoff:** {CUTOFF_HOUR}:00 PM  
+**Inactivity:** {INACTIVITY_MIN} min
+""")
+
+# ------------------------ Main App Execution ------------------------
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        logger.error(f"Application error: {e}")
+        st.error(f"❌ Application error: {e}")
+        st.info("Please refresh the page or contact support if the issue persists.")

backups/pre_modern_deployment_20250923_202615/test_app.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""
+Care Count App Testing Framework
+Tests UI/UX changes and backend functionality
+"""
+
+import sys
+import os
+import time
+import logging
+from datetime import datetime
+from typing import Dict, Any, List
+import subprocess
+import requests
+from pathlib import Path
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('test_results.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+class CareCountTester:
+    def __init__(self):
+        self.test_results = []
+        self.app_url = "http://localhost:8501"
+        self.backup_dir = Path("backups")
+        self.backup_dir.mkdir(exist_ok=True)
+        
+    def create_backup(self, description: str = "manual_backup"):
+        """Create a timestamped backup of current app state"""
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        backup_name = f"{description}_{timestamp}"
+        
+        # Backup main files
+        files_to_backup = [
+            "streamlit_app.py",
+            ".streamlit/secrets.toml",
+            "requirements.txt"
+        ]
+        
+        backup_path = self.backup_dir / backup_name
+        backup_path.mkdir(exist_ok=True)
+        
+        for file_path in files_to_backup:
+            if os.path.exists(file_path):
+                subprocess.run(["cp", file_path, str(backup_path / os.path.basename(file_path))])
+        
+        logger.info(f"Backup created: {backup_name}")
+        return backup_name
+    
+    def restore_backup(self, backup_name: str):
+        """Restore from a backup"""
+        backup_path = self.backup_dir / backup_name
+        
+        if not backup_path.exists():
+            logger.error(f"Backup {backup_name} not found")
+            return False
+        
+        # Restore files
+        files_to_restore = [
+            "streamlit_app.py",
+            ".streamlit/secrets.toml", 
+            "requirements.txt"
+        ]
+        
+        for file_path in files_to_restore:
+            backup_file = backup_path / os.path.basename(file_path)
+            if backup_file.exists():
+                subprocess.run(["cp", str(backup_file), file_path])
+        
+        logger.info(f"Restored from backup: {backup_name}")
+        return True
+    
+    def test_app_startup(self) -> bool:
+        """Test if the app starts without errors"""
+        try:
+            # Check if app is already running
+            response = requests.get(self.app_url, timeout=5)
+            if response.status_code == 200:
+                logger.info("✅ App is running and accessible")
+                return True
+            else:
+                logger.error(f"❌ App returned status code: {response.status_code}")
+                return False
+        except requests.exceptions.RequestException as e:
+            logger.error(f"❌ App startup test failed: {e}")
+            return False
+    
+    def test_ui_elements(self) -> Dict[str, bool]:
+        """Test key UI elements are present"""
+        results = {}
+        try:
+            response = requests.get(self.app_url, timeout=10)
+            content = response.text.lower()
+            
+            # Test for key UI elements
+            ui_tests = {
+                "title_present": "care count" in content,
+                "signin_form": "sign in" in content or "email" in content,
+                "camera_input": "camera" in content or "webcam" in content,
+                "file_upload": "upload" in content or "file" in content,
+                "visit_management": "visit" in content,
+                "item_logging": "item" in content,
+                "css_styling": "style" in content or "css" in content
+            }
+            
+            for test_name, result in ui_tests.items():
+                results[test_name] = result
+                status = "✅" if result else "❌"
+                logger.info(f"{status} {test_name}: {result}")
+            
+            return results
+            
+        except Exception as e:
+            logger.error(f"❌ UI elements test failed: {e}")
+            return {}
+    
+    def test_responsive_design(self) -> bool:
+        """Test if the app has responsive design elements"""
+        try:
+            response = requests.get(self.app_url, timeout=10)
+            content = response.text
+            
+            # Check for responsive design indicators
+            responsive_indicators = [
+                "container" in content,
+                "column" in content,
+                "responsive" in content,
+                "mobile" in content
+            ]
+            
+            responsive_score = sum(responsive_indicators) / len(responsive_indicators)
+            is_responsive = responsive_score >= 0.5
+            
+            logger.info(f"📱 Responsive design score: {responsive_score:.2f} ({'✅' if is_responsive else '❌'})")
+            return is_responsive
+            
+        except Exception as e:
+            logger.error(f"❌ Responsive design test failed: {e}")
+            return False
+    
+    def test_performance(self) -> Dict[str, float]:
+        """Test app performance metrics"""
+        try:
+            start_time = time.time()
+            response = requests.get(self.app_url, timeout=30)
+            load_time = time.time() - start_time
+            
+            results = {
+                "load_time": load_time,
+                "status_code": response.status_code,
+                "content_size": len(response.content)
+            }
+            
+            logger.info(f"⚡ Load time: {load_time:.2f}s")
+            logger.info(f"📊 Content size: {len(response.content)} bytes")
+            
+            return results
+            
+        except Exception as e:
+            logger.error(f"❌ Performance test failed: {e}")
+            return {}
+    
+    def run_all_tests(self) -> Dict[str, Any]:
+        """Run all tests and return comprehensive results"""
+        logger.info("🧪 Starting comprehensive app testing...")
+        
+        # Create backup before testing
+        backup_name = self.create_backup("pre_test_backup")
+        
+        test_results = {
+            "timestamp": datetime.now().isoformat(),
+            "backup_created": backup_name,
+            "startup_test": self.test_app_startup(),
+            "ui_elements": self.test_ui_elements(),
+            "responsive_design": self.test_responsive_design(),
+            "performance": self.test_performance()
+        }
+        
+        # Calculate overall score
+        ui_score = sum(test_results["ui_elements"].values()) / len(test_results["ui_elements"]) if test_results["ui_elements"] else 0
+        overall_score = (
+            (1 if test_results["startup_test"] else 0) +
+            ui_score +
+            (1 if test_results["responsive_design"] else 0)
+        ) / 3
+        
+        test_results["overall_score"] = overall_score
+        test_results["status"] = "PASS" if overall_score >= 0.8 else "FAIL"
+        
+        logger.info(f"🎯 Overall test score: {overall_score:.2f} ({test_results['status']})")
+        
+        return test_results
+
+def main():
+    """Main testing function"""
+    tester = CareCountTester()
+    
+    if len(sys.argv) > 1:
+        command = sys.argv[1]
+        
+        if command == "backup":
+            description = sys.argv[2] if len(sys.argv) > 2 else "manual_backup"
+            tester.create_backup(description)
+        elif command == "restore":
+            if len(sys.argv) > 2:
+                tester.restore_backup(sys.argv[2])
+            else:
+                print("Usage: python test_app.py restore <backup_name>")
+        elif command == "test":
+            results = tester.run_all_tests()
+            print(f"\n📋 Test Results Summary:")
+            print(f"Status: {results['status']}")
+            print(f"Score: {results['overall_score']:.2f}")
+            print(f"Backup: {results['backup_created']}")
+        else:
+            print("Available commands: backup, restore, test")
+    else:
+        # Run all tests by default
+        results = tester.run_all_tests()
+        print(f"\n📋 Test Results Summary:")
+        print(f"Status: {results['status']}")
+        print(f"Score: {results['overall_score']:.2f}")
+        print(f"Backup: {results['backup_created']}")
+
+if __name__ == "__main__":
+    main()

backups/pre_modern_deployment_20250923_202615/ui_improvements.py

@@ -0,0 +1,494 @@
+"""
+Care Count UI/UX Improvements Module
+Industry-standard UI components and styling
+"""
+
+import streamlit as st
+from typing import Dict, Any, Optional
+import base64
+from pathlib import Path
+
+class ModernUIComponents:
+    """Modern UI components for Care Count app"""
+    
+    @staticmethod
+    def get_modern_css() -> str:
+        """Return modern, industry-standard CSS"""
+        return """
+        <style>
+        /* Modern Design System */
+        :root {
+            /* Color Palette - Laurier Theme Enhanced */
+            --primary-purple: #6d28d9;
+            --primary-gold: #fde047;
+            --primary-dark: #0b1420;
+            --secondary-dark: #0f1a2a;
+            --accent-blue: #3b82f6;
+            --accent-green: #10b981;
+            --accent-red: #ef4444;
+            --accent-orange: #f59e0b;
+            
+            /* Neutral Colors */
+            --gray-50: #f9fafb;
+            --gray-100: #f3f4f6;
+            --gray-200: #e5e7eb;
+            --gray-300: #d1d5db;
+            --gray-400: #9ca3af;
+            --gray-500: #6b7280;
+            --gray-600: #4b5563;
+            --gray-700: #374151;
+            --gray-800: #1f2937;
+            --gray-900: #111827;
+            
+            /* Typography */
+            --font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            --font-size-xs: 0.75rem;
+            --font-size-sm: 0.875rem;
+            --font-size-base: 1rem;
+            --font-size-lg: 1.125rem;
+            --font-size-xl: 1.25rem;
+            --font-size-2xl: 1.5rem;
+            --font-size-3xl: 1.875rem;
+            
+            /* Spacing */
+            --space-1: 0.25rem;
+            --space-2: 0.5rem;
+            --space-3: 0.75rem;
+            --space-4: 1rem;
+            --space-5: 1.25rem;
+            --space-6: 1.5rem;
+            --space-8: 2rem;
+            --space-10: 2.5rem;
+            --space-12: 3rem;
+            
+            /* Border Radius */
+            --radius-sm: 0.375rem;
+            --radius-md: 0.5rem;
+            --radius-lg: 0.75rem;
+            --radius-xl: 1rem;
+            --radius-2xl: 1.5rem;
+            
+            /* Shadows */
+            --shadow-sm: 0 1px 2px 0 rgb(0 0 0 / 0.05);
+            --shadow-md: 0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1);
+            --shadow-lg: 0 10px 15px -3px rgb(0 0 0 / 0.1), 0 4px 6px -4px rgb(0 0 0 / 0.1);
+            --shadow-xl: 0 20px 25px -5px rgb(0 0 0 / 0.1), 0 8px 10px -6px rgb(0 0 0 / 0.1);
+        }
+        
+        /* Global Styles */
+        * {
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: var(--font-family);
+            background: var(--primary-dark);
+            color: var(--gray-100);
+            line-height: 1.6;
+        }
+        
+        /* Streamlit Overrides */
+        .main .block-container {
+            padding: var(--space-6) var(--space-4);
+            max-width: 1200px;
+        }
+        
+        .stApp {
+            background: var(--primary-dark);
+        }
+        
+        /* Typography */
+        h1, h2, h3, h4, h5, h6 {
+            font-weight: 700;
+            letter-spacing: -0.025em;
+            color: var(--gray-100);
+        }
+        
+        h1 {
+            font-size: var(--font-size-3xl);
+            margin-bottom: var(--space-6);
+        }
+        
+        h2 {
+            font-size: var(--font-size-2xl);
+            margin-bottom: var(--space-4);
+        }
+        
+        h3 {
+            font-size: var(--font-size-xl);
+            margin-bottom: var(--space-3);
+        }
+        
+        /* Modern Cards */
+        .modern-card {
+            background: var(--secondary-dark);
+            border: 1px solid var(--gray-700);
+            border-radius: var(--radius-xl);
+            padding: var(--space-6);
+            margin-bottom: var(--space-4);
+            box-shadow: var(--shadow-lg);
+            transition: all 0.2s ease;
+        }
+        
+        .modern-card:hover {
+            border-color: var(--primary-purple);
+            box-shadow: var(--shadow-xl);
+        }
+        
+        /* Status Cards */
+        .status-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: var(--space-4);
+            margin-bottom: var(--space-6);
+        }
+        
+        .status-card {
+            background: var(--secondary-dark);
+            border: 1px solid var(--gray-700);
+            border-radius: var(--radius-lg);
+            padding: var(--space-4);
+            text-align: center;
+            transition: all 0.2s ease;
+        }
+        
+        .status-card:hover {
+            transform: translateY(-2px);
+            box-shadow: var(--shadow-lg);
+        }
+        
+        .status-card h4 {
+            margin: 0 0 var(--space-2) 0;
+            font-size: var(--font-size-sm);
+            color: var(--gray-400);
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+        }
+        
+        .status-card .value {
+            font-size: var(--font-size-2xl);
+            font-weight: 800;
+            color: var(--primary-gold);
+            margin: 0;
+        }
+        
+        .status-card .subtitle {
+            font-size: var(--font-size-xs);
+            color: var(--gray-500);
+            margin: var(--space-1) 0 0 0;
+        }
+        
+        /* Modern Buttons */
+        .modern-btn {
+            background: var(--primary-purple);
+            color: white;
+            border: none;
+            border-radius: var(--radius-md);
+            padding: var(--space-3) var(--space-6);
+            font-weight: 600;
+            font-size: var(--font-size-sm);
+            cursor: pointer;
+            transition: all 0.2s ease;
+            box-shadow: var(--shadow-sm);
+        }
+        
+        .modern-btn:hover {
+            background: #5b21b6;
+            transform: translateY(-1px);
+            box-shadow: var(--shadow-md);
+        }
+        
+        .modern-btn:active {
+            transform: translateY(0);
+        }
+        
+        .modern-btn-secondary {
+            background: var(--gray-700);
+            color: var(--gray-100);
+        }
+        
+        .modern-btn-secondary:hover {
+            background: var(--gray-600);
+        }
+        
+        .modern-btn-success {
+            background: var(--accent-green);
+        }
+        
+        .modern-btn-success:hover {
+            background: #059669;
+        }
+        
+        .modern-btn-danger {
+            background: var(--accent-red);
+        }
+        
+        .modern-btn-danger:hover {
+            background: #dc2626;
+        }
+        
+        /* Form Elements */
+        .modern-input {
+            background: var(--secondary-dark);
+            border: 1px solid var(--gray-600);
+            border-radius: var(--radius-md);
+            padding: var(--space-3);
+            color: var(--gray-100);
+            font-size: var(--font-size-sm);
+            transition: all 0.2s ease;
+        }
+        
+        .modern-input:focus {
+            outline: none;
+            border-color: var(--primary-purple);
+            box-shadow: 0 0 0 3px rgb(109 40 217 / 0.1);
+        }
+        
+        /* Hero Section */
+        .hero-section {
+            background: linear-gradient(135deg, var(--primary-purple) 0%, var(--accent-blue) 100%);
+            border-radius: var(--radius-2xl);
+            padding: var(--space-8);
+            margin-bottom: var(--space-8);
+            text-align: center;
+            color: white;
+        }
+        
+        .hero-section h1 {
+            color: white;
+            margin-bottom: var(--space-4);
+        }
+        
+        .hero-section p {
+            font-size: var(--font-size-lg);
+            opacity: 0.9;
+            margin: 0;
+        }
+        
+        /* Progress Indicators */
+        .progress-bar {
+            background: var(--gray-700);
+            border-radius: var(--radius-lg);
+            height: 8px;
+            overflow: hidden;
+            margin: var(--space-2) 0;
+        }
+        
+        .progress-fill {
+            background: linear-gradient(90deg, var(--primary-purple), var(--primary-gold));
+            height: 100%;
+            transition: width 0.3s ease;
+        }
+        
+        /* Badges */
+        .badge {
+            display: inline-block;
+            padding: var(--space-1) var(--space-2);
+            border-radius: var(--radius-sm);
+            font-size: var(--font-size-xs);
+            font-weight: 600;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+        }
+        
+        .badge-success {
+            background: var(--accent-green);
+            color: white;
+        }
+        
+        .badge-warning {
+            background: var(--accent-orange);
+            color: white;
+        }
+        
+        .badge-danger {
+            background: var(--accent-red);
+            color: white;
+        }
+        
+        .badge-info {
+            background: var(--accent-blue);
+            color: white;
+        }
+        
+        /* Responsive Design */
+        @media (max-width: 768px) {
+            .main .block-container {
+                padding: var(--space-4) var(--space-2);
+            }
+            
+            .status-grid {
+                grid-template-columns: 1fr;
+            }
+            
+            .hero-section {
+                padding: var(--space-6);
+            }
+            
+            h1 {
+                font-size: var(--font-size-2xl);
+            }
+        }
+        
+        /* Loading States */
+        .loading {
+            display: inline-block;
+            width: 20px;
+            height: 20px;
+            border: 3px solid var(--gray-600);
+            border-radius: 50%;
+            border-top-color: var(--primary-purple);
+            animation: spin 1s ease-in-out infinite;
+        }
+        
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+        
+        /* Animations */
+        .fade-in {
+            animation: fadeIn 0.5s ease-in;
+        }
+        
+        @keyframes fadeIn {
+            from { opacity: 0; transform: translateY(20px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+        
+        .slide-in {
+            animation: slideIn 0.3s ease-out;
+        }
+        
+        @keyframes slideIn {
+            from { transform: translateX(-100%); }
+            to { transform: translateX(0); }
+        }
+        
+        /* Accessibility */
+        .sr-only {
+            position: absolute;
+            width: 1px;
+            height: 1px;
+            padding: 0;
+            margin: -1px;
+            overflow: hidden;
+            clip: rect(0, 0, 0, 0);
+            white-space: nowrap;
+            border: 0;
+        }
+        
+        /* Focus states for accessibility */
+        button:focus,
+        input:focus,
+        select:focus,
+        textarea:focus {
+            outline: 2px solid var(--primary-purple);
+            outline-offset: 2px;
+        }
+        </style>
+        """
+    
+    @staticmethod
+    def create_hero_section(title: str, subtitle: str, user_email: str = None) -> str:
+        """Create a modern hero section"""
+        if user_email:
+            return f"""
+            <div class="hero-section fade-in">
+                <h1>💜💛 {title}</h1>
+                <p>{subtitle}</p>
+                <div style="margin-top: var(--space-4); padding: var(--space-4); background: rgba(255,255,255,0.1); border-radius: var(--radius-lg);">
+                    <div style="font-size: var(--font-size-sm); opacity: 0.8;">Welcome,</div>
+                    <div style="font-weight: 800; font-size: var(--font-size-lg); margin: var(--space-1) 0;">{user_email}</div>
+                    <div style="font-size: var(--font-size-sm); opacity: 0.8;">Thank you for showing up for the community today. 💜💛</div>
+                </div>
+            </div>
+            """
+        else:
+            return f"""
+            <div class="hero-section fade-in">
+                <h1>💜💛 {title}</h1>
+                <p>{subtitle}</p>
+            </div>
+            """
+    
+    @staticmethod
+    def create_status_cards(data: Dict[str, Any]) -> str:
+        """Create modern status cards"""
+        cards_html = '<div class="status-grid">'
+        
+        for key, value in data.items():
+            if key == "shift_active":
+                cards_html += f"""
+                <div class="status-card slide-in">
+                    <h4>Shift Active</h4>
+                    <div class="value">{value}</div>
+                    <div class="subtitle">since you signed in</div>
+                </div>
+                """
+            elif key == "items_today":
+                cards_html += f"""
+                <div class="status-card slide-in">
+                    <h4>Items Logged Today</h4>
+                    <div class="value">{value}</div>
+                    <div class="subtitle">items processed</div>
+                </div>
+                """
+            elif key == "lifetime_hours":
+                cards_html += f"""
+                <div class="status-card slide-in">
+                    <h4>Lifetime Hours</h4>
+                    <div class="value">{value}</div>
+                    <div class="subtitle">volunteer hours</div>
+                </div>
+                """
+        
+        cards_html += '</div>'
+        return cards_html
+    
+    @staticmethod
+    def create_modern_form_section(title: str, description: str = None) -> str:
+        """Create a modern form section header"""
+        desc_html = f'<p style="color: var(--gray-400); margin-bottom: var(--space-4);">{description}</p>' if description else ''
+        return f"""
+        <div class="modern-card fade-in">
+            <h3>{title}</h3>
+            {desc_html}
+        """
+    
+    @staticmethod
+    def create_progress_indicator(current: int, total: int, label: str) -> str:
+        """Create a modern progress indicator"""
+        percentage = (current / total * 100) if total > 0 else 0
+        return f"""
+        <div style="margin: var(--space-4) 0;">
+            <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: var(--space-2);">
+                <span style="font-weight: 600; color: var(--gray-300);">{label}</span>
+                <span style="font-weight: 700; color: var(--primary-gold);">{current}/{total}</span>
+            </div>
+            <div class="progress-bar">
+                <div class="progress-fill" style="width: {percentage}%;"></div>
+            </div>
+        </div>
+        """
+    
+    @staticmethod
+    def create_badge(text: str, variant: str = "info") -> str:
+        """Create a modern badge"""
+        return f'<span class="badge badge-{variant}">{text}</span>'
+    
+    @staticmethod
+    def create_loading_spinner() -> str:
+        """Create a loading spinner"""
+        return '<div class="loading"></div>'
+
+def apply_modern_ui():
+    """Apply modern UI styling to the Streamlit app"""
+    st.markdown(ModernUIComponents.get_modern_css(), unsafe_allow_html=True)
+
+def create_modern_layout():
+    """Create a modern layout structure"""
+    return {
+        "container_style": "max-width: 1200px; margin: 0 auto;",
+        "sidebar_style": "background: var(--secondary-dark); border-right: 1px solid var(--gray-700);",
+        "main_style": "background: var(--primary-dark); padding: var(--space-6);"
+    }

backups/pre_modern_deployment_20250923_203628/backup_metadata.json

@@ -0,0 +1,34 @@
+{
+  "backup_name": "pre_modern_deployment_20250923_203628",
+  "timestamp": "20250923_203628",
+  "description": "pre_modern_deployment",
+  "files_backed_up": [
+    "streamlit_app.py",
+    "streamlit_app_modern.py",
+    ".streamlit/secrets.toml",
+    "requirements.txt",
+    "ui_improvements.py",
+    "test_app.py"
+  ],
+  "git_status": {
+    "modified_files": [
+      "M requirements.txt",
+      " M streamlit_app.py",
+      "?? .streamlit/",
+      "?? .venv/",
+      "?? DEPLOYMENT_QUICK_REFERENCE.md",
+      "?? UI_IMPROVEMENTS_GUIDE.md",
+      "?? __pycache__/",
+      "?? backups/",
+      "?? care_count.log",
+      "?? deploy_modern.py",
+      "?? deployment.log",
+      "?? streamlit_app_backup_20250923_195853.py",
+      "?? streamlit_app_modern.py",
+      "?? test_app.py",
+      "?? test_results.log",
+      "?? ui_improvements.py"
+    ],
+    "return_code": 0
+  }
+}

backups/pre_modern_deployment_20250923_203628/requirements.txt

@@ -0,0 +1,9 @@
+streamlit>=1.33
+pandas>=2.1
+Pillow>=10.1
+supabase>=2.5
+huggingface_hub>=0.24.6
+requests>=2.31
+python-dotenv>=1.0.0
+pytz>=2023.3
+

backups/pre_modern_deployment_20250923_203628/secrets.toml

@@ -0,0 +1,15 @@
+# Supabase connection
+SUPABASE_URL = "https://oudjcqhyldpncjbxohsg.supabase.co"
+SUPABASE_KEY ="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im91ZGpjcWh5bGRwbmNqYnhvaHNnIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTUzMDgyNDQsImV4cCI6MjA3MDg4NDI0NH0.SYwTtCe3r7WOZ25CRggL-lBkvGPjKnQhY_dT4Kjv9Dg"
+
+# App settings
+APP_TZ = "America/Toronto"
+
+# Hugging Face
+HF_TOKEN = "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"
+
+# Optional VLM model provider
+PROVIDER = "nebius"
+GEMMA_MODEL = "google/gemma-3-27b-it"
+NEBIUS_API_KEY = "eyJhbGciOiJIUzI1NiIsImtpZCI6IlV6SXJWd1h0dnprLVRvdzlLZWstc0M1akptWXBvX1VaVkxUZlpnMDRlOFUiLCJ0eXAiOiJKV1QifQ.eyJzdWIiOiJnb29nbGUtb2F1dGgyfDEwMjk4MzMxNjQ1OTQzNjA5ODYxMyIsInNjb3BlIjoib3BlbmlkIG9mZmxpbmVfYWNjZXNzIiwiaXNzIjoiYXBpX2tleV9pc3N1ZXIiLCJhdWQiOlsiaHR0cHM6Ly9uZWJpdXMtaW5mZXJlbmNlLmV1LmF1dGgwLmNvbS9hcGkvdjIvIl0sImV4cCI6MTkxNTEzMTE3MiwidXVpZCI6IjJmOTUxZmM1LWEyNTgtNDg5OC1iNWI4LTkwZTljY2RkZjU2NSIsIm5hbWUiOiJjYXJlIGNvdW50IGFwcCIsImV4cGlyZXNfYXQiOiIyMDMwLTA5LTA4VDIwOjUyOjUyKzAwMDAifQ.awAHOieD93pCnYmFMgRQ64-i6yZdO0XvXczD4eS6xEI"
+NEBIUS_BASE_URL = "https://api.nebius.ai/v1"

backups/pre_modern_deployment_20250923_203628/streamlit_app.py

@@ -0,0 +1,891 @@
+# --- Care Count (Volunteers → Visits → Items) ---
+# Modern UI/UX with industry-standard design patterns
+# Enhanced version with improved user experience
+
+from __future__ import annotations
+
+import os, io, time, base64, re, uuid, json
+from datetime import datetime, timedelta
+from typing import Optional
+import logging
+
+import pytz
+import requests
+import pandas as pd
+import streamlit as st
+from PIL import Image, ImageOps, ImageEnhance
+from supabase import create_client, Client
+
+# Import our modern UI components
+from ui_improvements import ModernUIComponents, apply_modern_ui, create_modern_layout
+
+# ------------------------ Enhanced Logging ------------------------
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('care_count.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# ------------------------ App config ------------------------
+os.environ.setdefault("HOME", "/tmp")
+os.environ["STREAMLIT_BROWSER_GATHER_USAGE_STATS"] = "false"
+
+TZ             = os.getenv("APP_TZ", "America/Toronto")
+CUTOFF_HOUR    = int(os.getenv("CUTOFF_HOUR", "20"))   # 8pm local
+INACTIVITY_MIN = int(os.getenv("INACTIVITY_MIN", "30"))
+
+def local_now() -> datetime:
+    return datetime.now(pytz.timezone(TZ))
+
+# Enhanced page config with modern settings
+st.set_page_config(
+    page_title="Care Count - Volunteer Management",
+    page_icon="💜",
+    layout="wide",
+    initial_sidebar_state="expanded",
+    menu_items={
+        'Get Help': 'https://github.com/your-repo/care-count',
+        'Report a bug': "https://github.com/your-repo/care-count/issues",
+        'About': "# Care Count\nVolunteer management system for community impact tracking"
+    }
+)
+
+# Apply modern UI styling
+apply_modern_ui()
+
+# ------------------------ Enhanced Secrets Management ------------------------
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except Exception:
+    pass
+
+try:
+    _SECRETS = getattr(st, "secrets", {})
+except Exception:
+    _SECRETS = {}
+
+def _is_useful(val: Optional[str]) -> bool:
+    return val is not None and str(val).strip() != ""
+
+def get_secret(name: str, default: Optional[str] = None) -> Optional[str]:
+    """Enhanced secret management with logging"""
+    v = os.getenv(name)
+    if _is_useful(v):
+        logger.info(f"Secret {name} loaded from environment")
+        return v
+
+    try:
+        if hasattr(_SECRETS, "get"):
+            v = _SECRETS.get(name, default)
+            if _is_useful(v):
+                logger.info(f"Secret {name} loaded from Streamlit secrets")
+                return v
+    except Exception as e:
+        logger.warning(f"Failed to load secret {name} from Streamlit secrets: {e}")
+
+    return default
+
+def require_secret(name: str) -> str:
+    """Enhanced secret requirement with better error handling"""
+    v = get_secret(name, None)
+    if not _is_useful(v):
+        st.error(
+            f"🔐 **Configuration Error**\n\n"
+            f"Missing required configuration: `{name}`\n\n"
+            f"Please ensure this is set in your environment variables or `.streamlit/secrets.toml` file.\n\n"
+            f"For help, check the [documentation](https://github.com/your-repo/care-count#configuration)."
+        )
+        st.stop()
+    return str(v)
+
+# Required Supabase credentials
+SUPABASE_URL = require_secret("SUPABASE_URL")
+SUPABASE_KEY = require_secret("SUPABASE_KEY")
+
+# Initialize Supabase client with error handling
+try:
+    sb: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+    logger.info("Supabase client initialized successfully")
+except Exception as e:
+    st.error(f"Failed to connect to Supabase: {e}")
+    logger.error(f"Supabase connection failed: {e}")
+    st.stop()
+
+# Optional provider/config
+PROVIDER         = (get_secret("PROVIDER", "nebius") or "nebius").strip().lower()
+GEMMA_MODEL      = (get_secret("GEMMA_MODEL", "google/gemma-3-27b-it") or "google/gemma-3-27b-it").strip()
+NEBIUS_API_KEY   = get_secret("NEBIUS_API_KEY")
+NEBIUS_BASE_URL  = get_secret("NEBIUS_BASE_URL", "https://api.nebius.ai/v1")
+FEATH_API_KEY    = get_secret("FEATHERLESS_API_KEY")
+FEATH_BASE_URL   = get_secret("FEATHERLESS_BASE_URL", "https://api.featherless.ai/v1")
+
+# ------------------------ Enhanced Event Logging ------------------------
+def log_event(action: str, actor: Optional[str], details: dict, level: str = "info"):
+    """Enhanced event logging with multiple levels"""
+    log_data = {
+        "timestamp": datetime.utcnow().isoformat(),
+        "action": action,
+        "actor_email": actor,
+        "details": details,
+        "level": level
+    }
+    
+    # Log to file
+    if level == "error":
+        logger.error(f"Event: {action} by {actor} - {details}")
+    elif level == "warning":
+        logger.warning(f"Event: {action} by {actor} - {details}")
+    else:
+        logger.info(f"Event: {action} by {actor} - {details}")
+    
+    # Log to database
+    try:
+        sb.table("events").insert(log_data).execute()
+    except Exception as e:
+        logger.error(f"Failed to log event to database: {e}")
+
+# ------------------------ Modern Authentication UI ------------------------
+def auth_block() -> tuple[bool, Optional[str]]:
+    """Enhanced authentication with modern UI"""
+    if "auth_email" not in st.session_state:
+        st.session_state["auth_email"] = None
+    if "user_email" in st.session_state:
+        return True, st.session_state["user_email"]
+
+    # Modern hero section for login
+    st.markdown(ModernUIComponents.create_hero_section(
+        "Care Count",
+        "Thanks for showing up for the community today. Snap items, keep visits tidy, and help us understand the impact of your time."
+    ), unsafe_allow_html=True)
+
+    # Modern login form
+    with st.container():
+        st.markdown('<div class="modern-card">', unsafe_allow_html=True)
+        st.subheader("🔐 Sign In")
+        st.markdown("Enter your email to receive a secure login code.")
+        
+        with st.form("otp_request", clear_on_submit=False):
+            email = st.text_input(
+                "Email Address", 
+                value=st.session_state.get("auth_email") or "", 
+                placeholder="your.email@example.com",
+                help="We'll send you a secure 6-digit code"
+            )
+            
+            col1, col2, col3 = st.columns([1, 2, 1])
+            with col2:
+                send = st.form_submit_button("📧 Send Login Code", use_container_width=True)
+            
+            if send:
+                if not email or "@" not in email:
+                    st.error("Please enter a valid email address.")
+                else:
+                    try:
+                        with st.spinner("Sending login code..."):
+                            sb.auth.sign_in_with_otp({"email": email, "shouldCreateUser": True})
+                            st.session_state["auth_email"] = email
+                            st.success("✅ Login code sent! Check your email.")
+                            log_event("otp_requested", email, {"method": "email"})
+                    except Exception as e:
+                        st.error(f"❌ Could not send code: {e}")
+                        log_event("otp_failed", email, {"error": str(e)}, "error")
+
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    # OTP verification form
+    if st.session_state.get("auth_email"):
+        with st.container():
+            st.markdown('<div class="modern-card">', unsafe_allow_html=True)
+            st.subheader("🔢 Verify Code")
+            st.markdown(f"Enter the 6-digit code sent to **{st.session_state['auth_email']}**")
+            
+            with st.form("otp_verify", clear_on_submit=True):
+                code = st.text_input(
+                    "Verification Code", 
+                    max_chars=6,
+                    placeholder="123456",
+                    help="Enter the 6-digit code from your email"
+                )
+                
+                col1, col2, col3 = st.columns([1, 2, 1])
+                with col2:
+                    ok = st.form_submit_button("✅ Verify & Start Shift", use_container_width=True)
+                
+                if ok:
+                    if len(code) != 6 or not code.isdigit():
+                        st.error("Please enter a valid 6-digit code.")
+                    else:
+                        try:
+                            with st.spinner("Verifying code..."):
+                                res = sb.auth.verify_otp({"email": st.session_state["auth_email"], "token": code, "type": "email"})
+                                if res and res.user:
+                                    email = st.session_state["auth_email"]
+                                    
+                                    # Enhanced volunteer upsert
+                                    volunteer_data = {
+                                        "email": email,
+                                        "last_login_at": datetime.utcnow().isoformat(),
+                                        "shift_started_at": datetime.utcnow().isoformat(),
+                                        "shift_ended_at": None,
+                                        "login_count": 1  # Track login frequency
+                                    }
+                                    
+                                    sb.table("volunteers").upsert(volunteer_data, on_conflict="email").execute()
+                                    
+                                    st.session_state["user_email"] = email
+                                    st.session_state["shift_started"] = True
+                                    st.session_state["last_activity_at"] = local_now()
+                                    
+                                    log_event("login_success", email, {"method": "otp"})
+                                    st.success("🎉 Welcome back! Your shift has started.")
+                                    st.balloons()
+                                    return True, email
+                        except Exception as e:
+                            st.error(f"❌ Verification failed: {e}")
+                            log_event("otp_verification_failed", st.session_state["auth_email"], {"error": str(e)}, "error")
+            
+            st.markdown('</div>', unsafe_allow_html=True)
+    
+    return False, None
+
+def end_shift(email: str, reason: str):
+    """Enhanced shift ending with better logging"""
+    try:
+        end_time = datetime.utcnow().isoformat()
+        sb.table("volunteers").update({"shift_ended_at": end_time}).eq("email", email).execute()
+        log_event("shift_end", email, {"reason": reason, "end_time": end_time})
+    except Exception as e:
+        logger.error(f"Failed to end shift for {email}: {e}")
+
+def guard_cutoff_and_idle(email: str):
+    """Enhanced session management with better UX"""
+    now = local_now()
+    last = st.session_state.get("last_activity_at")
+    
+    if last and (now - last).total_seconds() > INACTIVITY_MIN * 60:
+        end_shift(email, "inactivity")
+        st.session_state.clear()
+        st.warning("⏰ You were logged out due to inactivity. Thank you for volunteering today!")
+        st.stop()
+    
+    st.session_state["last_activity_at"] = now
+
+    cutoff = now.replace(hour=CUTOFF_HOUR, minute=0, second=0, microsecond=0)
+    if now >= cutoff:
+        end_shift(email, "cutoff_8pm")
+        st.session_state.clear()
+        st.info("🌅 We close the day at 8pm. Your shift has been ended. Thank you so much!")
+        st.stop()
+
+# ------------------------ Main App Flow ------------------------
+def main():
+    """Main application flow with modern UI"""
+    
+    # Authentication
+    signed_in, user_email = auth_block()
+    if not signed_in:
+        st.stop()
+    
+    guard_cutoff_and_idle(user_email)
+
+    # Modern welcome section
+    st.markdown(ModernUIComponents.create_hero_section(
+        "Care Count Dashboard",
+        "Manage visits, track items, and make a difference in your community.",
+        user_email
+    ), unsafe_allow_html=True)
+
+    # Enhanced status cards
+    vrow = fetch_volunteer_row(user_email) or {}
+    shift_started_at = vrow.get("shift_started_at")
+    lifetime_hours = vrow.get("total_hours", 0)
+    
+    mins_active = 0
+    try:
+        if shift_started_at:
+            t0 = datetime.fromisoformat(str(shift_started_at).replace("Z","+00:00"))
+            mins_active = max(0, int((datetime.utcnow() - t0).total_seconds() // 60))
+    except Exception:
+        pass
+
+    status_data = {
+        "shift_active": f"{mins_active} min",
+        "items_today": items_today(user_email),
+        "lifetime_hours": f"{round(float(lifetime_hours), 1)} hrs" if isinstance(lifetime_hours, (int, float)) else "0.0 hrs"
+    }
+    
+    st.markdown(ModernUIComponents.create_status_cards(status_data), unsafe_allow_html=True)
+
+    # Modern sign-out button
+    col1, col2, col3 = st.columns([1, 1, 1])
+    with col2:
+        if st.button("🔒 Sign Out", use_container_width=True, type="secondary"):
+            end_shift(user_email, "manual")
+            st.session_state.clear()
+            st.success("✅ Signed out successfully. See you next time!")
+            st.rerun()
+
+    # Enhanced visit management section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "🪪 Visit Management",
+        "Start and manage student visits with unique tracking codes"
+    ), unsafe_allow_html=True)
+    
+    active_visit = st.session_state.get("active_visit")
+    
+    col1, col2, col3 = st.columns([1, 1, 1])
+    
+    with col1:
+        if not active_visit and st.button("🚀 Start New Visit", use_container_width=True, type="primary"):
+            try:
+                with st.spinner("Creating visit..."):
+                    payload = {
+                        "visit_code": fallback_visit_code(),
+                        "started_at": datetime.utcnow().isoformat(),
+                        "ended_at": None,
+                        "created_by": user_email
+                    }
+                    v = sb.table("visits").insert(payload).execute().data[0]
+                    if not v.get("visit_code"):
+                        v["visit_code"] = payload["visit_code"]
+                    st.session_state["active_visit"] = v
+                    st.success(f"✅ Visit #{v['id']} started")
+                    st.info(f"**Visit Code:** `{v['visit_code']}`")
+                    log_event("visit_start", user_email, {"visit_id": v["id"], "visit_code": v["visit_code"]})
+                    st.rerun()
+            except Exception as e:
+                st.error(f"❌ Could not start visit: {e}")
+                log_event("visit_start_failed", user_email, {"error": str(e)}, "error")
+
+    with col2:
+        if active_visit and st.button("🏁 End Visit", use_container_width=True, type="secondary"):
+            try:
+                with st.spinner("Ending visit..."):
+                    sb.table("visits").update({"ended_at": datetime.utcnow().isoformat()}) \
+                      .eq("id", active_visit["id"]).execute()
+                    st.success("✅ Visit completed successfully")
+                    log_event("visit_end", user_email, {"visit_id": active_visit["id"]})
+                    st.session_state.pop("active_visit", None)
+                    st.rerun()
+            except Exception as e:
+                st.error(f"❌ Could not end visit: {e}")
+                log_event("visit_end_failed", user_email, {"error": str(e)}, "error")
+
+    with col3:
+        if st.session_state.get("active_visit"):
+            v = st.session_state["active_visit"]
+            st.info(f"**Active Visit:** #{v['id']}\n**Code:** {v.get('visit_code','')}")
+        else:
+            st.info("No active visit")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced item identification section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📸 Item Identification",
+        "Use AI-powered image recognition to identify items quickly and accurately"
+    ), unsafe_allow_html=True)
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("📷 Camera Capture")
+        cam = st.camera_input("Take a photo of the item", help="Position the item clearly in the frame")
+    
+    with col2:
+        st.subheader("📁 File Upload")
+        up = st.file_uploader(
+            "Upload an image", 
+            type=["png","jpg","jpeg"],
+            help="Supported formats: PNG, JPG, JPEG"
+        )
+
+    img_file = cam or up
+    if img_file:
+        try:
+            img = Image.open(img_file).convert("RGB")
+            st.image(img, use_container_width=True, caption="Captured Image")
+            
+            if st.button("🔍 Identify Item with AI", use_container_width=True, type="primary"):
+                with st.spinner("Analyzing image with AI..."):
+                    t0 = time.time()
+                    try:
+                        pre = preprocess_for_label(img)
+                        raw = gemma_item_name(_to_png_bytes(pre))
+                        processing_time = time.time() - t0
+                        
+                        norm = normalize_item_name(raw)
+                        
+                        if raw:
+                            st.success(f"🤖 **AI Detection:** {raw}")
+                        st.info(f"✨ **Normalized:** {norm or '(unknown)'} · ⏱️ {processing_time:.2f}s")
+                        
+                        st.session_state["scanned_item_name"] = norm or raw or ""
+                        st.session_state["last_activity_at"] = local_now()
+                        
+                        log_event("item_identified", user_email, {
+                            "raw_name": raw,
+                            "normalized_name": norm,
+                            "processing_time": processing_time
+                        })
+                        
+                    except Exception as e:
+                        st.error(f"❌ AI identification failed: {e}")
+                        log_event("ai_identification_failed", user_email, {"error": str(e)}, "error")
+        except Exception as e:
+            st.error(f"❌ Failed to process image: {e}")
+            log_event("image_processing_failed", user_email, {"error": str(e)}, "error")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced item logging section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📬 Item Logging",
+        "Log items to the current visit with detailed information"
+    ), unsafe_allow_html=True)
+    
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        item_name = st.text_input(
+            "Item Name", 
+            value=st.session_state.get("scanned_item_name",""),
+            placeholder="Enter item name or use AI detection above",
+            help="Required field - item name for tracking"
+        )
+    
+    with col2:
+        quantity = st.number_input(
+            "Quantity", 
+            min_value=1, 
+            max_value=9999, 
+            step=1, 
+            value=1,
+            help="Number of items"
+        )
+    
+    col3, col4 = st.columns(2)
+    
+    with col3:
+        category = st.text_input(
+            "Category (optional)", 
+            placeholder="e.g., Food, Hygiene, Clothing",
+            help="Item category for better organization"
+        )
+    
+    with col4:
+        unit = st.text_input(
+            "Unit (optional)", 
+            placeholder="e.g., 500 mL, 1 L, 250 g",
+            help="Unit of measurement"
+        )
+    
+    barcode = st.text_input(
+        "Barcode (optional)", 
+        placeholder="Scan or enter barcode",
+        help="Product barcode for inventory tracking"
+    )
+
+    save_disabled = not st.session_state.get("active_visit")
+    if st.button("✅ Save Item to Visit", disabled=save_disabled, use_container_width=True, type="primary"):
+        v = st.session_state.get("active_visit")
+        if not v:
+            st.warning("⚠️ Please start a visit first before logging items.")
+        else:
+            name_clean = clean_text(item_name, 120)
+            if not name_clean:
+                st.warning("⚠️ Item name is required.")
+            else:
+                with st.spinner("Saving item..."):
+                    ts_iso = datetime.utcnow().isoformat()
+                    ingest_id = deterministic_ingest_id(int(v["id"]), user_email, name_clean, int(quantity), ts_iso)
+                    
+                    try:
+                        ok, msg = try_rpc_ingest(
+                            email=user_email, v_id=int(v["id"]), name=name_clean, qty=int(quantity),
+                            category=clean_text(category, 80), unit=clean_text(unit, 40),
+                            barcode=clean_text(barcode, 64), ts_iso=ts_iso, ingest_id=ingest_id
+                        )
+                        
+                        if ok:
+                            st.success("✅ Item logged successfully!")
+                            log_event("item_logged", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                        else:
+                            st.warning(f"⚠️ {msg}. Trying fallback method...")
+                            fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                                   clean_text(category,80), clean_text(unit,40),
+                                                   clean_text(barcode,64), ts_iso, ingest_id)
+                            st.success("✅ Item logged successfully (fallback method)!")
+                            log_event("item_logged_fallback", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                    except Exception as e:
+                        try:
+                            fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                                   clean_text(category,80), clean_text(unit,40),
+                                                   clean_text(barcode,64), ts_iso, ingest_id)
+                            st.success("✅ Item logged successfully (fallback method)!")
+                            log_event("item_logged_fallback", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                        except Exception as e2:
+                            st.error(f"❌ Failed to log item: {e2}")
+                            log_event("item_log_failed", user_email, {"error": str(e2)}, "error")
+                    
+                    st.session_state["last_activity_at"] = local_now()
+                    st.session_state["scanned_item_name"] = name_clean
+                    st.rerun()
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced visit items view
+    if st.session_state.get("active_visit"):
+        st.markdown(ModernUIComponents.create_modern_form_section(
+            "🧾 Current Visit Items",
+            "Review and manage items in the current visit"
+        ), unsafe_allow_html=True)
+        
+        rows = load_items_for_visit(int(st.session_state["active_visit"]["id"]))
+        if rows:
+            df = pd.DataFrame(rows)
+            
+            # Enhanced dataframe display
+            st.dataframe(
+                df, 
+                use_container_width=True,
+                hide_index=True,
+                column_config={
+                    "timestamp": st.column_config.DatetimeColumn("Time", format="MM/DD/YY HH:mm"),
+                    "item_name": st.column_config.TextColumn("Item Name", width="medium"),
+                    "qty": st.column_config.NumberColumn("Quantity", width="small"),
+                    "category": st.column_config.TextColumn("Category", width="small"),
+                    "unit": st.column_config.TextColumn("Unit", width="small")
+                }
+            )
+            
+            # Enhanced delete functionality
+            with st.expander("🗑️ Delete Item (if mis-logged)"):
+                if rows:
+                    item_options = {f"{r['item_name']} (Qty: {r['qty']})": r["id"] for r in rows if "id" in r}
+                    selected_item = st.selectbox("Select item to delete", list(item_options.keys()))
+                    
+                    if st.button("🗑️ Delete Selected Item", type="secondary"):
+                        item_id = item_options[selected_item]
+                        try:
+                            # Try both tables safely
+                            try:
+                                delete_item("visit_items_p", int(item_id))
+                            except Exception:
+                                delete_item("visit_items", int(item_id))
+                            
+                            st.success("✅ Item deleted successfully")
+                            log_event("item_deleted", user_email, {"item_id": item_id})
+                            st.rerun()
+                        except Exception as e:
+                            st.error(f"❌ Failed to delete item: {e}")
+                            log_event("item_delete_failed", user_email, {"error": str(e)}, "error")
+                else:
+                    st.info("No items to delete")
+        else:
+            st.info("📝 No items logged for this visit yet.")
+        
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced analytics section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📈 Today's Analytics",
+        "Real-time insights into today's volunteer activity"
+    ), unsafe_allow_html=True)
+    
+    try:
+        daily = sb.table("v_daily_activity").select("*").execute().data
+        today_str = local_now().strftime("%Y-%m-%d")
+        today = next((r for r in daily if str(r.get("day",""))[:10]==today_str), None)
+        
+        if today:
+            visits = int(today.get("visits", 0))
+            items = int(today.get("items", 0))
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                st.metric("Total Visits Today", visits, delta=None)
+            with col2:
+                st.metric("Total Items Processed", items, delta=None)
+            
+            # Progress indicator
+            if visits > 0:
+                st.markdown(ModernUIComponents.create_progress_indicator(
+                    items, visits * 10, "Items per Visit Target"
+                ), unsafe_allow_html=True)
+        else:
+            st.info("📊 Analytics data will appear here as activity increases.")
+            
+    except Exception as e:
+        st.info("📊 Analytics view will be available once the database view is set up.")
+        logger.warning(f"Analytics view not available: {e}")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced footer with helpful information
+    st.markdown("""
+    <div class="modern-card" style="margin-top: var(--space-8); text-align: center;">
+        <h4>💡 Quick Tips</h4>
+        <p style="color: var(--gray-400); margin: 0;">
+            When you're done, please <strong>End Visit</strong> and <strong>Sign out</strong>.<br>
+            We'll auto-sign you out after inactivity or at 8pm local time. 💜
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+
+# ------------------------ Helper Functions (Enhanced) ------------------------
+def fetch_volunteer_row(email: str) -> dict | None:
+    """Enhanced volunteer data fetching with error handling"""
+    try:
+        return sb.table("volunteers").select("*").eq("email", email).single().execute().data
+    except Exception as e:
+        logger.warning(f"Failed to fetch volunteer data for {email}: {e}")
+        return None
+
+def items_today(email: str) -> int:
+    """Enhanced item counting with better error handling"""
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        # Try partitioned table first
+        data = sb.table("visit_items_p").select("id,timestamp,volunteer") \
+                .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                .eq("volunteer", email).execute().data
+        return len(data or [])
+    except Exception:
+        try:
+            data = sb.table("visit_items").select("id,timestamp,volunteer") \
+                    .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                    .eq("volunteer", email).execute().data
+            return len(data or [])
+        except Exception as e:
+            logger.warning(f"Failed to count items for {email}: {e}")
+            return 0
+
+def fallback_visit_code() -> str:
+    """Enhanced visit code generation with better uniqueness"""
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        todays = sb.table("visits").select("id,started_at").gte("started_at", f"{day} 00:00:00") \
+                 .lte("started_at", f"{day} 23:59:59").execute().data or []
+        seq = len(todays) + 1
+    except Exception:
+        seq = int(time.time()) % 1000
+    return f"V-{seq}-{local_now().strftime('%Y%m%d')}-{str(uuid.uuid4())[:6]}"
+
+def _to_png_bytes(img: Image.Image) -> bytes:
+    """Convert image to PNG bytes"""
+    b = io.BytesIO()
+    img.save(b, format="PNG")
+    return b.getvalue()
+
+def preprocess_for_label(img: Image.Image) -> Image.Image:
+    """Enhanced image preprocessing for better AI recognition"""
+    img = img.convert("RGB")
+    w, h = img.size
+    scale = 1024 / max(w, h) if max(w, h) > 1024 else 1.0
+    if scale < 1.0: 
+        img = img.resize((int(w * scale), int(h * scale)))
+    img = ImageOps.autocontrast(img, cutoff=2)
+    img = ImageEnhance.Brightness(img).enhance(1.06)
+    img = ImageEnhance.Contrast(img).enhance(1.05)
+    img = ImageEnhance.Sharpness(img).enhance(1.15)
+    return img
+
+def gemma_item_name(img_bytes: bytes) -> str:
+    """Enhanced AI item identification with better error handling"""
+    try:
+        if PROVIDER == "nebius":
+            if not NEBIUS_API_KEY: 
+                raise RuntimeError("NEBIUS_API_KEY missing")
+            return _openai_style_chat(NEBIUS_BASE_URL, NEBIUS_API_KEY, GEMMA_MODEL, img_bytes)
+        elif PROVIDER == "featherless":
+            if not FEATH_API_KEY: 
+                raise RuntimeError("FEATHERLESS_API_KEY missing")
+            return _openai_style_chat(FEATH_BASE_URL, FEATH_API_KEY, GEMMA_MODEL, img_bytes)
+        else:
+            raise RuntimeError(f"Unknown PROVIDER: {PROVIDER}")
+    except Exception as e:
+        logger.error(f"AI identification failed: {e}")
+        raise
+
+def _openai_style_chat(base_url: str, api_key: str, model_id: str, img_bytes: bytes) -> str:
+    """Enhanced API communication with better error handling"""
+    b64 = base64.b64encode(img_bytes).decode("utf-8")
+    url = f"{base_url.rstrip('/')}/chat/completions"
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    payload = {
+        "model": model_id,
+        "temperature": 0,
+        "messages": [
+            {"role": "system", "content": "You label item being held in the image for a food bank. Return ONLY the item name."},
+            {"role": "user", "content": [
+                {"type": "text", "text": "What is the name of the item in the picture? Return only the item name."},
+                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}}
+            ]}
+        ]
+    }
+    
+    try:
+        r = requests.post(url, json=payload, headers=headers, timeout=90)
+        if r.status_code != 200:
+            raise RuntimeError(f"LLM HTTP {r.status_code}: {r.text[:200]}")
+        data = r.json()
+        return (data["choices"][0]["message"]["content"] or "").strip()
+    except requests.exceptions.Timeout:
+        raise RuntimeError("AI service timeout - please try again")
+    except requests.exceptions.RequestException as e:
+        raise RuntimeError(f"AI service error: {e}")
+
+def normalize_item_name(s: str) -> str:
+    """Enhanced item name normalization"""
+    s = (s or "").strip()
+    if not s: 
+        return ""
+    
+    # Enhanced brand and type recognition
+    BRANDS = {
+        "whiskas","tetley","kellogg's","kelloggs","campbell's","campbells","heinz",
+        "nestle","kraft","general mills","cheerios","oreo","oreos","pringles","lays","doritos",
+        "ice river","green bottle","great value","wheat thins","vegetable thins","raid"
+    }
+    GENERIC_TYPES = {
+        "water","toothpaste","deodorant","antiperspirant","soap","shampoo","conditioner",
+        "lotion","tea","coffee","cereal","pasta","rice","beans","sauce","salsa","cleaner",
+        "peanut butter","jam","jelly","tuna","chicken","beef","flour","sugar","salt","oil",
+        "crackers","cookies","soup","insect killer","spray"
+    }
+    
+    low = re.sub(r"[®™]", "", s.lower())
+    for b in BRANDS: 
+        low = low.replace(b, "")
+    
+    chosen = None
+    for t in GENERIC_TYPES:
+        if t in low: 
+            chosen = t
+            break
+    
+    cleaned = " ".join(low.split())
+    return (chosen or cleaned.title())[:120]
+
+def clean_text(v: Optional[str], maxlen: int = 120) -> Optional[str]:
+    """Enhanced text cleaning"""
+    if not v: 
+        return None
+    v = re.sub(r"\s+", " ", v).strip()
+    return v[:maxlen] if v else None
+
+def deterministic_ingest_id(v_id: int, email: str, name: str, qty: int, ts_iso: str) -> str:
+    """Enhanced ID generation for data integrity"""
+    key = f"visit_items::{v_id}::{email}::{name}::{qty}::{ts_iso}"
+    return str(uuid.uuid5(uuid.NAMESPACE_URL, key))
+
+def try_rpc_ingest(email: str, v_id: int, name: str, qty: int,
+                   category: Optional[str], unit: Optional[str],
+                   barcode: Optional[str], ts_iso: str, ingest_id: str) -> tuple[bool,str]:
+    """Enhanced RPC ingestion with better error handling"""
+    try:
+        res = sb.rpc("safe_ingest_visit_item", {
+            "p_email": email,
+            "p_visit_id": v_id,
+            "p_item_name": name,
+            "p_qty": qty,
+            "p_category": category,
+            "p_unit": unit,
+            "p_barcode": barcode,
+            "p_ts": ts_iso,
+            "p_ingest_id": ingest_id
+        }).execute()
+        
+        rows = res.data if isinstance(res.data, list) else []
+        if rows:
+            r0 = rows[0]
+            ok = bool(r0.get("ok", False))
+            msg = str(r0.get("msg", ""))
+            return ok, msg or ("ok" if ok else "failed")
+        return True, "ok"
+    except Exception as e:
+        logger.warning(f"RPC ingest failed, using fallback: {e}")
+        raise e
+
+def fallback_direct_insert(email: str, v_id: int, name: str, qty: int,
+                           category: Optional[str], unit: Optional[str],
+                           barcode: Optional[str], ts_iso: str, ingest_id: str) -> None:
+    """Enhanced fallback insertion with better error handling"""
+    payload = {
+        "visit_id": v_id,
+        "timestamp": ts_iso,
+        "volunteer": email,
+        "item_name": name,
+        "category": category,
+        "unit": unit,
+        "qty": qty,
+        "barcode": barcode,
+        "weather_type": None,
+        "temp_c": None,
+        "ingest_id": ingest_id
+    }
+    
+    try:
+        sb.table("visit_items_p").insert(payload).execute()
+    except Exception:
+        # Legacy table fallback
+        payload.pop("ingest_id", None)
+        sb.table("visit_items").insert(payload).execute()
+
+def load_items_for_visit(visit_id: int) -> list[dict]:
+    """Enhanced item loading with better error handling"""
+    try:
+        return sb.table("visit_items_p").select("*").eq("visit_id", visit_id) \
+            .order("timestamp", desc=True).limit(500).execute().data or []
+    except Exception:
+        try:
+            return sb.table("visit_items").select("*").eq("visit_id", visit_id) \
+                .order("timestamp", desc=True).limit(500).execute().data or []
+        except Exception as e:
+            logger.warning(f"Failed to load items for visit {visit_id}: {e}")
+            return []
+
+def delete_item(table: str, item_id: int):
+    """Enhanced item deletion with better error handling"""
+    try:
+        sb.table(table).delete().eq("id", item_id).execute()
+    except Exception as e:
+        logger.error(f"Failed to delete item {item_id} from {table}: {e}")
+        raise e
+
+# ------------------------ App Configuration Display ------------------------
+st.sidebar.markdown("### ⚙️ Configuration")
+st.sidebar.info(f"""
+**Provider:** `{PROVIDER}`  
+**Model:** `{GEMMA_MODEL}`  
+**Timezone:** `{TZ}`  
+**Cutoff:** {CUTOFF_HOUR}:00 PM  
+**Inactivity:** {INACTIVITY_MIN} min
+""")
+
+# ------------------------ Main App Execution ------------------------
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        logger.error(f"Application error: {e}")
+        st.error(f"❌ Application error: {e}")
+        st.info("Please refresh the page or contact support if the issue persists.")

backups/pre_modern_deployment_20250923_203628/streamlit_app_modern.py

@@ -0,0 +1,891 @@
+# --- Care Count (Volunteers → Visits → Items) ---
+# Modern UI/UX with industry-standard design patterns
+# Enhanced version with improved user experience
+
+from __future__ import annotations
+
+import os, io, time, base64, re, uuid, json
+from datetime import datetime, timedelta
+from typing import Optional
+import logging
+
+import pytz
+import requests
+import pandas as pd
+import streamlit as st
+from PIL import Image, ImageOps, ImageEnhance
+from supabase import create_client, Client
+
+# Import our modern UI components
+from ui_improvements import ModernUIComponents, apply_modern_ui, create_modern_layout
+
+# ------------------------ Enhanced Logging ------------------------
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('care_count.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# ------------------------ App config ------------------------
+os.environ.setdefault("HOME", "/tmp")
+os.environ["STREAMLIT_BROWSER_GATHER_USAGE_STATS"] = "false"
+
+TZ             = os.getenv("APP_TZ", "America/Toronto")
+CUTOFF_HOUR    = int(os.getenv("CUTOFF_HOUR", "20"))   # 8pm local
+INACTIVITY_MIN = int(os.getenv("INACTIVITY_MIN", "30"))
+
+def local_now() -> datetime:
+    return datetime.now(pytz.timezone(TZ))
+
+# Enhanced page config with modern settings
+st.set_page_config(
+    page_title="Care Count - Volunteer Management",
+    page_icon="💜",
+    layout="wide",
+    initial_sidebar_state="expanded",
+    menu_items={
+        'Get Help': 'https://github.com/your-repo/care-count',
+        'Report a bug': "https://github.com/your-repo/care-count/issues",
+        'About': "# Care Count\nVolunteer management system for community impact tracking"
+    }
+)
+
+# Apply modern UI styling
+apply_modern_ui()
+
+# ------------------------ Enhanced Secrets Management ------------------------
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except Exception:
+    pass
+
+try:
+    _SECRETS = getattr(st, "secrets", {})
+except Exception:
+    _SECRETS = {}
+
+def _is_useful(val: Optional[str]) -> bool:
+    return val is not None and str(val).strip() != ""
+
+def get_secret(name: str, default: Optional[str] = None) -> Optional[str]:
+    """Enhanced secret management with logging"""
+    v = os.getenv(name)
+    if _is_useful(v):
+        logger.info(f"Secret {name} loaded from environment")
+        return v
+
+    try:
+        if hasattr(_SECRETS, "get"):
+            v = _SECRETS.get(name, default)
+            if _is_useful(v):
+                logger.info(f"Secret {name} loaded from Streamlit secrets")
+                return v
+    except Exception as e:
+        logger.warning(f"Failed to load secret {name} from Streamlit secrets: {e}")
+
+    return default
+
+def require_secret(name: str) -> str:
+    """Enhanced secret requirement with better error handling"""
+    v = get_secret(name, None)
+    if not _is_useful(v):
+        st.error(
+            f"🔐 **Configuration Error**\n\n"
+            f"Missing required configuration: `{name}`\n\n"
+            f"Please ensure this is set in your environment variables or `.streamlit/secrets.toml` file.\n\n"
+            f"For help, check the [documentation](https://github.com/your-repo/care-count#configuration)."
+        )
+        st.stop()
+    return str(v)
+
+# Required Supabase credentials
+SUPABASE_URL = require_secret("SUPABASE_URL")
+SUPABASE_KEY = require_secret("SUPABASE_KEY")
+
+# Initialize Supabase client with error handling
+try:
+    sb: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+    logger.info("Supabase client initialized successfully")
+except Exception as e:
+    st.error(f"Failed to connect to Supabase: {e}")
+    logger.error(f"Supabase connection failed: {e}")
+    st.stop()
+
+# Optional provider/config
+PROVIDER         = (get_secret("PROVIDER", "nebius") or "nebius").strip().lower()
+GEMMA_MODEL      = (get_secret("GEMMA_MODEL", "google/gemma-3-27b-it") or "google/gemma-3-27b-it").strip()
+NEBIUS_API_KEY   = get_secret("NEBIUS_API_KEY")
+NEBIUS_BASE_URL  = get_secret("NEBIUS_BASE_URL", "https://api.nebius.ai/v1")
+FEATH_API_KEY    = get_secret("FEATHERLESS_API_KEY")
+FEATH_BASE_URL   = get_secret("FEATHERLESS_BASE_URL", "https://api.featherless.ai/v1")
+
+# ------------------------ Enhanced Event Logging ------------------------
+def log_event(action: str, actor: Optional[str], details: dict, level: str = "info"):
+    """Enhanced event logging with multiple levels"""
+    log_data = {
+        "timestamp": datetime.utcnow().isoformat(),
+        "action": action,
+        "actor_email": actor,
+        "details": details,
+        "level": level
+    }
+    
+    # Log to file
+    if level == "error":
+        logger.error(f"Event: {action} by {actor} - {details}")
+    elif level == "warning":
+        logger.warning(f"Event: {action} by {actor} - {details}")
+    else:
+        logger.info(f"Event: {action} by {actor} - {details}")
+    
+    # Log to database
+    try:
+        sb.table("events").insert(log_data).execute()
+    except Exception as e:
+        logger.error(f"Failed to log event to database: {e}")
+
+# ------------------------ Modern Authentication UI ------------------------
+def auth_block() -> tuple[bool, Optional[str]]:
+    """Enhanced authentication with modern UI"""
+    if "auth_email" not in st.session_state:
+        st.session_state["auth_email"] = None
+    if "user_email" in st.session_state:
+        return True, st.session_state["user_email"]
+
+    # Modern hero section for login
+    st.markdown(ModernUIComponents.create_hero_section(
+        "Care Count",
+        "Thanks for showing up for the community today. Snap items, keep visits tidy, and help us understand the impact of your time."
+    ))
+
+    # Modern login form
+    with st.container():
+        st.markdown('<div class="modern-card">', unsafe_allow_html=True)
+        st.subheader("🔐 Sign In")
+        st.markdown("Enter your email to receive a secure login code.")
+        
+        with st.form("otp_request", clear_on_submit=False):
+            email = st.text_input(
+                "Email Address", 
+                value=st.session_state.get("auth_email") or "", 
+                placeholder="your.email@example.com",
+                help="We'll send you a secure 6-digit code"
+            )
+            
+            col1, col2, col3 = st.columns([1, 2, 1])
+            with col2:
+                send = st.form_submit_button("📧 Send Login Code", use_container_width=True)
+            
+            if send:
+                if not email or "@" not in email:
+                    st.error("Please enter a valid email address.")
+                else:
+                    try:
+                        with st.spinner("Sending login code..."):
+                            sb.auth.sign_in_with_otp({"email": email, "shouldCreateUser": True})
+                            st.session_state["auth_email"] = email
+                            st.success("✅ Login code sent! Check your email.")
+                            log_event("otp_requested", email, {"method": "email"})
+                    except Exception as e:
+                        st.error(f"❌ Could not send code: {e}")
+                        log_event("otp_failed", email, {"error": str(e)}, "error")
+
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    # OTP verification form
+    if st.session_state.get("auth_email"):
+        with st.container():
+            st.markdown('<div class="modern-card">', unsafe_allow_html=True)
+            st.subheader("🔢 Verify Code")
+            st.markdown(f"Enter the 6-digit code sent to **{st.session_state['auth_email']}**")
+            
+            with st.form("otp_verify", clear_on_submit=True):
+                code = st.text_input(
+                    "Verification Code", 
+                    max_chars=6,
+                    placeholder="123456",
+                    help="Enter the 6-digit code from your email"
+                )
+                
+                col1, col2, col3 = st.columns([1, 2, 1])
+                with col2:
+                    ok = st.form_submit_button("✅ Verify & Start Shift", use_container_width=True)
+                
+                if ok:
+                    if len(code) != 6 or not code.isdigit():
+                        st.error("Please enter a valid 6-digit code.")
+                    else:
+                        try:
+                            with st.spinner("Verifying code..."):
+                                res = sb.auth.verify_otp({"email": st.session_state["auth_email"], "token": code, "type": "email"})
+                                if res and res.user:
+                                    email = st.session_state["auth_email"]
+                                    
+                                    # Enhanced volunteer upsert
+                                    volunteer_data = {
+                                        "email": email,
+                                        "last_login_at": datetime.utcnow().isoformat(),
+                                        "shift_started_at": datetime.utcnow().isoformat(),
+                                        "shift_ended_at": None,
+                                        "login_count": 1  # Track login frequency
+                                    }
+                                    
+                                    sb.table("volunteers").upsert(volunteer_data, on_conflict="email").execute()
+                                    
+                                    st.session_state["user_email"] = email
+                                    st.session_state["shift_started"] = True
+                                    st.session_state["last_activity_at"] = local_now()
+                                    
+                                    log_event("login_success", email, {"method": "otp"})
+                                    st.success("🎉 Welcome back! Your shift has started.")
+                                    st.balloons()
+                                    return True, email
+                        except Exception as e:
+                            st.error(f"❌ Verification failed: {e}")
+                            log_event("otp_verification_failed", st.session_state["auth_email"], {"error": str(e)}, "error")
+            
+            st.markdown('</div>', unsafe_allow_html=True)
+    
+    return False, None
+
+def end_shift(email: str, reason: str):
+    """Enhanced shift ending with better logging"""
+    try:
+        end_time = datetime.utcnow().isoformat()
+        sb.table("volunteers").update({"shift_ended_at": end_time}).eq("email", email).execute()
+        log_event("shift_end", email, {"reason": reason, "end_time": end_time})
+    except Exception as e:
+        logger.error(f"Failed to end shift for {email}: {e}")
+
+def guard_cutoff_and_idle(email: str):
+    """Enhanced session management with better UX"""
+    now = local_now()
+    last = st.session_state.get("last_activity_at")
+    
+    if last and (now - last).total_seconds() > INACTIVITY_MIN * 60:
+        end_shift(email, "inactivity")
+        st.session_state.clear()
+        st.warning("⏰ You were logged out due to inactivity. Thank you for volunteering today!")
+        st.stop()
+    
+    st.session_state["last_activity_at"] = now
+
+    cutoff = now.replace(hour=CUTOFF_HOUR, minute=0, second=0, microsecond=0)
+    if now >= cutoff:
+        end_shift(email, "cutoff_8pm")
+        st.session_state.clear()
+        st.info("🌅 We close the day at 8pm. Your shift has been ended. Thank you so much!")
+        st.stop()
+
+# ------------------------ Main App Flow ------------------------
+def main():
+    """Main application flow with modern UI"""
+    
+    # Authentication
+    signed_in, user_email = auth_block()
+    if not signed_in:
+        st.stop()
+    
+    guard_cutoff_and_idle(user_email)
+
+    # Modern welcome section
+    st.markdown(ModernUIComponents.create_hero_section(
+        "Care Count Dashboard",
+        "Manage visits, track items, and make a difference in your community.",
+        user_email
+    ))
+
+    # Enhanced status cards
+    vrow = fetch_volunteer_row(user_email) or {}
+    shift_started_at = vrow.get("shift_started_at")
+    lifetime_hours = vrow.get("total_hours", 0)
+    
+    mins_active = 0
+    try:
+        if shift_started_at:
+            t0 = datetime.fromisoformat(str(shift_started_at).replace("Z","+00:00"))
+            mins_active = max(0, int((datetime.utcnow() - t0).total_seconds() // 60))
+    except Exception:
+        pass
+
+    status_data = {
+        "shift_active": f"{mins_active} min",
+        "items_today": items_today(user_email),
+        "lifetime_hours": f"{round(float(lifetime_hours), 1)} hrs" if isinstance(lifetime_hours, (int, float)) else "0.0 hrs"
+    }
+    
+    st.markdown(ModernUIComponents.create_status_cards(status_data), unsafe_allow_html=True)
+
+    # Modern sign-out button
+    col1, col2, col3 = st.columns([1, 1, 1])
+    with col2:
+        if st.button("🔒 Sign Out", use_container_width=True, type="secondary"):
+            end_shift(user_email, "manual")
+            st.session_state.clear()
+            st.success("✅ Signed out successfully. See you next time!")
+            st.rerun()
+
+    # Enhanced visit management section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "🪪 Visit Management",
+        "Start and manage student visits with unique tracking codes"
+    ), unsafe_allow_html=True)
+    
+    active_visit = st.session_state.get("active_visit")
+    
+    col1, col2, col3 = st.columns([1, 1, 1])
+    
+    with col1:
+        if not active_visit and st.button("🚀 Start New Visit", use_container_width=True, type="primary"):
+            try:
+                with st.spinner("Creating visit..."):
+                    payload = {
+                        "visit_code": fallback_visit_code(),
+                        "started_at": datetime.utcnow().isoformat(),
+                        "ended_at": None,
+                        "created_by": user_email
+                    }
+                    v = sb.table("visits").insert(payload).execute().data[0]
+                    if not v.get("visit_code"):
+                        v["visit_code"] = payload["visit_code"]
+                    st.session_state["active_visit"] = v
+                    st.success(f"✅ Visit #{v['id']} started")
+                    st.info(f"**Visit Code:** `{v['visit_code']}`")
+                    log_event("visit_start", user_email, {"visit_id": v["id"], "visit_code": v["visit_code"]})
+                    st.rerun()
+            except Exception as e:
+                st.error(f"❌ Could not start visit: {e}")
+                log_event("visit_start_failed", user_email, {"error": str(e)}, "error")
+
+    with col2:
+        if active_visit and st.button("🏁 End Visit", use_container_width=True, type="secondary"):
+            try:
+                with st.spinner("Ending visit..."):
+                    sb.table("visits").update({"ended_at": datetime.utcnow().isoformat()}) \
+                      .eq("id", active_visit["id"]).execute()
+                    st.success("✅ Visit completed successfully")
+                    log_event("visit_end", user_email, {"visit_id": active_visit["id"]})
+                    st.session_state.pop("active_visit", None)
+                    st.rerun()
+            except Exception as e:
+                st.error(f"❌ Could not end visit: {e}")
+                log_event("visit_end_failed", user_email, {"error": str(e)}, "error")
+
+    with col3:
+        if st.session_state.get("active_visit"):
+            v = st.session_state["active_visit"]
+            st.info(f"**Active Visit:** #{v['id']}\n**Code:** {v.get('visit_code','')}")
+        else:
+            st.info("No active visit")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced item identification section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📸 Item Identification",
+        "Use AI-powered image recognition to identify items quickly and accurately"
+    ), unsafe_allow_html=True)
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("📷 Camera Capture")
+        cam = st.camera_input("Take a photo of the item", help="Position the item clearly in the frame")
+    
+    with col2:
+        st.subheader("📁 File Upload")
+        up = st.file_uploader(
+            "Upload an image", 
+            type=["png","jpg","jpeg"],
+            help="Supported formats: PNG, JPG, JPEG"
+        )
+
+    img_file = cam or up
+    if img_file:
+        try:
+            img = Image.open(img_file).convert("RGB")
+            st.image(img, use_container_width=True, caption="Captured Image")
+            
+            if st.button("🔍 Identify Item with AI", use_container_width=True, type="primary"):
+                with st.spinner("Analyzing image with AI..."):
+                    t0 = time.time()
+                    try:
+                        pre = preprocess_for_label(img)
+                        raw = gemma_item_name(_to_png_bytes(pre))
+                        processing_time = time.time() - t0
+                        
+                        norm = normalize_item_name(raw)
+                        
+                        if raw:
+                            st.success(f"🤖 **AI Detection:** {raw}")
+                        st.info(f"✨ **Normalized:** {norm or '(unknown)'} · ⏱️ {processing_time:.2f}s")
+                        
+                        st.session_state["scanned_item_name"] = norm or raw or ""
+                        st.session_state["last_activity_at"] = local_now()
+                        
+                        log_event("item_identified", user_email, {
+                            "raw_name": raw,
+                            "normalized_name": norm,
+                            "processing_time": processing_time
+                        })
+                        
+                    except Exception as e:
+                        st.error(f"❌ AI identification failed: {e}")
+                        log_event("ai_identification_failed", user_email, {"error": str(e)}, "error")
+        except Exception as e:
+            st.error(f"❌ Failed to process image: {e}")
+            log_event("image_processing_failed", user_email, {"error": str(e)}, "error")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced item logging section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📬 Item Logging",
+        "Log items to the current visit with detailed information"
+    ), unsafe_allow_html=True)
+    
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        item_name = st.text_input(
+            "Item Name", 
+            value=st.session_state.get("scanned_item_name",""),
+            placeholder="Enter item name or use AI detection above",
+            help="Required field - item name for tracking"
+        )
+    
+    with col2:
+        quantity = st.number_input(
+            "Quantity", 
+            min_value=1, 
+            max_value=9999, 
+            step=1, 
+            value=1,
+            help="Number of items"
+        )
+    
+    col3, col4 = st.columns(2)
+    
+    with col3:
+        category = st.text_input(
+            "Category (optional)", 
+            placeholder="e.g., Food, Hygiene, Clothing",
+            help="Item category for better organization"
+        )
+    
+    with col4:
+        unit = st.text_input(
+            "Unit (optional)", 
+            placeholder="e.g., 500 mL, 1 L, 250 g",
+            help="Unit of measurement"
+        )
+    
+    barcode = st.text_input(
+        "Barcode (optional)", 
+        placeholder="Scan or enter barcode",
+        help="Product barcode for inventory tracking"
+    )
+
+    save_disabled = not st.session_state.get("active_visit")
+    if st.button("✅ Save Item to Visit", disabled=save_disabled, use_container_width=True, type="primary"):
+        v = st.session_state.get("active_visit")
+        if not v:
+            st.warning("⚠️ Please start a visit first before logging items.")
+        else:
+            name_clean = clean_text(item_name, 120)
+            if not name_clean:
+                st.warning("⚠️ Item name is required.")
+            else:
+                with st.spinner("Saving item..."):
+                    ts_iso = datetime.utcnow().isoformat()
+                    ingest_id = deterministic_ingest_id(int(v["id"]), user_email, name_clean, int(quantity), ts_iso)
+                    
+                    try:
+                        ok, msg = try_rpc_ingest(
+                            email=user_email, v_id=int(v["id"]), name=name_clean, qty=int(quantity),
+                            category=clean_text(category, 80), unit=clean_text(unit, 40),
+                            barcode=clean_text(barcode, 64), ts_iso=ts_iso, ingest_id=ingest_id
+                        )
+                        
+                        if ok:
+                            st.success("✅ Item logged successfully!")
+                            log_event("item_logged", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                        else:
+                            st.warning(f"⚠️ {msg}. Trying fallback method...")
+                            fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                                   clean_text(category,80), clean_text(unit,40),
+                                                   clean_text(barcode,64), ts_iso, ingest_id)
+                            st.success("✅ Item logged successfully (fallback method)!")
+                            log_event("item_logged_fallback", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                    except Exception as e:
+                        try:
+                            fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                                   clean_text(category,80), clean_text(unit,40),
+                                                   clean_text(barcode,64), ts_iso, ingest_id)
+                            st.success("✅ Item logged successfully (fallback method)!")
+                            log_event("item_logged_fallback", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                        except Exception as e2:
+                            st.error(f"❌ Failed to log item: {e2}")
+                            log_event("item_log_failed", user_email, {"error": str(e2)}, "error")
+                    
+                    st.session_state["last_activity_at"] = local_now()
+                    st.session_state["scanned_item_name"] = name_clean
+                    st.rerun()
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced visit items view
+    if st.session_state.get("active_visit"):
+        st.markdown(ModernUIComponents.create_modern_form_section(
+            "🧾 Current Visit Items",
+            "Review and manage items in the current visit"
+        ), unsafe_allow_html=True)
+        
+        rows = load_items_for_visit(int(st.session_state["active_visit"]["id"]))
+        if rows:
+            df = pd.DataFrame(rows)
+            
+            # Enhanced dataframe display
+            st.dataframe(
+                df, 
+                use_container_width=True,
+                hide_index=True,
+                column_config={
+                    "timestamp": st.column_config.DatetimeColumn("Time", format="MM/DD/YY HH:mm"),
+                    "item_name": st.column_config.TextColumn("Item Name", width="medium"),
+                    "qty": st.column_config.NumberColumn("Quantity", width="small"),
+                    "category": st.column_config.TextColumn("Category", width="small"),
+                    "unit": st.column_config.TextColumn("Unit", width="small")
+                }
+            )
+            
+            # Enhanced delete functionality
+            with st.expander("🗑️ Delete Item (if mis-logged)"):
+                if rows:
+                    item_options = {f"{r['item_name']} (Qty: {r['qty']})": r["id"] for r in rows if "id" in r}
+                    selected_item = st.selectbox("Select item to delete", list(item_options.keys()))
+                    
+                    if st.button("🗑️ Delete Selected Item", type="secondary"):
+                        item_id = item_options[selected_item]
+                        try:
+                            # Try both tables safely
+                            try:
+                                delete_item("visit_items_p", int(item_id))
+                            except Exception:
+                                delete_item("visit_items", int(item_id))
+                            
+                            st.success("✅ Item deleted successfully")
+                            log_event("item_deleted", user_email, {"item_id": item_id})
+                            st.rerun()
+                        except Exception as e:
+                            st.error(f"❌ Failed to delete item: {e}")
+                            log_event("item_delete_failed", user_email, {"error": str(e)}, "error")
+                else:
+                    st.info("No items to delete")
+        else:
+            st.info("📝 No items logged for this visit yet.")
+        
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced analytics section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📈 Today's Analytics",
+        "Real-time insights into today's volunteer activity"
+    ), unsafe_allow_html=True)
+    
+    try:
+        daily = sb.table("v_daily_activity").select("*").execute().data
+        today_str = local_now().strftime("%Y-%m-%d")
+        today = next((r for r in daily if str(r.get("day",""))[:10]==today_str), None)
+        
+        if today:
+            visits = int(today.get("visits", 0))
+            items = int(today.get("items", 0))
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                st.metric("Total Visits Today", visits, delta=None)
+            with col2:
+                st.metric("Total Items Processed", items, delta=None)
+            
+            # Progress indicator
+            if visits > 0:
+                st.markdown(ModernUIComponents.create_progress_indicator(
+                    items, visits * 10, "Items per Visit Target"
+                ), unsafe_allow_html=True)
+        else:
+            st.info("📊 Analytics data will appear here as activity increases.")
+            
+    except Exception as e:
+        st.info("📊 Analytics view will be available once the database view is set up.")
+        logger.warning(f"Analytics view not available: {e}")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced footer with helpful information
+    st.markdown("""
+    <div class="modern-card" style="margin-top: var(--space-8); text-align: center;">
+        <h4>💡 Quick Tips</h4>
+        <p style="color: var(--gray-400); margin: 0;">
+            When you're done, please <strong>End Visit</strong> and <strong>Sign out</strong>.<br>
+            We'll auto-sign you out after inactivity or at 8pm local time. 💜
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+
+# ------------------------ Helper Functions (Enhanced) ------------------------
+def fetch_volunteer_row(email: str) -> dict | None:
+    """Enhanced volunteer data fetching with error handling"""
+    try:
+        return sb.table("volunteers").select("*").eq("email", email).single().execute().data
+    except Exception as e:
+        logger.warning(f"Failed to fetch volunteer data for {email}: {e}")
+        return None
+
+def items_today(email: str) -> int:
+    """Enhanced item counting with better error handling"""
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        # Try partitioned table first
+        data = sb.table("visit_items_p").select("id,timestamp,volunteer") \
+                .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                .eq("volunteer", email).execute().data
+        return len(data or [])
+    except Exception:
+        try:
+            data = sb.table("visit_items").select("id,timestamp,volunteer") \
+                    .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                    .eq("volunteer", email).execute().data
+            return len(data or [])
+        except Exception as e:
+            logger.warning(f"Failed to count items for {email}: {e}")
+            return 0
+
+def fallback_visit_code() -> str:
+    """Enhanced visit code generation with better uniqueness"""
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        todays = sb.table("visits").select("id,started_at").gte("started_at", f"{day} 00:00:00") \
+                 .lte("started_at", f"{day} 23:59:59").execute().data or []
+        seq = len(todays) + 1
+    except Exception:
+        seq = int(time.time()) % 1000
+    return f"V-{seq}-{local_now().strftime('%Y%m%d')}-{str(uuid.uuid4())[:6]}"
+
+def _to_png_bytes(img: Image.Image) -> bytes:
+    """Convert image to PNG bytes"""
+    b = io.BytesIO()
+    img.save(b, format="PNG")
+    return b.getvalue()
+
+def preprocess_for_label(img: Image.Image) -> Image.Image:
+    """Enhanced image preprocessing for better AI recognition"""
+    img = img.convert("RGB")
+    w, h = img.size
+    scale = 1024 / max(w, h) if max(w, h) > 1024 else 1.0
+    if scale < 1.0: 
+        img = img.resize((int(w * scale), int(h * scale)))
+    img = ImageOps.autocontrast(img, cutoff=2)
+    img = ImageEnhance.Brightness(img).enhance(1.06)
+    img = ImageEnhance.Contrast(img).enhance(1.05)
+    img = ImageEnhance.Sharpness(img).enhance(1.15)
+    return img
+
+def gemma_item_name(img_bytes: bytes) -> str:
+    """Enhanced AI item identification with better error handling"""
+    try:
+        if PROVIDER == "nebius":
+            if not NEBIUS_API_KEY: 
+                raise RuntimeError("NEBIUS_API_KEY missing")
+            return _openai_style_chat(NEBIUS_BASE_URL, NEBIUS_API_KEY, GEMMA_MODEL, img_bytes)
+        elif PROVIDER == "featherless":
+            if not FEATH_API_KEY: 
+                raise RuntimeError("FEATHERLESS_API_KEY missing")
+            return _openai_style_chat(FEATH_BASE_URL, FEATH_API_KEY, GEMMA_MODEL, img_bytes)
+        else:
+            raise RuntimeError(f"Unknown PROVIDER: {PROVIDER}")
+    except Exception as e:
+        logger.error(f"AI identification failed: {e}")
+        raise
+
+def _openai_style_chat(base_url: str, api_key: str, model_id: str, img_bytes: bytes) -> str:
+    """Enhanced API communication with better error handling"""
+    b64 = base64.b64encode(img_bytes).decode("utf-8")
+    url = f"{base_url.rstrip('/')}/chat/completions"
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    payload = {
+        "model": model_id,
+        "temperature": 0,
+        "messages": [
+            {"role": "system", "content": "You label item being held in the image for a food bank. Return ONLY the item name."},
+            {"role": "user", "content": [
+                {"type": "text", "text": "What is the name of the item in the picture? Return only the item name."},
+                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}}
+            ]}
+        ]
+    }
+    
+    try:
+        r = requests.post(url, json=payload, headers=headers, timeout=90)
+        if r.status_code != 200:
+            raise RuntimeError(f"LLM HTTP {r.status_code}: {r.text[:200]}")
+        data = r.json()
+        return (data["choices"][0]["message"]["content"] or "").strip()
+    except requests.exceptions.Timeout:
+        raise RuntimeError("AI service timeout - please try again")
+    except requests.exceptions.RequestException as e:
+        raise RuntimeError(f"AI service error: {e}")
+
+def normalize_item_name(s: str) -> str:
+    """Enhanced item name normalization"""
+    s = (s or "").strip()
+    if not s: 
+        return ""
+    
+    # Enhanced brand and type recognition
+    BRANDS = {
+        "whiskas","tetley","kellogg's","kelloggs","campbell's","campbells","heinz",
+        "nestle","kraft","general mills","cheerios","oreo","oreos","pringles","lays","doritos",
+        "ice river","green bottle","great value","wheat thins","vegetable thins","raid"
+    }
+    GENERIC_TYPES = {
+        "water","toothpaste","deodorant","antiperspirant","soap","shampoo","conditioner",
+        "lotion","tea","coffee","cereal","pasta","rice","beans","sauce","salsa","cleaner",
+        "peanut butter","jam","jelly","tuna","chicken","beef","flour","sugar","salt","oil",
+        "crackers","cookies","soup","insect killer","spray"
+    }
+    
+    low = re.sub(r"[®™]", "", s.lower())
+    for b in BRANDS: 
+        low = low.replace(b, "")
+    
+    chosen = None
+    for t in GENERIC_TYPES:
+        if t in low: 
+            chosen = t
+            break
+    
+    cleaned = " ".join(low.split())
+    return (chosen or cleaned.title())[:120]
+
+def clean_text(v: Optional[str], maxlen: int = 120) -> Optional[str]:
+    """Enhanced text cleaning"""
+    if not v: 
+        return None
+    v = re.sub(r"\s+", " ", v).strip()
+    return v[:maxlen] if v else None
+
+def deterministic_ingest_id(v_id: int, email: str, name: str, qty: int, ts_iso: str) -> str:
+    """Enhanced ID generation for data integrity"""
+    key = f"visit_items::{v_id}::{email}::{name}::{qty}::{ts_iso}"
+    return str(uuid.uuid5(uuid.NAMESPACE_URL, key))
+
+def try_rpc_ingest(email: str, v_id: int, name: str, qty: int,
+                   category: Optional[str], unit: Optional[str],
+                   barcode: Optional[str], ts_iso: str, ingest_id: str) -> tuple[bool,str]:
+    """Enhanced RPC ingestion with better error handling"""
+    try:
+        res = sb.rpc("safe_ingest_visit_item", {
+            "p_email": email,
+            "p_visit_id": v_id,
+            "p_item_name": name,
+            "p_qty": qty,
+            "p_category": category,
+            "p_unit": unit,
+            "p_barcode": barcode,
+            "p_ts": ts_iso,
+            "p_ingest_id": ingest_id
+        }).execute()
+        
+        rows = res.data if isinstance(res.data, list) else []
+        if rows:
+            r0 = rows[0]
+            ok = bool(r0.get("ok", False))
+            msg = str(r0.get("msg", ""))
+            return ok, msg or ("ok" if ok else "failed")
+        return True, "ok"
+    except Exception as e:
+        logger.warning(f"RPC ingest failed, using fallback: {e}")
+        raise e
+
+def fallback_direct_insert(email: str, v_id: int, name: str, qty: int,
+                           category: Optional[str], unit: Optional[str],
+                           barcode: Optional[str], ts_iso: str, ingest_id: str) -> None:
+    """Enhanced fallback insertion with better error handling"""
+    payload = {
+        "visit_id": v_id,
+        "timestamp": ts_iso,
+        "volunteer": email,
+        "item_name": name,
+        "category": category,
+        "unit": unit,
+        "qty": qty,
+        "barcode": barcode,
+        "weather_type": None,
+        "temp_c": None,
+        "ingest_id": ingest_id
+    }
+    
+    try:
+        sb.table("visit_items_p").insert(payload).execute()
+    except Exception:
+        # Legacy table fallback
+        payload.pop("ingest_id", None)
+        sb.table("visit_items").insert(payload).execute()
+
+def load_items_for_visit(visit_id: int) -> list[dict]:
+    """Enhanced item loading with better error handling"""
+    try:
+        return sb.table("visit_items_p").select("*").eq("visit_id", visit_id) \
+            .order("timestamp", desc=True).limit(500).execute().data or []
+    except Exception:
+        try:
+            return sb.table("visit_items").select("*").eq("visit_id", visit_id) \
+                .order("timestamp", desc=True).limit(500).execute().data or []
+        except Exception as e:
+            logger.warning(f"Failed to load items for visit {visit_id}: {e}")
+            return []
+
+def delete_item(table: str, item_id: int):
+    """Enhanced item deletion with better error handling"""
+    try:
+        sb.table(table).delete().eq("id", item_id).execute()
+    except Exception as e:
+        logger.error(f"Failed to delete item {item_id} from {table}: {e}")
+        raise e
+
+# ------------------------ App Configuration Display ------------------------
+st.sidebar.markdown("### ⚙️ Configuration")
+st.sidebar.info(f"""
+**Provider:** `{PROVIDER}`  
+**Model:** `{GEMMA_MODEL}`  
+**Timezone:** `{TZ}`  
+**Cutoff:** {CUTOFF_HOUR}:00 PM  
+**Inactivity:** {INACTIVITY_MIN} min
+""")
+
+# ------------------------ Main App Execution ------------------------
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        logger.error(f"Application error: {e}")
+        st.error(f"❌ Application error: {e}")
+        st.info("Please refresh the page or contact support if the issue persists.")

backups/pre_modern_deployment_20250923_203628/test_app.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""
+Care Count App Testing Framework
+Tests UI/UX changes and backend functionality
+"""
+
+import sys
+import os
+import time
+import logging
+from datetime import datetime
+from typing import Dict, Any, List
+import subprocess
+import requests
+from pathlib import Path
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('test_results.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+class CareCountTester:
+    def __init__(self):
+        self.test_results = []
+        self.app_url = "http://localhost:8501"
+        self.backup_dir = Path("backups")
+        self.backup_dir.mkdir(exist_ok=True)
+        
+    def create_backup(self, description: str = "manual_backup"):
+        """Create a timestamped backup of current app state"""
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        backup_name = f"{description}_{timestamp}"
+        
+        # Backup main files
+        files_to_backup = [
+            "streamlit_app.py",
+            ".streamlit/secrets.toml",
+            "requirements.txt"
+        ]
+        
+        backup_path = self.backup_dir / backup_name
+        backup_path.mkdir(exist_ok=True)
+        
+        for file_path in files_to_backup:
+            if os.path.exists(file_path):
+                subprocess.run(["cp", file_path, str(backup_path / os.path.basename(file_path))])
+        
+        logger.info(f"Backup created: {backup_name}")
+        return backup_name
+    
+    def restore_backup(self, backup_name: str):
+        """Restore from a backup"""
+        backup_path = self.backup_dir / backup_name
+        
+        if not backup_path.exists():
+            logger.error(f"Backup {backup_name} not found")
+            return False
+        
+        # Restore files
+        files_to_restore = [
+            "streamlit_app.py",
+            ".streamlit/secrets.toml", 
+            "requirements.txt"
+        ]
+        
+        for file_path in files_to_restore:
+            backup_file = backup_path / os.path.basename(file_path)
+            if backup_file.exists():
+                subprocess.run(["cp", str(backup_file), file_path])
+        
+        logger.info(f"Restored from backup: {backup_name}")
+        return True
+    
+    def test_app_startup(self) -> bool:
+        """Test if the app starts without errors"""
+        try:
+            # Check if app is already running
+            response = requests.get(self.app_url, timeout=5)
+            if response.status_code == 200:
+                logger.info("✅ App is running and accessible")
+                return True
+            else:
+                logger.error(f"❌ App returned status code: {response.status_code}")
+                return False
+        except requests.exceptions.RequestException as e:
+            logger.error(f"❌ App startup test failed: {e}")
+            return False
+    
+    def test_ui_elements(self) -> Dict[str, bool]:
+        """Test key UI elements are present"""
+        results = {}
+        try:
+            response = requests.get(self.app_url, timeout=10)
+            content = response.text.lower()
+            
+            # Test for key UI elements
+            ui_tests = {
+                "title_present": "care count" in content,
+                "signin_form": "sign in" in content or "email" in content,
+                "camera_input": "camera" in content or "webcam" in content,
+                "file_upload": "upload" in content or "file" in content,
+                "visit_management": "visit" in content,
+                "item_logging": "item" in content,
+                "css_styling": "style" in content or "css" in content
+            }
+            
+            for test_name, result in ui_tests.items():
+                results[test_name] = result
+                status = "✅" if result else "❌"
+                logger.info(f"{status} {test_name}: {result}")
+            
+            return results
+            
+        except Exception as e:
+            logger.error(f"❌ UI elements test failed: {e}")
+            return {}
+    
+    def test_responsive_design(self) -> bool:
+        """Test if the app has responsive design elements"""
+        try:
+            response = requests.get(self.app_url, timeout=10)
+            content = response.text
+            
+            # Check for responsive design indicators
+            responsive_indicators = [
+                "container" in content,
+                "column" in content,
+                "responsive" in content,
+                "mobile" in content
+            ]
+            
+            responsive_score = sum(responsive_indicators) / len(responsive_indicators)
+            is_responsive = responsive_score >= 0.5
+            
+            logger.info(f"📱 Responsive design score: {responsive_score:.2f} ({'✅' if is_responsive else '❌'})")
+            return is_responsive
+            
+        except Exception as e:
+            logger.error(f"❌ Responsive design test failed: {e}")
+            return False
+    
+    def test_performance(self) -> Dict[str, float]:
+        """Test app performance metrics"""
+        try:
+            start_time = time.time()
+            response = requests.get(self.app_url, timeout=30)
+            load_time = time.time() - start_time
+            
+            results = {
+                "load_time": load_time,
+                "status_code": response.status_code,
+                "content_size": len(response.content)
+            }
+            
+            logger.info(f"⚡ Load time: {load_time:.2f}s")
+            logger.info(f"📊 Content size: {len(response.content)} bytes")
+            
+            return results
+            
+        except Exception as e:
+            logger.error(f"❌ Performance test failed: {e}")
+            return {}
+    
+    def run_all_tests(self) -> Dict[str, Any]:
+        """Run all tests and return comprehensive results"""
+        logger.info("🧪 Starting comprehensive app testing...")
+        
+        # Create backup before testing
+        backup_name = self.create_backup("pre_test_backup")
+        
+        test_results = {
+            "timestamp": datetime.now().isoformat(),
+            "backup_created": backup_name,
+            "startup_test": self.test_app_startup(),
+            "ui_elements": self.test_ui_elements(),
+            "responsive_design": self.test_responsive_design(),
+            "performance": self.test_performance()
+        }
+        
+        # Calculate overall score
+        ui_score = sum(test_results["ui_elements"].values()) / len(test_results["ui_elements"]) if test_results["ui_elements"] else 0
+        overall_score = (
+            (1 if test_results["startup_test"] else 0) +
+            ui_score +
+            (1 if test_results["responsive_design"] else 0)
+        ) / 3
+        
+        test_results["overall_score"] = overall_score
+        test_results["status"] = "PASS" if overall_score >= 0.8 else "FAIL"
+        
+        logger.info(f"🎯 Overall test score: {overall_score:.2f} ({test_results['status']})")
+        
+        return test_results
+
+def main():
+    """Main testing function"""
+    tester = CareCountTester()
+    
+    if len(sys.argv) > 1:
+        command = sys.argv[1]
+        
+        if command == "backup":
+            description = sys.argv[2] if len(sys.argv) > 2 else "manual_backup"
+            tester.create_backup(description)
+        elif command == "restore":
+            if len(sys.argv) > 2:
+                tester.restore_backup(sys.argv[2])
+            else:
+                print("Usage: python test_app.py restore <backup_name>")
+        elif command == "test":
+            results = tester.run_all_tests()
+            print(f"\n📋 Test Results Summary:")
+            print(f"Status: {results['status']}")
+            print(f"Score: {results['overall_score']:.2f}")
+            print(f"Backup: {results['backup_created']}")
+        else:
+            print("Available commands: backup, restore, test")
+    else:
+        # Run all tests by default
+        results = tester.run_all_tests()
+        print(f"\n📋 Test Results Summary:")
+        print(f"Status: {results['status']}")
+        print(f"Score: {results['overall_score']:.2f}")
+        print(f"Backup: {results['backup_created']}")
+
+if __name__ == "__main__":
+    main()

backups/pre_modern_deployment_20250923_203628/ui_improvements.py

@@ -0,0 +1,518 @@
+"""
+Care Count UI/UX Improvements Module
+Industry-standard UI components and styling
+"""
+
+import streamlit as st
+from typing import Dict, Any, Optional
+import base64
+from pathlib import Path
+
+class ModernUIComponents:
+    """Modern UI components for Care Count app"""
+    
+    @staticmethod
+    def get_modern_css() -> str:
+        """Return modern, industry-standard CSS"""
+        return """
+        <style>
+        /* Modern Design System - Laurier University Inspired */
+        :root {
+            /* Color Palette - Laurier University Theme */
+            --primary-purple: #6b46c1;  /* Laurier purple - more vibrant */
+            --primary-gold: #fbbf24;    /* Laurier gold - warmer tone */
+            --primary-dark: #1e1b4b;    /* Deep purple background */
+            --secondary-dark: #312e81;  /* Slightly lighter purple */
+            --accent-blue: #3b82f6;
+            --accent-green: #10b981;
+            --accent-red: #ef4444;
+            --accent-orange: #f59e0b;
+            
+            /* Neutral Colors */
+            --gray-50: #f9fafb;
+            --gray-100: #f3f4f6;
+            --gray-200: #e5e7eb;
+            --gray-300: #d1d5db;
+            --gray-400: #9ca3af;
+            --gray-500: #6b7280;
+            --gray-600: #4b5563;
+            --gray-700: #374151;
+            --gray-800: #1f2937;
+            --gray-900: #111827;
+            
+            /* Typography */
+            --font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            --font-size-xs: 0.75rem;
+            --font-size-sm: 0.875rem;
+            --font-size-base: 1rem;
+            --font-size-lg: 1.125rem;
+            --font-size-xl: 1.25rem;
+            --font-size-2xl: 1.5rem;
+            --font-size-3xl: 1.875rem;
+            
+            /* Spacing */
+            --space-1: 0.25rem;
+            --space-2: 0.5rem;
+            --space-3: 0.75rem;
+            --space-4: 1rem;
+            --space-5: 1.25rem;
+            --space-6: 1.5rem;
+            --space-8: 2rem;
+            --space-10: 2.5rem;
+            --space-12: 3rem;
+            
+            /* Border Radius */
+            --radius-sm: 0.375rem;
+            --radius-md: 0.5rem;
+            --radius-lg: 0.75rem;
+            --radius-xl: 1rem;
+            --radius-2xl: 1.5rem;
+            
+            /* Shadows */
+            --shadow-sm: 0 1px 2px 0 rgb(0 0 0 / 0.05);
+            --shadow-md: 0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1);
+            --shadow-lg: 0 10px 15px -3px rgb(0 0 0 / 0.1), 0 4px 6px -4px rgb(0 0 0 / 0.1);
+            --shadow-xl: 0 20px 25px -5px rgb(0 0 0 / 0.1), 0 8px 10px -6px rgb(0 0 0 / 0.1);
+        }
+        
+        /* Global Styles */
+        * {
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: var(--font-family);
+            background: var(--gray-50);
+            color: var(--gray-800);
+            line-height: 1.6;
+        }
+        
+        /* Streamlit Overrides */
+        .main .block-container {
+            padding: var(--space-6) var(--space-4);
+            max-width: 1200px;
+            background: var(--gray-50);
+        }
+        
+        .stApp {
+            background: var(--gray-50);
+        }
+        
+        /* Typography */
+        h1, h2, h3, h4, h5, h6 {
+            font-weight: 700;
+            letter-spacing: -0.025em;
+            color: var(--gray-800);
+        }
+        
+        h1 {
+            font-size: var(--font-size-3xl);
+            margin-bottom: var(--space-6);
+        }
+        
+        h2 {
+            font-size: var(--font-size-2xl);
+            margin-bottom: var(--space-4);
+        }
+        
+        h3 {
+            font-size: var(--font-size-xl);
+            margin-bottom: var(--space-3);
+        }
+        
+        /* Modern Cards - Laurier Style */
+        .modern-card {
+            background: white;
+            border: 1px solid var(--gray-200);
+            border-radius: var(--radius-xl);
+            padding: var(--space-6);
+            margin-bottom: var(--space-4);
+            box-shadow: var(--shadow-md);
+            transition: all 0.2s ease;
+            color: var(--gray-800);
+        }
+        
+        .modern-card:hover {
+            border-color: var(--primary-purple);
+            box-shadow: var(--shadow-lg);
+            transform: translateY(-2px);
+        }
+        
+        /* Status Cards */
+        .status-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: var(--space-4);
+            margin-bottom: var(--space-6);
+        }
+        
+        .status-card {
+            background: white;
+            border: 1px solid var(--gray-200);
+            border-radius: var(--radius-lg);
+            padding: var(--space-5);
+            text-align: center;
+            transition: all 0.2s ease;
+            box-shadow: var(--shadow-sm);
+        }
+        
+        .status-card:hover {
+            transform: translateY(-2px);
+            box-shadow: var(--shadow-md);
+            border-color: var(--primary-purple);
+        }
+        
+        .status-card h4 {
+            margin: 0 0 var(--space-2) 0;
+            font-size: var(--font-size-sm);
+            color: var(--gray-600);
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+            font-weight: 600;
+        }
+        
+        .status-card .value {
+            font-size: var(--font-size-2xl);
+            font-weight: 800;
+            color: var(--primary-purple);
+            margin: 0;
+        }
+        
+        .status-card .subtitle {
+            font-size: var(--font-size-xs);
+            color: var(--gray-500);
+            margin: var(--space-1) 0 0 0;
+        }
+        
+        /* Modern Buttons */
+        .modern-btn {
+            background: var(--primary-purple);
+            color: white;
+            border: none;
+            border-radius: var(--radius-md);
+            padding: var(--space-3) var(--space-6);
+            font-weight: 600;
+            font-size: var(--font-size-sm);
+            cursor: pointer;
+            transition: all 0.2s ease;
+            box-shadow: var(--shadow-sm);
+        }
+        
+        .modern-btn:hover {
+            background: #5b21b6;
+            transform: translateY(-1px);
+            box-shadow: var(--shadow-md);
+        }
+        
+        .modern-btn:active {
+            transform: translateY(0);
+        }
+        
+        .modern-btn-secondary {
+            background: var(--gray-700);
+            color: var(--gray-100);
+        }
+        
+        .modern-btn-secondary:hover {
+            background: var(--gray-600);
+        }
+        
+        .modern-btn-success {
+            background: var(--accent-green);
+        }
+        
+        .modern-btn-success:hover {
+            background: #059669;
+        }
+        
+        .modern-btn-danger {
+            background: var(--accent-red);
+        }
+        
+        .modern-btn-danger:hover {
+            background: #dc2626;
+        }
+        
+        /* Form Elements */
+        .modern-input {
+            background: white;
+            border: 1px solid var(--gray-300);
+            border-radius: var(--radius-md);
+            padding: var(--space-3);
+            color: var(--gray-800);
+            font-size: var(--font-size-sm);
+            transition: all 0.2s ease;
+        }
+        
+        .modern-input:focus {
+            outline: none;
+            border-color: var(--primary-purple);
+            box-shadow: 0 0 0 3px rgb(107 70 193 / 0.1);
+        }
+        
+        /* Hero Section - Laurier Style */
+        .hero-section {
+            background: var(--primary-purple);
+            border-radius: var(--radius-2xl);
+            padding: var(--space-10);
+            margin-bottom: var(--space-8);
+            text-align: left;
+            color: white;
+            box-shadow: var(--shadow-xl);
+            position: relative;
+            overflow: hidden;
+        }
+        
+        .hero-section::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            right: 0;
+            width: 40%;
+            height: 100%;
+            background: linear-gradient(135deg, rgba(255,255,255,0.1) 0%, rgba(255,255,255,0.05) 100%);
+            border-radius: 0 var(--radius-2xl) var(--radius-2xl) 0;
+        }
+        
+        .hero-section h1 {
+            color: white;
+            margin-bottom: var(--space-4);
+        }
+        
+        .hero-section p {
+            font-size: var(--font-size-lg);
+            opacity: 0.9;
+            margin: 0;
+        }
+        
+        /* Progress Indicators */
+        .progress-bar {
+            background: var(--gray-700);
+            border-radius: var(--radius-lg);
+            height: 8px;
+            overflow: hidden;
+            margin: var(--space-2) 0;
+        }
+        
+        .progress-fill {
+            background: linear-gradient(90deg, var(--primary-purple), var(--primary-gold));
+            height: 100%;
+            transition: width 0.3s ease;
+        }
+        
+        /* Badges */
+        .badge {
+            display: inline-block;
+            padding: var(--space-1) var(--space-2);
+            border-radius: var(--radius-sm);
+            font-size: var(--font-size-xs);
+            font-weight: 600;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+        }
+        
+        .badge-success {
+            background: var(--accent-green);
+            color: white;
+        }
+        
+        .badge-warning {
+            background: var(--accent-orange);
+            color: white;
+        }
+        
+        .badge-danger {
+            background: var(--accent-red);
+            color: white;
+        }
+        
+        .badge-info {
+            background: var(--accent-blue);
+            color: white;
+        }
+        
+        /* Responsive Design */
+        @media (max-width: 768px) {
+            .main .block-container {
+                padding: var(--space-4) var(--space-2);
+            }
+            
+            .status-grid {
+                grid-template-columns: 1fr;
+            }
+            
+            .hero-section {
+                padding: var(--space-6);
+            }
+            
+            h1 {
+                font-size: var(--font-size-2xl);
+            }
+        }
+        
+        /* Loading States */
+        .loading {
+            display: inline-block;
+            width: 20px;
+            height: 20px;
+            border: 3px solid var(--gray-600);
+            border-radius: 50%;
+            border-top-color: var(--primary-purple);
+            animation: spin 1s ease-in-out infinite;
+        }
+        
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+        
+        /* Animations */
+        .fade-in {
+            animation: fadeIn 0.5s ease-in;
+        }
+        
+        @keyframes fadeIn {
+            from { opacity: 0; transform: translateY(20px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+        
+        .slide-in {
+            animation: slideIn 0.3s ease-out;
+        }
+        
+        @keyframes slideIn {
+            from { transform: translateX(-100%); }
+            to { transform: translateX(0); }
+        }
+        
+        /* Accessibility */
+        .sr-only {
+            position: absolute;
+            width: 1px;
+            height: 1px;
+            padding: 0;
+            margin: -1px;
+            overflow: hidden;
+            clip: rect(0, 0, 0, 0);
+            white-space: nowrap;
+            border: 0;
+        }
+        
+        /* Focus states for accessibility */
+        button:focus,
+        input:focus,
+        select:focus,
+        textarea:focus {
+            outline: 2px solid var(--primary-purple);
+            outline-offset: 2px;
+        }
+        </style>
+        """
+    
+    @staticmethod
+    def create_hero_section(title: str, subtitle: str, user_email: str = None) -> str:
+        """Create a Laurier-style hero section"""
+        if user_email:
+            return f"""
+            <div class="hero-section fade-in">
+                <div style="position: relative; z-index: 2;">
+                    <h1 style="font-size: 2.5rem; margin-bottom: var(--space-4); color: white;">💜💛 {title}</h1>
+                    <p style="font-size: 1.25rem; margin-bottom: var(--space-6); color: white; opacity: 0.9;">{subtitle}</p>
+                    <div style="margin-top: var(--space-6); padding: var(--space-5); background: rgba(255,255,255,0.15); border-radius: var(--radius-lg); backdrop-filter: blur(10px);">
+                        <div style="font-size: var(--font-size-sm); opacity: 0.8; color: white;">Welcome,</div>
+                        <div style="font-weight: 800; font-size: var(--font-size-xl); margin: var(--space-2) 0; color: white;">{user_email}</div>
+                        <div style="font-size: var(--font-size-sm); opacity: 0.8; color: white;">Thank you for showing up for the community today. 💜💛</div>
+                    </div>
+                </div>
+            </div>
+            """
+        else:
+            return f"""
+            <div class="hero-section fade-in">
+                <div style="position: relative; z-index: 2;">
+                    <h1 style="font-size: 2.5rem; margin-bottom: var(--space-4); color: white;">💜💛 {title}</h1>
+                    <p style="font-size: 1.25rem; color: white; opacity: 0.9;">{subtitle}</p>
+                </div>
+            </div>
+            """
+    
+    @staticmethod
+    def create_status_cards(data: Dict[str, Any]) -> str:
+        """Create modern status cards"""
+        cards_html = '<div class="status-grid">'
+        
+        for key, value in data.items():
+            if key == "shift_active":
+                cards_html += f"""
+                <div class="status-card slide-in">
+                    <h4>Shift Active</h4>
+                    <div class="value">{value}</div>
+                    <div class="subtitle">since you signed in</div>
+                </div>
+                """
+            elif key == "items_today":
+                cards_html += f"""
+                <div class="status-card slide-in">
+                    <h4>Items Logged Today</h4>
+                    <div class="value">{value}</div>
+                    <div class="subtitle">items processed</div>
+                </div>
+                """
+            elif key == "lifetime_hours":
+                cards_html += f"""
+                <div class="status-card slide-in">
+                    <h4>Lifetime Hours</h4>
+                    <div class="value">{value}</div>
+                    <div class="subtitle">volunteer hours</div>
+                </div>
+                """
+        
+        cards_html += '</div>'
+        return cards_html
+    
+    @staticmethod
+    def create_modern_form_section(title: str, description: str = None) -> str:
+        """Create a modern form section header"""
+        desc_html = f'<p style="color: var(--gray-400); margin-bottom: var(--space-4);">{description}</p>' if description else ''
+        return f"""
+        <div class="modern-card fade-in">
+            <h3>{title}</h3>
+            {desc_html}
+        """
+    
+    @staticmethod
+    def create_progress_indicator(current: int, total: int, label: str) -> str:
+        """Create a modern progress indicator"""
+        percentage = (current / total * 100) if total > 0 else 0
+        return f"""
+        <div style="margin: var(--space-4) 0;">
+            <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: var(--space-2);">
+                <span style="font-weight: 600; color: var(--gray-300);">{label}</span>
+                <span style="font-weight: 700; color: var(--primary-gold);">{current}/{total}</span>
+            </div>
+            <div class="progress-bar">
+                <div class="progress-fill" style="width: {percentage}%;"></div>
+            </div>
+        </div>
+        """
+    
+    @staticmethod
+    def create_badge(text: str, variant: str = "info") -> str:
+        """Create a modern badge"""
+        return f'<span class="badge badge-{variant}">{text}</span>'
+    
+    @staticmethod
+    def create_loading_spinner() -> str:
+        """Create a loading spinner"""
+        return '<div class="loading"></div>'
+
+def apply_modern_ui():
+    """Apply modern UI styling to the Streamlit app"""
+    st.markdown(ModernUIComponents.get_modern_css(), unsafe_allow_html=True)
+
+def create_modern_layout():
+    """Create a modern layout structure"""
+    return {
+        "container_style": "max-width: 1200px; margin: 0 auto;",
+        "sidebar_style": "background: var(--secondary-dark); border-right: 1px solid var(--gray-700);",
+        "main_style": "background: var(--primary-dark); padding: var(--space-6);"
+    }

backups/pre_modern_deployment_20250923_205210/backup_metadata.json

@@ -0,0 +1,35 @@
+{
+  "backup_name": "pre_modern_deployment_20250923_205210",
+  "timestamp": "20250923_205210",
+  "description": "pre_modern_deployment",
+  "files_backed_up": [
+    "streamlit_app.py",
+    "streamlit_app_modern.py",
+    ".streamlit/secrets.toml",
+    "requirements.txt",
+    "ui_improvements.py",
+    "test_app.py"
+  ],
+  "git_status": {
+    "modified_files": [
+      "M requirements.txt",
+      " M streamlit_app.py",
+      "?? .streamlit/",
+      "?? .venv/",
+      "?? COLOR_SCHEME_UPDATE.md",
+      "?? DEPLOYMENT_QUICK_REFERENCE.md",
+      "?? UI_IMPROVEMENTS_GUIDE.md",
+      "?? __pycache__/",
+      "?? backups/",
+      "?? care_count.log",
+      "?? deploy_modern.py",
+      "?? deployment.log",
+      "?? streamlit_app_backup_20250923_195853.py",
+      "?? streamlit_app_modern.py",
+      "?? test_app.py",
+      "?? test_results.log",
+      "?? ui_improvements.py"
+    ],
+    "return_code": 0
+  }
+}

backups/pre_modern_deployment_20250923_205210/requirements.txt

@@ -0,0 +1,9 @@
+streamlit>=1.33
+pandas>=2.1
+Pillow>=10.1
+supabase>=2.5
+huggingface_hub>=0.24.6
+requests>=2.31
+python-dotenv>=1.0.0
+pytz>=2023.3
+

backups/pre_modern_deployment_20250923_205210/secrets.toml

@@ -0,0 +1,15 @@
+# Supabase connection
+SUPABASE_URL = "https://oudjcqhyldpncjbxohsg.supabase.co"
+SUPABASE_KEY ="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im91ZGpjcWh5bGRwbmNqYnhvaHNnIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTUzMDgyNDQsImV4cCI6MjA3MDg4NDI0NH0.SYwTtCe3r7WOZ25CRggL-lBkvGPjKnQhY_dT4Kjv9Dg"
+
+# App settings
+APP_TZ = "America/Toronto"
+
+# Hugging Face
+HF_TOKEN = "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"
+
+# Optional VLM model provider
+PROVIDER = "nebius"
+GEMMA_MODEL = "google/gemma-3-27b-it"
+NEBIUS_API_KEY = "eyJhbGciOiJIUzI1NiIsImtpZCI6IlV6SXJWd1h0dnprLVRvdzlLZWstc0M1akptWXBvX1VaVkxUZlpnMDRlOFUiLCJ0eXAiOiJKV1QifQ.eyJzdWIiOiJnb29nbGUtb2F1dGgyfDEwMjk4MzMxNjQ1OTQzNjA5ODYxMyIsInNjb3BlIjoib3BlbmlkIG9mZmxpbmVfYWNjZXNzIiwiaXNzIjoiYXBpX2tleV9pc3N1ZXIiLCJhdWQiOlsiaHR0cHM6Ly9uZWJpdXMtaW5mZXJlbmNlLmV1LmF1dGgwLmNvbS9hcGkvdjIvIl0sImV4cCI6MTkxNTEzMTE3MiwidXVpZCI6IjJmOTUxZmM1LWEyNTgtNDg5OC1iNWI4LTkwZTljY2RkZjU2NSIsIm5hbWUiOiJjYXJlIGNvdW50IGFwcCIsImV4cGlyZXNfYXQiOiIyMDMwLTA5LTA4VDIwOjUyOjUyKzAwMDAifQ.awAHOieD93pCnYmFMgRQ64-i6yZdO0XvXczD4eS6xEI"
+NEBIUS_BASE_URL = "https://api.nebius.ai/v1"

backups/pre_modern_deployment_20250923_205210/streamlit_app.py

@@ -0,0 +1,890 @@
+# --- Care Count (Volunteers → Visits → Items) ---
+# Modern UI/UX with industry-standard design patterns
+# Enhanced version with improved user experience
+
+from __future__ import annotations
+
+import os, io, time, base64, re, uuid, json
+from datetime import datetime, timedelta
+from typing import Optional
+import logging
+
+import pytz
+import requests
+import pandas as pd
+import streamlit as st
+from PIL import Image, ImageOps, ImageEnhance
+from supabase import create_client, Client
+
+# Import our modern UI components
+from ui_improvements import ModernUIComponents, apply_modern_ui, create_modern_layout
+
+# ------------------------ Enhanced Logging ------------------------
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('care_count.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# ------------------------ App config ------------------------
+os.environ.setdefault("HOME", "/tmp")
+os.environ["STREAMLIT_BROWSER_GATHER_USAGE_STATS"] = "false"
+
+TZ             = os.getenv("APP_TZ", "America/Toronto")
+CUTOFF_HOUR    = int(os.getenv("CUTOFF_HOUR", "20"))   # 8pm local
+INACTIVITY_MIN = int(os.getenv("INACTIVITY_MIN", "30"))
+
+def local_now() -> datetime:
+    return datetime.now(pytz.timezone(TZ))
+
+# Enhanced page config with modern settings
+st.set_page_config(
+    page_title="Care Count - Volunteer Management",
+    page_icon="💜",
+    layout="wide",
+    initial_sidebar_state="expanded",
+    menu_items={
+        'Get Help': 'https://github.com/your-repo/care-count',
+        'Report a bug': "https://github.com/your-repo/care-count/issues",
+        'About': "# Care Count\nVolunteer management system for community impact tracking"
+    }
+)
+
+# Apply modern UI styling
+apply_modern_ui()
+
+# ------------------------ Enhanced Secrets Management ------------------------
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except Exception:
+    pass
+
+try:
+    _SECRETS = getattr(st, "secrets", {})
+except Exception:
+    _SECRETS = {}
+
+def _is_useful(val: Optional[str]) -> bool:
+    return val is not None and str(val).strip() != ""
+
+def get_secret(name: str, default: Optional[str] = None) -> Optional[str]:
+    """Enhanced secret management with logging"""
+    v = os.getenv(name)
+    if _is_useful(v):
+        logger.info(f"Secret {name} loaded from environment")
+        return v
+
+    try:
+        if hasattr(_SECRETS, "get"):
+            v = _SECRETS.get(name, default)
+            if _is_useful(v):
+                logger.info(f"Secret {name} loaded from Streamlit secrets")
+                return v
+    except Exception as e:
+        logger.warning(f"Failed to load secret {name} from Streamlit secrets: {e}")
+
+    return default
+
+def require_secret(name: str) -> str:
+    """Enhanced secret requirement with better error handling"""
+    v = get_secret(name, None)
+    if not _is_useful(v):
+        st.error(
+            f"🔐 **Configuration Error**\n\n"
+            f"Missing required configuration: `{name}`\n\n"
+            f"Please ensure this is set in your environment variables or `.streamlit/secrets.toml` file.\n\n"
+            f"For help, check the [documentation](https://github.com/your-repo/care-count#configuration)."
+        )
+        st.stop()
+    return str(v)
+
+# Required Supabase credentials
+SUPABASE_URL = require_secret("SUPABASE_URL")
+SUPABASE_KEY = require_secret("SUPABASE_KEY")
+
+# Initialize Supabase client with error handling
+try:
+sb: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+    logger.info("Supabase client initialized successfully")
+except Exception as e:
+    st.error(f"Failed to connect to Supabase: {e}")
+    logger.error(f"Supabase connection failed: {e}")
+    st.stop()
+
+# Optional provider/config
+PROVIDER         = (get_secret("PROVIDER", "nebius") or "nebius").strip().lower()
+GEMMA_MODEL      = (get_secret("GEMMA_MODEL", "google/gemma-3-27b-it") or "google/gemma-3-27b-it").strip()
+NEBIUS_API_KEY   = get_secret("NEBIUS_API_KEY")
+NEBIUS_BASE_URL  = get_secret("NEBIUS_BASE_URL", "https://api.nebius.ai/v1")
+FEATH_API_KEY    = get_secret("FEATHERLESS_API_KEY")
+FEATH_BASE_URL   = get_secret("FEATHERLESS_BASE_URL", "https://api.featherless.ai/v1")
+
+# ------------------------ Enhanced Event Logging ------------------------
+def log_event(action: str, actor: Optional[str], details: dict, level: str = "info"):
+    """Enhanced event logging with multiple levels"""
+    log_data = {
+        "timestamp": datetime.utcnow().isoformat(),
+        "action": action,
+        "actor_email": actor,
+        "details": json.dumps(details) if isinstance(details, dict) else str(details)
+    }
+    
+    # Log to file
+    if level == "error":
+        logger.error(f"Event: {action} by {actor} - {details}")
+    elif level == "warning":
+        logger.warning(f"Event: {action} by {actor} - {details}")
+    else:
+        logger.info(f"Event: {action} by {actor} - {details}")
+    
+    # Log to database (without level field to avoid schema issues)
+    try:
+        sb.table("events").insert(log_data).execute()
+    except Exception as e:
+        logger.warning(f"Failed to log event to database (continuing): {e}")
+
+# ------------------------ Modern Authentication UI ------------------------
+def auth_block() -> tuple[bool, Optional[str]]:
+    """Enhanced authentication with modern UI"""
+    if "auth_email" not in st.session_state:
+        st.session_state["auth_email"] = None
+    if "user_email" in st.session_state:
+        return True, st.session_state["user_email"]
+
+    # Modern hero section for login
+    st.markdown(ModernUIComponents.create_hero_section(
+        "Care Count",
+        "Thanks for showing up for the community today. Snap items, keep visits tidy, and help us understand the impact of your time."
+    ), unsafe_allow_html=True)
+
+    # Modern login form
+    with st.container():
+        st.markdown('<div class="modern-card">', unsafe_allow_html=True)
+        st.subheader("🔐 Sign In")
+        st.markdown("Enter your email to receive a secure login code.")
+        
+        with st.form("otp_request", clear_on_submit=False):
+            email = st.text_input(
+                "Email Address", 
+                value=st.session_state.get("auth_email") or "", 
+                placeholder="your.email@example.com",
+                help="Enter your email address to receive a secure 6-digit login code. This code will be sent to your email and is valid for 10 minutes."
+            )
+            
+            col1, col2, col3 = st.columns([1, 2, 1])
+            with col2:
+                send = st.form_submit_button("📧 Send Login Code", use_container_width=True)
+            
+        if send:
+            if not email or "@" not in email:
+                    st.error("Please enter a valid email address.")
+            else:
+                try:
+                        with st.spinner("Sending login code..."):
+                    sb.auth.sign_in_with_otp({"email": email, "shouldCreateUser": True})
+                    st.session_state["auth_email"] = email
+                            st.success("✅ Login code sent! Check your email.")
+                            log_event("otp_requested", email, {"method": "email"})
+                except Exception as e:
+                        st.error(f"❌ Could not send code: {e}")
+                        log_event("otp_failed", email, {"error": str(e)}, "error")
+
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    # OTP verification form
+    if st.session_state.get("auth_email"):
+        with st.container():
+            st.markdown('<div class="modern-card">', unsafe_allow_html=True)
+            st.subheader("🔢 Verify Code")
+            st.markdown(f"Enter the 6-digit code sent to **{st.session_state['auth_email']}**")
+            
+            with st.form("otp_verify", clear_on_submit=True):
+                code = st.text_input(
+                    "Verification Code", 
+                    max_chars=6,
+                    placeholder="123456",
+                    help="Enter the 6-digit verification code that was sent to your email. Check your spam folder if you don't see it in your inbox."
+                )
+                
+                col1, col2, col3 = st.columns([1, 2, 1])
+                with col2:
+                    ok = st.form_submit_button("✅ Verify & Start Shift", use_container_width=True)
+                
+            if ok:
+                    if len(code) != 6 or not code.isdigit():
+                        st.error("Please enter a valid 6-digit code.")
+                    else:
+                try:
+                            with st.spinner("Verifying code..."):
+                    res = sb.auth.verify_otp({"email": st.session_state["auth_email"], "token": code, "type": "email"})
+                    if res and res.user:
+                        email = st.session_state["auth_email"]
+                                    
+                                    # Enhanced volunteer upsert
+                                    volunteer_data = {
+                            "email": email,
+                            "last_login_at": datetime.utcnow().isoformat(),
+                            "shift_started_at": datetime.utcnow().isoformat(),
+                                        "shift_ended_at": None,
+                                        "login_count": 1  # Track login frequency
+                                    }
+                                    
+                                    sb.table("volunteers").upsert(volunteer_data, on_conflict="email").execute()
+                                    
+                        st.session_state["user_email"] = email
+                        st.session_state["shift_started"] = True
+                        st.session_state["last_activity_at"] = local_now()
+                                    
+                                    log_event("login_success", email, {"method": "otp"})
+                                    st.success("🎉 Welcome back! Your shift has started.")
+                                    st.balloons()
+                        return True, email
+                except Exception as e:
+                            st.error(f"❌ Verification failed: {e}")
+                            log_event("otp_verification_failed", st.session_state["auth_email"], {"error": str(e)}, "error")
+            
+            st.markdown('</div>', unsafe_allow_html=True)
+    
+    return False, None
+
+def end_shift(email: str, reason: str):
+    """Enhanced shift ending with better logging"""
+    try:
+        end_time = datetime.utcnow().isoformat()
+        sb.table("volunteers").update({"shift_ended_at": end_time}).eq("email", email).execute()
+        log_event("shift_end", email, {"reason": reason, "end_time": end_time})
+    except Exception as e:
+        logger.error(f"Failed to end shift for {email}: {e}")
+
+def guard_cutoff_and_idle(email: str):
+    """Enhanced session management with better UX"""
+    now = local_now()
+    last = st.session_state.get("last_activity_at")
+    
+    if last and (now - last).total_seconds() > INACTIVITY_MIN * 60:
+        end_shift(email, "inactivity")
+        st.session_state.clear()
+        st.warning("⏰ You were logged out due to inactivity. Thank you for volunteering today!")
+        st.stop()
+    
+    st.session_state["last_activity_at"] = now
+
+    cutoff = now.replace(hour=CUTOFF_HOUR, minute=0, second=0, microsecond=0)
+    if now >= cutoff:
+        end_shift(email, "cutoff_8pm")
+        st.session_state.clear()
+        st.info("🌅 We close the day at 8pm. Your shift has been ended. Thank you so much!")
+        st.stop()
+
+# ------------------------ Main App Flow ------------------------
+def main():
+    """Main application flow with modern UI"""
+    
+    # Authentication
+signed_in, user_email = auth_block()
+if not signed_in:
+    st.stop()
+    
+guard_cutoff_and_idle(user_email)
+
+    # Modern welcome section
+    st.markdown(ModernUIComponents.create_hero_section(
+        "Care Count Dashboard",
+        "Manage visits, track items, and make a difference in your community.",
+        user_email
+    ), unsafe_allow_html=True)
+
+    # Enhanced status cards
+    vrow = fetch_volunteer_row(user_email) or {}
+    shift_started_at = vrow.get("shift_started_at")
+    lifetime_hours = vrow.get("total_hours", 0)
+    
+    mins_active = 0
+    try:
+        if shift_started_at:
+            t0 = datetime.fromisoformat(str(shift_started_at).replace("Z","+00:00"))
+            mins_active = max(0, int((datetime.utcnow() - t0).total_seconds() // 60))
+    except Exception:
+        pass
+
+    status_data = {
+        "shift_active": f"{mins_active} min",
+        "items_today": items_today(user_email),
+        "lifetime_hours": f"{round(float(lifetime_hours), 1)} hrs" if isinstance(lifetime_hours, (int, float)) else "0.0 hrs"
+    }
+    
+    st.markdown(ModernUIComponents.create_status_cards(status_data), unsafe_allow_html=True)
+
+    # Modern sign-out button
+    col1, col2, col3 = st.columns([1, 1, 1])
+    with col2:
+        if st.button("🔒 Sign Out", use_container_width=True, type="secondary"):
+        end_shift(user_email, "manual")
+        st.session_state.clear()
+            st.success("✅ Signed out successfully. See you next time!")
+            st.rerun()
+
+    # Enhanced visit management section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "🪪 Visit Management",
+        "Start and manage student visits with unique tracking codes"
+    ), unsafe_allow_html=True)
+    
+    active_visit = st.session_state.get("active_visit")
+    
+    col1, col2, col3 = st.columns([1, 1, 1])
+    
+    with col1:
+        if not active_visit and st.button("🚀 Start New Visit", use_container_width=True, type="primary", help="Start a new student visit session. This will create a unique visit code for tracking items."):
+            try:
+                with st.spinner("Creating visit..."):
+                    payload = {
+                        "visit_code": fallback_visit_code(),
+                        "started_at": datetime.utcnow().isoformat(),
+                        "ended_at": None,
+                        "created_by": user_email
+                    }
+                    v = sb.table("visits").insert(payload).execute().data[0]
+                    if not v.get("visit_code"):
+                        v["visit_code"] = payload["visit_code"]
+                    st.session_state["active_visit"] = v
+                    st.success(f"✅ Visit #{v['id']} started")
+                    st.info(f"**Visit Code:** `{v['visit_code']}`")
+                    log_event("visit_start", user_email, {"visit_id": v["id"], "visit_code": v["visit_code"]})
+                    st.rerun()
+            except Exception as e:
+                st.error(f"❌ Could not start visit: {e}")
+                log_event("visit_start_failed", user_email, {"error": str(e)}, "error")
+
+    with col2:
+        if active_visit and st.button("🏁 End Visit", use_container_width=True, type="secondary", help="End the current student visit session. This will finalize the visit and prepare for the next student."):
+            try:
+                with st.spinner("Ending visit..."):
+                    sb.table("visits").update({"ended_at": datetime.utcnow().isoformat()}) \
+                      .eq("id", active_visit["id"]).execute()
+                    st.success("✅ Visit completed successfully")
+                    log_event("visit_end", user_email, {"visit_id": active_visit["id"]})
+                    st.session_state.pop("active_visit", None)
+                    st.rerun()
+            except Exception as e:
+                st.error(f"❌ Could not end visit: {e}")
+                log_event("visit_end_failed", user_email, {"error": str(e)}, "error")
+
+    with col3:
+        if st.session_state.get("active_visit"):
+            v = st.session_state["active_visit"]
+            st.info(f"**Active Visit:** #{v['id']}\n**Code:** {v.get('visit_code','')}")
+        else:
+            st.info("No active visit")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced item identification section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📸 Item Identification",
+        "Use AI-powered image recognition to identify items quickly and accurately"
+    ), unsafe_allow_html=True)
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("📷 Camera Capture")
+        cam = st.camera_input("Take a photo of the item", help="Use your device's camera to take a clear photo of the item. Make sure the item is well-lit and clearly visible in the frame.")
+    
+    with col2:
+        st.subheader("📁 File Upload")
+        up = st.file_uploader(
+            "Upload an image", 
+            type=["png","jpg","jpeg"],
+            help="Upload a photo of the item from your device. Supported formats: PNG, JPG, JPEG. Maximum file size: 200MB."
+        )
+
+    img_file = cam or up
+    if img_file:
+        try:
+            img = Image.open(img_file).convert("RGB")
+            st.image(img, use_container_width=True, caption="Captured Image")
+            
+            if st.button("🔍 Identify Item with AI", use_container_width=True, type="primary", help="Use AI to automatically identify the item in the image. This will analyze the photo and suggest an item name."):
+                with st.spinner("Analyzing image with AI..."):
+                    t0 = time.time()
+                    try:
+                        pre = preprocess_for_label(img)
+                        raw = gemma_item_name(_to_png_bytes(pre))
+                        processing_time = time.time() - t0
+                        
+                        norm = normalize_item_name(raw)
+                        
+                        if raw:
+                            st.success(f"🤖 **AI Detection:** {raw}")
+                        st.info(f"✨ **Normalized:** {norm or '(unknown)'} · ⏱️ {processing_time:.2f}s")
+                        
+                        st.session_state["scanned_item_name"] = norm or raw or ""
+                        st.session_state["last_activity_at"] = local_now()
+                        
+                        log_event("item_identified", user_email, {
+                            "raw_name": raw,
+                            "normalized_name": norm,
+                            "processing_time": processing_time
+                        })
+                        
+                    except Exception as e:
+                        st.error(f"❌ AI identification failed: {e}")
+                        log_event("ai_identification_failed", user_email, {"error": str(e)}, "error")
+        except Exception as e:
+            st.error(f"❌ Failed to process image: {e}")
+            log_event("image_processing_failed", user_email, {"error": str(e)}, "error")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced item logging section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📬 Item Logging",
+        "Log items to the current visit with detailed information"
+    ), unsafe_allow_html=True)
+    
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        item_name = st.text_input(
+            "Item Name", 
+            value=st.session_state.get("scanned_item_name",""),
+            placeholder="Enter item name or use AI detection above",
+            help="Enter the name of the item. You can type it manually or use the AI detection feature above to automatically identify it from a photo."
+        )
+    
+    with col2:
+        quantity = st.number_input(
+            "Quantity", 
+            min_value=1, 
+            max_value=9999, 
+            step=1, 
+            value=1,
+            help="Number of items"
+        )
+    
+    col3, col4 = st.columns(2)
+    
+    with col3:
+        category = st.text_input(
+            "Category (optional)", 
+            placeholder="e.g., Food, Hygiene, Clothing",
+            help="Item category for better organization"
+        )
+    
+    with col4:
+        unit = st.text_input(
+            "Unit (optional)", 
+            placeholder="e.g., 500 mL, 1 L, 250 g",
+            help="Unit of measurement"
+        )
+    
+    barcode = st.text_input(
+        "Barcode (optional)", 
+        placeholder="Scan or enter barcode",
+        help="Product barcode for inventory tracking"
+    )
+
+    save_disabled = not st.session_state.get("active_visit")
+    if st.button("✅ Save Item to Visit", disabled=save_disabled, use_container_width=True, type="primary", help="Save the item to the current visit. You must start a visit first before you can log items."):
+        v = st.session_state.get("active_visit")
+        if not v:
+            st.warning("⚠️ Please start a visit first before logging items.")
+        else:
+            name_clean = clean_text(item_name, 120)
+            if not name_clean:
+                st.warning("⚠️ Item name is required.")
+            else:
+                with st.spinner("Saving item..."):
+                    ts_iso = datetime.utcnow().isoformat()
+                    ingest_id = deterministic_ingest_id(int(v["id"]), user_email, name_clean, int(quantity), ts_iso)
+                    
+                    try:
+                        ok, msg = try_rpc_ingest(
+                            email=user_email, v_id=int(v["id"]), name=name_clean, qty=int(quantity),
+                            category=clean_text(category, 80), unit=clean_text(unit, 40),
+                            barcode=clean_text(barcode, 64), ts_iso=ts_iso, ingest_id=ingest_id
+                        )
+                        
+                        if ok:
+                            st.success("✅ Item logged successfully!")
+                            log_event("item_logged", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                        else:
+                            st.warning(f"⚠️ {msg}. Trying fallback method...")
+                            fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                                   clean_text(category,80), clean_text(unit,40),
+                                                   clean_text(barcode,64), ts_iso, ingest_id)
+                            st.success("✅ Item logged successfully (fallback method)!")
+                            log_event("item_logged_fallback", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                    except Exception as e:
+                        try:
+                            fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                                   clean_text(category,80), clean_text(unit,40),
+                                                   clean_text(barcode,64), ts_iso, ingest_id)
+                            st.success("✅ Item logged successfully (fallback method)!")
+                            log_event("item_logged_fallback", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                        except Exception as e2:
+                            st.error(f"❌ Failed to log item: {e2}")
+                            log_event("item_log_failed", user_email, {"error": str(e2)}, "error")
+                    
+                    st.session_state["last_activity_at"] = local_now()
+                    st.session_state["scanned_item_name"] = name_clean
+                    st.rerun()
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced visit items view
+    if st.session_state.get("active_visit"):
+        st.markdown(ModernUIComponents.create_modern_form_section(
+            "🧾 Current Visit Items",
+            "Review and manage items in the current visit"
+        ), unsafe_allow_html=True)
+        
+        rows = load_items_for_visit(int(st.session_state["active_visit"]["id"]))
+        if rows:
+            df = pd.DataFrame(rows)
+            
+            # Enhanced dataframe display
+            st.dataframe(
+                df, 
+                use_container_width=True,
+                hide_index=True,
+                column_config={
+                    "timestamp": st.column_config.DatetimeColumn("Time", format="MM/DD/YY HH:mm"),
+                    "item_name": st.column_config.TextColumn("Item Name", width="medium"),
+                    "qty": st.column_config.NumberColumn("Quantity", width="small"),
+                    "category": st.column_config.TextColumn("Category", width="small"),
+                    "unit": st.column_config.TextColumn("Unit", width="small")
+                }
+            )
+            
+            # Enhanced delete functionality
+            with st.expander("🗑️ Delete Item (if mis-logged)"):
+                if rows:
+                    item_options = {f"{r['item_name']} (Qty: {r['qty']})": r["id"] for r in rows if "id" in r}
+                    selected_item = st.selectbox("Select item to delete", list(item_options.keys()))
+                    
+                    if st.button("🗑️ Delete Selected Item", type="secondary"):
+                        item_id = item_options[selected_item]
+                        try:
+                            # Try both tables safely
+                            try:
+                                delete_item("visit_items_p", int(item_id))
+                            except Exception:
+                                delete_item("visit_items", int(item_id))
+                            
+                            st.success("✅ Item deleted successfully")
+                            log_event("item_deleted", user_email, {"item_id": item_id})
+                            st.rerun()
+                        except Exception as e:
+                            st.error(f"❌ Failed to delete item: {e}")
+                            log_event("item_delete_failed", user_email, {"error": str(e)}, "error")
+                else:
+                    st.info("No items to delete")
+        else:
+            st.info("📝 No items logged for this visit yet.")
+        
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced analytics section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📈 Today's Analytics",
+        "Real-time insights into today's volunteer activity"
+    ), unsafe_allow_html=True)
+    
+    try:
+        daily = sb.table("v_daily_activity").select("*").execute().data
+        today_str = local_now().strftime("%Y-%m-%d")
+        today = next((r for r in daily if str(r.get("day",""))[:10]==today_str), None)
+        
+        if today:
+            visits = int(today.get("visits", 0))
+            items = int(today.get("items", 0))
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                st.metric("Total Visits Today", visits, delta=None)
+            with col2:
+                st.metric("Total Items Processed", items, delta=None)
+            
+            # Progress indicator
+            if visits > 0:
+                st.markdown(ModernUIComponents.create_progress_indicator(
+                    items, visits * 10, "Items per Visit Target"
+                ), unsafe_allow_html=True)
+        else:
+            st.info("📊 Analytics data will appear here as activity increases.")
+            
+    except Exception as e:
+        st.info("📊 Analytics view will be available once the database view is set up.")
+        logger.warning(f"Analytics view not available: {e}")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced footer with helpful information
+    st.markdown("""
+    <div class="modern-card" style="margin-top: var(--space-8); text-align: center;">
+        <h4>💡 Quick Tips</h4>
+        <p style="color: var(--gray-400); margin: 0;">
+            When you're done, please <strong>End Visit</strong> and <strong>Sign out</strong>.<br>
+            We'll auto-sign you out after inactivity or at 8pm local time. 💜
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+
+# ------------------------ Helper Functions (Enhanced) ------------------------
+def fetch_volunteer_row(email: str) -> dict | None:
+    """Enhanced volunteer data fetching with error handling"""
+    try:
+        return sb.table("volunteers").select("*").eq("email", email).single().execute().data
+    except Exception as e:
+        logger.warning(f"Failed to fetch volunteer data for {email}: {e}")
+        return None
+
+def items_today(email: str) -> int:
+    """Enhanced item counting with better error handling"""
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        # Try partitioned table first
+        data = sb.table("visit_items_p").select("id,timestamp,volunteer") \
+                .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                .eq("volunteer", email).execute().data
+        return len(data or [])
+    except Exception:
+        try:
+            data = sb.table("visit_items").select("id,timestamp,volunteer") \
+                    .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                    .eq("volunteer", email).execute().data
+            return len(data or [])
+        except Exception as e:
+            logger.warning(f"Failed to count items for {email}: {e}")
+            return 0
+
+def fallback_visit_code() -> str:
+    """Enhanced visit code generation with better uniqueness"""
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        todays = sb.table("visits").select("id,started_at").gte("started_at", f"{day} 00:00:00") \
+                 .lte("started_at", f"{day} 23:59:59").execute().data or []
+        seq = len(todays) + 1
+except Exception:
+        seq = int(time.time()) % 1000
+    return f"V-{seq}-{local_now().strftime('%Y%m%d')}-{str(uuid.uuid4())[:6]}"
+
+def _to_png_bytes(img: Image.Image) -> bytes:
+    """Convert image to PNG bytes"""
+    b = io.BytesIO()
+    img.save(b, format="PNG")
+    return b.getvalue()
+
+def preprocess_for_label(img: Image.Image) -> Image.Image:
+    """Enhanced image preprocessing for better AI recognition"""
+    img = img.convert("RGB")
+    w, h = img.size
+    scale = 1024 / max(w, h) if max(w, h) > 1024 else 1.0
+    if scale < 1.0: 
+        img = img.resize((int(w * scale), int(h * scale)))
+    img = ImageOps.autocontrast(img, cutoff=2)
+    img = ImageEnhance.Brightness(img).enhance(1.06)
+    img = ImageEnhance.Contrast(img).enhance(1.05)
+    img = ImageEnhance.Sharpness(img).enhance(1.15)
+    return img
+
+def gemma_item_name(img_bytes: bytes) -> str:
+    """Enhanced AI item identification with better error handling"""
+    try:
+        if PROVIDER == "nebius":
+            if not NEBIUS_API_KEY: 
+                raise RuntimeError("NEBIUS_API_KEY missing")
+            return _openai_style_chat(NEBIUS_BASE_URL, NEBIUS_API_KEY, GEMMA_MODEL, img_bytes)
+        elif PROVIDER == "featherless":
+            if not FEATH_API_KEY: 
+                raise RuntimeError("FEATHERLESS_API_KEY missing")
+            return _openai_style_chat(FEATH_BASE_URL, FEATH_API_KEY, GEMMA_MODEL, img_bytes)
+        else:
+            raise RuntimeError(f"Unknown PROVIDER: {PROVIDER}")
+    except Exception as e:
+        logger.error(f"AI identification failed: {e}")
+        raise
+
+def _openai_style_chat(base_url: str, api_key: str, model_id: str, img_bytes: bytes) -> str:
+    """Enhanced API communication with better error handling"""
+    b64 = base64.b64encode(img_bytes).decode("utf-8")
+    url = f"{base_url.rstrip('/')}/chat/completions"
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    payload = {
+        "model": model_id,
+        "temperature": 0,
+        "messages": [
+            {"role": "system", "content": "You label item being held in the image for a food bank. Return ONLY the item name."},
+            {"role": "user", "content": [
+                {"type": "text", "text": "What is the name of the item in the picture? Return only the item name."},
+                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}}
+            ]}
+        ]
+    }
+    
+    try:
+    r = requests.post(url, json=payload, headers=headers, timeout=90)
+    if r.status_code != 200:
+        raise RuntimeError(f"LLM HTTP {r.status_code}: {r.text[:200]}")
+    data = r.json()
+    return (data["choices"][0]["message"]["content"] or "").strip()
+    except requests.exceptions.Timeout:
+        raise RuntimeError("AI service timeout - please try again")
+    except requests.exceptions.RequestException as e:
+        raise RuntimeError(f"AI service error: {e}")
+
+def normalize_item_name(s: str) -> str:
+    """Enhanced item name normalization"""
+    s = (s or "").strip()
+    if not s: 
+        return ""
+    
+    # Enhanced brand and type recognition
+BRANDS = {
+    "whiskas","tetley","kellogg's","kelloggs","campbell's","campbells","heinz",
+    "nestle","kraft","general mills","cheerios","oreo","oreos","pringles","lays","doritos",
+    "ice river","green bottle","great value","wheat thins","vegetable thins","raid"
+}
+GENERIC_TYPES = {
+    "water","toothpaste","deodorant","antiperspirant","soap","shampoo","conditioner",
+    "lotion","tea","coffee","cereal","pasta","rice","beans","sauce","salsa","cleaner",
+    "peanut butter","jam","jelly","tuna","chicken","beef","flour","sugar","salt","oil",
+    "crackers","cookies","soup","insect killer","spray"
+}
+    
+    low = re.sub(r"[®™]", "", s.lower())
+    for b in BRANDS: 
+        low = low.replace(b, "")
+    
+    chosen = None
+    for t in GENERIC_TYPES:
+        if t in low: 
+            chosen = t
+            break
+    
+    cleaned = " ".join(low.split())
+    return (chosen or cleaned.title())[:120]
+
+def clean_text(v: Optional[str], maxlen: int = 120) -> Optional[str]:
+    """Enhanced text cleaning"""
+    if not v: 
+        return None
+    v = re.sub(r"\s+", " ", v).strip()
+    return v[:maxlen] if v else None
+
+def deterministic_ingest_id(v_id: int, email: str, name: str, qty: int, ts_iso: str) -> str:
+    """Enhanced ID generation for data integrity"""
+    key = f"visit_items::{v_id}::{email}::{name}::{qty}::{ts_iso}"
+    return str(uuid.uuid5(uuid.NAMESPACE_URL, key))
+
+def try_rpc_ingest(email: str, v_id: int, name: str, qty: int,
+                   category: Optional[str], unit: Optional[str],
+                   barcode: Optional[str], ts_iso: str, ingest_id: str) -> tuple[bool,str]:
+    """Enhanced RPC ingestion with better error handling"""
+    try:
+        res = sb.rpc("safe_ingest_visit_item", {
+            "p_email": email,
+            "p_visit_id": v_id,
+            "p_item_name": name,
+            "p_qty": qty,
+            "p_category": category,
+            "p_unit": unit,
+            "p_barcode": barcode,
+            "p_ts": ts_iso,
+            "p_ingest_id": ingest_id
+        }).execute()
+        
+        rows = res.data if isinstance(res.data, list) else []
+        if rows:
+            r0 = rows[0]
+            ok = bool(r0.get("ok", False))
+            msg = str(r0.get("msg", ""))
+            return ok, msg or ("ok" if ok else "failed")
+        return True, "ok"
+    except Exception as e:
+        logger.warning(f"RPC ingest failed, using fallback: {e}")
+        raise e
+
+def fallback_direct_insert(email: str, v_id: int, name: str, qty: int,
+                           category: Optional[str], unit: Optional[str],
+                           barcode: Optional[str], ts_iso: str, ingest_id: str) -> None:
+    """Enhanced fallback insertion with better error handling"""
+    payload = {
+        "visit_id": v_id,
+        "timestamp": ts_iso,
+        "volunteer": email,
+        "item_name": name,
+        "category": category,
+        "unit": unit,
+        "qty": qty,
+        "barcode": barcode,
+        "weather_type": None,
+        "temp_c": None,
+        "ingest_id": ingest_id
+    }
+    
+    try:
+        sb.table("visit_items_p").insert(payload).execute()
+    except Exception:
+        # Legacy table fallback
+        payload.pop("ingest_id", None)
+        sb.table("visit_items").insert(payload).execute()
+
+def load_items_for_visit(visit_id: int) -> list[dict]:
+    """Enhanced item loading with better error handling"""
+    try:
+        return sb.table("visit_items_p").select("*").eq("visit_id", visit_id) \
+            .order("timestamp", desc=True).limit(500).execute().data or []
+    except Exception:
+        try:
+            return sb.table("visit_items").select("*").eq("visit_id", visit_id) \
+                .order("timestamp", desc=True).limit(500).execute().data or []
+        except Exception as e:
+            logger.warning(f"Failed to load items for visit {visit_id}: {e}")
+            return []
+
+def delete_item(table: str, item_id: int):
+    """Enhanced item deletion with better error handling"""
+    try:
+        sb.table(table).delete().eq("id", item_id).execute()
+    except Exception as e:
+        logger.error(f"Failed to delete item {item_id} from {table}: {e}")
+        raise e
+
+# ------------------------ App Configuration Display ------------------------
+st.sidebar.markdown("### ⚙️ Configuration")
+st.sidebar.info(f"""
+**Provider:** `{PROVIDER}`  
+**Model:** `{GEMMA_MODEL}`  
+**Timezone:** `{TZ}`  
+**Cutoff:** {CUTOFF_HOUR}:00 PM  
+**Inactivity:** {INACTIVITY_MIN} min
+""")
+
+# ------------------------ Main App Execution ------------------------
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        logger.error(f"Application error: {e}")
+        st.error(f"❌ Application error: {e}")
+        st.info("Please refresh the page or contact support if the issue persists.")

backups/pre_modern_deployment_20250923_205210/streamlit_app_modern.py

@@ -0,0 +1,891 @@
+# --- Care Count (Volunteers → Visits → Items) ---
+# Modern UI/UX with industry-standard design patterns
+# Enhanced version with improved user experience
+
+from __future__ import annotations
+
+import os, io, time, base64, re, uuid, json
+from datetime import datetime, timedelta
+from typing import Optional
+import logging
+
+import pytz
+import requests
+import pandas as pd
+import streamlit as st
+from PIL import Image, ImageOps, ImageEnhance
+from supabase import create_client, Client
+
+# Import our modern UI components
+from ui_improvements import ModernUIComponents, apply_modern_ui, create_modern_layout
+
+# ------------------------ Enhanced Logging ------------------------
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('care_count.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# ------------------------ App config ------------------------
+os.environ.setdefault("HOME", "/tmp")
+os.environ["STREAMLIT_BROWSER_GATHER_USAGE_STATS"] = "false"
+
+TZ             = os.getenv("APP_TZ", "America/Toronto")
+CUTOFF_HOUR    = int(os.getenv("CUTOFF_HOUR", "20"))   # 8pm local
+INACTIVITY_MIN = int(os.getenv("INACTIVITY_MIN", "30"))
+
+def local_now() -> datetime:
+    return datetime.now(pytz.timezone(TZ))
+
+# Enhanced page config with modern settings
+st.set_page_config(
+    page_title="Care Count - Volunteer Management",
+    page_icon="💜",
+    layout="wide",
+    initial_sidebar_state="expanded",
+    menu_items={
+        'Get Help': 'https://github.com/your-repo/care-count',
+        'Report a bug': "https://github.com/your-repo/care-count/issues",
+        'About': "# Care Count\nVolunteer management system for community impact tracking"
+    }
+)
+
+# Apply modern UI styling
+apply_modern_ui()
+
+# ------------------------ Enhanced Secrets Management ------------------------
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except Exception:
+    pass
+
+try:
+    _SECRETS = getattr(st, "secrets", {})
+except Exception:
+    _SECRETS = {}
+
+def _is_useful(val: Optional[str]) -> bool:
+    return val is not None and str(val).strip() != ""
+
+def get_secret(name: str, default: Optional[str] = None) -> Optional[str]:
+    """Enhanced secret management with logging"""
+    v = os.getenv(name)
+    if _is_useful(v):
+        logger.info(f"Secret {name} loaded from environment")
+        return v
+
+    try:
+        if hasattr(_SECRETS, "get"):
+            v = _SECRETS.get(name, default)
+            if _is_useful(v):
+                logger.info(f"Secret {name} loaded from Streamlit secrets")
+                return v
+    except Exception as e:
+        logger.warning(f"Failed to load secret {name} from Streamlit secrets: {e}")
+
+    return default
+
+def require_secret(name: str) -> str:
+    """Enhanced secret requirement with better error handling"""
+    v = get_secret(name, None)
+    if not _is_useful(v):
+        st.error(
+            f"🔐 **Configuration Error**\n\n"
+            f"Missing required configuration: `{name}`\n\n"
+            f"Please ensure this is set in your environment variables or `.streamlit/secrets.toml` file.\n\n"
+            f"For help, check the [documentation](https://github.com/your-repo/care-count#configuration)."
+        )
+        st.stop()
+    return str(v)
+
+# Required Supabase credentials
+SUPABASE_URL = require_secret("SUPABASE_URL")
+SUPABASE_KEY = require_secret("SUPABASE_KEY")
+
+# Initialize Supabase client with error handling
+try:
+    sb: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+    logger.info("Supabase client initialized successfully")
+except Exception as e:
+    st.error(f"Failed to connect to Supabase: {e}")
+    logger.error(f"Supabase connection failed: {e}")
+    st.stop()
+
+# Optional provider/config
+PROVIDER         = (get_secret("PROVIDER", "nebius") or "nebius").strip().lower()
+GEMMA_MODEL      = (get_secret("GEMMA_MODEL", "google/gemma-3-27b-it") or "google/gemma-3-27b-it").strip()
+NEBIUS_API_KEY   = get_secret("NEBIUS_API_KEY")
+NEBIUS_BASE_URL  = get_secret("NEBIUS_BASE_URL", "https://api.nebius.ai/v1")
+FEATH_API_KEY    = get_secret("FEATHERLESS_API_KEY")
+FEATH_BASE_URL   = get_secret("FEATHERLESS_BASE_URL", "https://api.featherless.ai/v1")
+
+# ------------------------ Enhanced Event Logging ------------------------
+def log_event(action: str, actor: Optional[str], details: dict, level: str = "info"):
+    """Enhanced event logging with multiple levels"""
+    log_data = {
+        "timestamp": datetime.utcnow().isoformat(),
+        "action": action,
+        "actor_email": actor,
+        "details": details,
+        "level": level
+    }
+    
+    # Log to file
+    if level == "error":
+        logger.error(f"Event: {action} by {actor} - {details}")
+    elif level == "warning":
+        logger.warning(f"Event: {action} by {actor} - {details}")
+    else:
+        logger.info(f"Event: {action} by {actor} - {details}")
+    
+    # Log to database
+    try:
+        sb.table("events").insert(log_data).execute()
+    except Exception as e:
+        logger.error(f"Failed to log event to database: {e}")
+
+# ------------------------ Modern Authentication UI ------------------------
+def auth_block() -> tuple[bool, Optional[str]]:
+    """Enhanced authentication with modern UI"""
+    if "auth_email" not in st.session_state:
+        st.session_state["auth_email"] = None
+    if "user_email" in st.session_state:
+        return True, st.session_state["user_email"]
+
+    # Modern hero section for login
+    st.markdown(ModernUIComponents.create_hero_section(
+        "Care Count",
+        "Thanks for showing up for the community today. Snap items, keep visits tidy, and help us understand the impact of your time."
+    ))
+
+    # Modern login form
+    with st.container():
+        st.markdown('<div class="modern-card">', unsafe_allow_html=True)
+        st.subheader("🔐 Sign In")
+        st.markdown("Enter your email to receive a secure login code.")
+        
+        with st.form("otp_request", clear_on_submit=False):
+            email = st.text_input(
+                "Email Address", 
+                value=st.session_state.get("auth_email") or "", 
+                placeholder="your.email@example.com",
+                help="We'll send you a secure 6-digit code"
+            )
+            
+            col1, col2, col3 = st.columns([1, 2, 1])
+            with col2:
+                send = st.form_submit_button("📧 Send Login Code", use_container_width=True)
+            
+            if send:
+                if not email or "@" not in email:
+                    st.error("Please enter a valid email address.")
+                else:
+                    try:
+                        with st.spinner("Sending login code..."):
+                            sb.auth.sign_in_with_otp({"email": email, "shouldCreateUser": True})
+                            st.session_state["auth_email"] = email
+                            st.success("✅ Login code sent! Check your email.")
+                            log_event("otp_requested", email, {"method": "email"})
+                    except Exception as e:
+                        st.error(f"❌ Could not send code: {e}")
+                        log_event("otp_failed", email, {"error": str(e)}, "error")
+
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    # OTP verification form
+    if st.session_state.get("auth_email"):
+        with st.container():
+            st.markdown('<div class="modern-card">', unsafe_allow_html=True)
+            st.subheader("🔢 Verify Code")
+            st.markdown(f"Enter the 6-digit code sent to **{st.session_state['auth_email']}**")
+            
+            with st.form("otp_verify", clear_on_submit=True):
+                code = st.text_input(
+                    "Verification Code", 
+                    max_chars=6,
+                    placeholder="123456",
+                    help="Enter the 6-digit code from your email"
+                )
+                
+                col1, col2, col3 = st.columns([1, 2, 1])
+                with col2:
+                    ok = st.form_submit_button("✅ Verify & Start Shift", use_container_width=True)
+                
+                if ok:
+                    if len(code) != 6 or not code.isdigit():
+                        st.error("Please enter a valid 6-digit code.")
+                    else:
+                        try:
+                            with st.spinner("Verifying code..."):
+                                res = sb.auth.verify_otp({"email": st.session_state["auth_email"], "token": code, "type": "email"})
+                                if res and res.user:
+                                    email = st.session_state["auth_email"]
+                                    
+                                    # Enhanced volunteer upsert
+                                    volunteer_data = {
+                                        "email": email,
+                                        "last_login_at": datetime.utcnow().isoformat(),
+                                        "shift_started_at": datetime.utcnow().isoformat(),
+                                        "shift_ended_at": None,
+                                        "login_count": 1  # Track login frequency
+                                    }
+                                    
+                                    sb.table("volunteers").upsert(volunteer_data, on_conflict="email").execute()
+                                    
+                                    st.session_state["user_email"] = email
+                                    st.session_state["shift_started"] = True
+                                    st.session_state["last_activity_at"] = local_now()
+                                    
+                                    log_event("login_success", email, {"method": "otp"})
+                                    st.success("🎉 Welcome back! Your shift has started.")
+                                    st.balloons()
+                                    return True, email
+                        except Exception as e:
+                            st.error(f"❌ Verification failed: {e}")
+                            log_event("otp_verification_failed", st.session_state["auth_email"], {"error": str(e)}, "error")
+            
+            st.markdown('</div>', unsafe_allow_html=True)
+    
+    return False, None
+
+def end_shift(email: str, reason: str):
+    """Enhanced shift ending with better logging"""
+    try:
+        end_time = datetime.utcnow().isoformat()
+        sb.table("volunteers").update({"shift_ended_at": end_time}).eq("email", email).execute()
+        log_event("shift_end", email, {"reason": reason, "end_time": end_time})
+    except Exception as e:
+        logger.error(f"Failed to end shift for {email}: {e}")
+
+def guard_cutoff_and_idle(email: str):
+    """Enhanced session management with better UX"""
+    now = local_now()
+    last = st.session_state.get("last_activity_at")
+    
+    if last and (now - last).total_seconds() > INACTIVITY_MIN * 60:
+        end_shift(email, "inactivity")
+        st.session_state.clear()
+        st.warning("⏰ You were logged out due to inactivity. Thank you for volunteering today!")
+        st.stop()
+    
+    st.session_state["last_activity_at"] = now
+
+    cutoff = now.replace(hour=CUTOFF_HOUR, minute=0, second=0, microsecond=0)
+    if now >= cutoff:
+        end_shift(email, "cutoff_8pm")
+        st.session_state.clear()
+        st.info("🌅 We close the day at 8pm. Your shift has been ended. Thank you so much!")
+        st.stop()
+
+# ------------------------ Main App Flow ------------------------
+def main():
+    """Main application flow with modern UI"""
+    
+    # Authentication
+    signed_in, user_email = auth_block()
+    if not signed_in:
+        st.stop()
+    
+    guard_cutoff_and_idle(user_email)
+
+    # Modern welcome section
+    st.markdown(ModernUIComponents.create_hero_section(
+        "Care Count Dashboard",
+        "Manage visits, track items, and make a difference in your community.",
+        user_email
+    ))
+
+    # Enhanced status cards
+    vrow = fetch_volunteer_row(user_email) or {}
+    shift_started_at = vrow.get("shift_started_at")
+    lifetime_hours = vrow.get("total_hours", 0)
+    
+    mins_active = 0
+    try:
+        if shift_started_at:
+            t0 = datetime.fromisoformat(str(shift_started_at).replace("Z","+00:00"))
+            mins_active = max(0, int((datetime.utcnow() - t0).total_seconds() // 60))
+    except Exception:
+        pass
+
+    status_data = {
+        "shift_active": f"{mins_active} min",
+        "items_today": items_today(user_email),
+        "lifetime_hours": f"{round(float(lifetime_hours), 1)} hrs" if isinstance(lifetime_hours, (int, float)) else "0.0 hrs"
+    }
+    
+    st.markdown(ModernUIComponents.create_status_cards(status_data), unsafe_allow_html=True)
+
+    # Modern sign-out button
+    col1, col2, col3 = st.columns([1, 1, 1])
+    with col2:
+        if st.button("🔒 Sign Out", use_container_width=True, type="secondary"):
+            end_shift(user_email, "manual")
+            st.session_state.clear()
+            st.success("✅ Signed out successfully. See you next time!")
+            st.rerun()
+
+    # Enhanced visit management section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "🪪 Visit Management",
+        "Start and manage student visits with unique tracking codes"
+    ), unsafe_allow_html=True)
+    
+    active_visit = st.session_state.get("active_visit")
+    
+    col1, col2, col3 = st.columns([1, 1, 1])
+    
+    with col1:
+        if not active_visit and st.button("🚀 Start New Visit", use_container_width=True, type="primary"):
+            try:
+                with st.spinner("Creating visit..."):
+                    payload = {
+                        "visit_code": fallback_visit_code(),
+                        "started_at": datetime.utcnow().isoformat(),
+                        "ended_at": None,
+                        "created_by": user_email
+                    }
+                    v = sb.table("visits").insert(payload).execute().data[0]
+                    if not v.get("visit_code"):
+                        v["visit_code"] = payload["visit_code"]
+                    st.session_state["active_visit"] = v
+                    st.success(f"✅ Visit #{v['id']} started")
+                    st.info(f"**Visit Code:** `{v['visit_code']}`")
+                    log_event("visit_start", user_email, {"visit_id": v["id"], "visit_code": v["visit_code"]})
+                    st.rerun()
+            except Exception as e:
+                st.error(f"❌ Could not start visit: {e}")
+                log_event("visit_start_failed", user_email, {"error": str(e)}, "error")
+
+    with col2:
+        if active_visit and st.button("🏁 End Visit", use_container_width=True, type="secondary"):
+            try:
+                with st.spinner("Ending visit..."):
+                    sb.table("visits").update({"ended_at": datetime.utcnow().isoformat()}) \
+                      .eq("id", active_visit["id"]).execute()
+                    st.success("✅ Visit completed successfully")
+                    log_event("visit_end", user_email, {"visit_id": active_visit["id"]})
+                    st.session_state.pop("active_visit", None)
+                    st.rerun()
+            except Exception as e:
+                st.error(f"❌ Could not end visit: {e}")
+                log_event("visit_end_failed", user_email, {"error": str(e)}, "error")
+
+    with col3:
+        if st.session_state.get("active_visit"):
+            v = st.session_state["active_visit"]
+            st.info(f"**Active Visit:** #{v['id']}\n**Code:** {v.get('visit_code','')}")
+        else:
+            st.info("No active visit")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced item identification section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📸 Item Identification",
+        "Use AI-powered image recognition to identify items quickly and accurately"
+    ), unsafe_allow_html=True)
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("📷 Camera Capture")
+        cam = st.camera_input("Take a photo of the item", help="Position the item clearly in the frame")
+    
+    with col2:
+        st.subheader("📁 File Upload")
+        up = st.file_uploader(
+            "Upload an image", 
+            type=["png","jpg","jpeg"],
+            help="Supported formats: PNG, JPG, JPEG"
+        )
+
+    img_file = cam or up
+    if img_file:
+        try:
+            img = Image.open(img_file).convert("RGB")
+            st.image(img, use_container_width=True, caption="Captured Image")
+            
+            if st.button("🔍 Identify Item with AI", use_container_width=True, type="primary"):
+                with st.spinner("Analyzing image with AI..."):
+                    t0 = time.time()
+                    try:
+                        pre = preprocess_for_label(img)
+                        raw = gemma_item_name(_to_png_bytes(pre))
+                        processing_time = time.time() - t0
+                        
+                        norm = normalize_item_name(raw)
+                        
+                        if raw:
+                            st.success(f"🤖 **AI Detection:** {raw}")
+                        st.info(f"✨ **Normalized:** {norm or '(unknown)'} · ⏱️ {processing_time:.2f}s")
+                        
+                        st.session_state["scanned_item_name"] = norm or raw or ""
+                        st.session_state["last_activity_at"] = local_now()
+                        
+                        log_event("item_identified", user_email, {
+                            "raw_name": raw,
+                            "normalized_name": norm,
+                            "processing_time": processing_time
+                        })
+                        
+                    except Exception as e:
+                        st.error(f"❌ AI identification failed: {e}")
+                        log_event("ai_identification_failed", user_email, {"error": str(e)}, "error")
+        except Exception as e:
+            st.error(f"❌ Failed to process image: {e}")
+            log_event("image_processing_failed", user_email, {"error": str(e)}, "error")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced item logging section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📬 Item Logging",
+        "Log items to the current visit with detailed information"
+    ), unsafe_allow_html=True)
+    
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        item_name = st.text_input(
+            "Item Name", 
+            value=st.session_state.get("scanned_item_name",""),
+            placeholder="Enter item name or use AI detection above",
+            help="Required field - item name for tracking"
+        )
+    
+    with col2:
+        quantity = st.number_input(
+            "Quantity", 
+            min_value=1, 
+            max_value=9999, 
+            step=1, 
+            value=1,
+            help="Number of items"
+        )
+    
+    col3, col4 = st.columns(2)
+    
+    with col3:
+        category = st.text_input(
+            "Category (optional)", 
+            placeholder="e.g., Food, Hygiene, Clothing",
+            help="Item category for better organization"
+        )
+    
+    with col4:
+        unit = st.text_input(
+            "Unit (optional)", 
+            placeholder="e.g., 500 mL, 1 L, 250 g",
+            help="Unit of measurement"
+        )
+    
+    barcode = st.text_input(
+        "Barcode (optional)", 
+        placeholder="Scan or enter barcode",
+        help="Product barcode for inventory tracking"
+    )
+
+    save_disabled = not st.session_state.get("active_visit")
+    if st.button("✅ Save Item to Visit", disabled=save_disabled, use_container_width=True, type="primary"):
+        v = st.session_state.get("active_visit")
+        if not v:
+            st.warning("⚠️ Please start a visit first before logging items.")
+        else:
+            name_clean = clean_text(item_name, 120)
+            if not name_clean:
+                st.warning("⚠️ Item name is required.")
+            else:
+                with st.spinner("Saving item..."):
+                    ts_iso = datetime.utcnow().isoformat()
+                    ingest_id = deterministic_ingest_id(int(v["id"]), user_email, name_clean, int(quantity), ts_iso)
+                    
+                    try:
+                        ok, msg = try_rpc_ingest(
+                            email=user_email, v_id=int(v["id"]), name=name_clean, qty=int(quantity),
+                            category=clean_text(category, 80), unit=clean_text(unit, 40),
+                            barcode=clean_text(barcode, 64), ts_iso=ts_iso, ingest_id=ingest_id
+                        )
+                        
+                        if ok:
+                            st.success("✅ Item logged successfully!")
+                            log_event("item_logged", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                        else:
+                            st.warning(f"⚠️ {msg}. Trying fallback method...")
+                            fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                                   clean_text(category,80), clean_text(unit,40),
+                                                   clean_text(barcode,64), ts_iso, ingest_id)
+                            st.success("✅ Item logged successfully (fallback method)!")
+                            log_event("item_logged_fallback", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                    except Exception as e:
+                        try:
+                            fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                                   clean_text(category,80), clean_text(unit,40),
+                                                   clean_text(barcode,64), ts_iso, ingest_id)
+                            st.success("✅ Item logged successfully (fallback method)!")
+                            log_event("item_logged_fallback", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                        except Exception as e2:
+                            st.error(f"❌ Failed to log item: {e2}")
+                            log_event("item_log_failed", user_email, {"error": str(e2)}, "error")
+                    
+                    st.session_state["last_activity_at"] = local_now()
+                    st.session_state["scanned_item_name"] = name_clean
+                    st.rerun()
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced visit items view
+    if st.session_state.get("active_visit"):
+        st.markdown(ModernUIComponents.create_modern_form_section(
+            "🧾 Current Visit Items",
+            "Review and manage items in the current visit"
+        ), unsafe_allow_html=True)
+        
+        rows = load_items_for_visit(int(st.session_state["active_visit"]["id"]))
+        if rows:
+            df = pd.DataFrame(rows)
+            
+            # Enhanced dataframe display
+            st.dataframe(
+                df, 
+                use_container_width=True,
+                hide_index=True,
+                column_config={
+                    "timestamp": st.column_config.DatetimeColumn("Time", format="MM/DD/YY HH:mm"),
+                    "item_name": st.column_config.TextColumn("Item Name", width="medium"),
+                    "qty": st.column_config.NumberColumn("Quantity", width="small"),
+                    "category": st.column_config.TextColumn("Category", width="small"),
+                    "unit": st.column_config.TextColumn("Unit", width="small")
+                }
+            )
+            
+            # Enhanced delete functionality
+            with st.expander("🗑️ Delete Item (if mis-logged)"):
+                if rows:
+                    item_options = {f"{r['item_name']} (Qty: {r['qty']})": r["id"] for r in rows if "id" in r}
+                    selected_item = st.selectbox("Select item to delete", list(item_options.keys()))
+                    
+                    if st.button("🗑️ Delete Selected Item", type="secondary"):
+                        item_id = item_options[selected_item]
+                        try:
+                            # Try both tables safely
+                            try:
+                                delete_item("visit_items_p", int(item_id))
+                            except Exception:
+                                delete_item("visit_items", int(item_id))
+                            
+                            st.success("✅ Item deleted successfully")
+                            log_event("item_deleted", user_email, {"item_id": item_id})
+                            st.rerun()
+                        except Exception as e:
+                            st.error(f"❌ Failed to delete item: {e}")
+                            log_event("item_delete_failed", user_email, {"error": str(e)}, "error")
+                else:
+                    st.info("No items to delete")
+        else:
+            st.info("📝 No items logged for this visit yet.")
+        
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced analytics section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📈 Today's Analytics",
+        "Real-time insights into today's volunteer activity"
+    ), unsafe_allow_html=True)
+    
+    try:
+        daily = sb.table("v_daily_activity").select("*").execute().data
+        today_str = local_now().strftime("%Y-%m-%d")
+        today = next((r for r in daily if str(r.get("day",""))[:10]==today_str), None)
+        
+        if today:
+            visits = int(today.get("visits", 0))
+            items = int(today.get("items", 0))
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                st.metric("Total Visits Today", visits, delta=None)
+            with col2:
+                st.metric("Total Items Processed", items, delta=None)
+            
+            # Progress indicator
+            if visits > 0:
+                st.markdown(ModernUIComponents.create_progress_indicator(
+                    items, visits * 10, "Items per Visit Target"
+                ), unsafe_allow_html=True)
+        else:
+            st.info("📊 Analytics data will appear here as activity increases.")
+            
+    except Exception as e:
+        st.info("📊 Analytics view will be available once the database view is set up.")
+        logger.warning(f"Analytics view not available: {e}")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced footer with helpful information
+    st.markdown("""
+    <div class="modern-card" style="margin-top: var(--space-8); text-align: center;">
+        <h4>💡 Quick Tips</h4>
+        <p style="color: var(--gray-400); margin: 0;">
+            When you're done, please <strong>End Visit</strong> and <strong>Sign out</strong>.<br>
+            We'll auto-sign you out after inactivity or at 8pm local time. 💜
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+
+# ------------------------ Helper Functions (Enhanced) ------------------------
+def fetch_volunteer_row(email: str) -> dict | None:
+    """Enhanced volunteer data fetching with error handling"""
+    try:
+        return sb.table("volunteers").select("*").eq("email", email).single().execute().data
+    except Exception as e:
+        logger.warning(f"Failed to fetch volunteer data for {email}: {e}")
+        return None
+
+def items_today(email: str) -> int:
+    """Enhanced item counting with better error handling"""
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        # Try partitioned table first
+        data = sb.table("visit_items_p").select("id,timestamp,volunteer") \
+                .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                .eq("volunteer", email).execute().data
+        return len(data or [])
+    except Exception:
+        try:
+            data = sb.table("visit_items").select("id,timestamp,volunteer") \
+                    .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                    .eq("volunteer", email).execute().data
+            return len(data or [])
+        except Exception as e:
+            logger.warning(f"Failed to count items for {email}: {e}")
+            return 0
+
+def fallback_visit_code() -> str:
+    """Enhanced visit code generation with better uniqueness"""
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        todays = sb.table("visits").select("id,started_at").gte("started_at", f"{day} 00:00:00") \
+                 .lte("started_at", f"{day} 23:59:59").execute().data or []
+        seq = len(todays) + 1
+    except Exception:
+        seq = int(time.time()) % 1000
+    return f"V-{seq}-{local_now().strftime('%Y%m%d')}-{str(uuid.uuid4())[:6]}"
+
+def _to_png_bytes(img: Image.Image) -> bytes:
+    """Convert image to PNG bytes"""
+    b = io.BytesIO()
+    img.save(b, format="PNG")
+    return b.getvalue()
+
+def preprocess_for_label(img: Image.Image) -> Image.Image:
+    """Enhanced image preprocessing for better AI recognition"""
+    img = img.convert("RGB")
+    w, h = img.size
+    scale = 1024 / max(w, h) if max(w, h) > 1024 else 1.0
+    if scale < 1.0: 
+        img = img.resize((int(w * scale), int(h * scale)))
+    img = ImageOps.autocontrast(img, cutoff=2)
+    img = ImageEnhance.Brightness(img).enhance(1.06)
+    img = ImageEnhance.Contrast(img).enhance(1.05)
+    img = ImageEnhance.Sharpness(img).enhance(1.15)
+    return img
+
+def gemma_item_name(img_bytes: bytes) -> str:
+    """Enhanced AI item identification with better error handling"""
+    try:
+        if PROVIDER == "nebius":
+            if not NEBIUS_API_KEY: 
+                raise RuntimeError("NEBIUS_API_KEY missing")
+            return _openai_style_chat(NEBIUS_BASE_URL, NEBIUS_API_KEY, GEMMA_MODEL, img_bytes)
+        elif PROVIDER == "featherless":
+            if not FEATH_API_KEY: 
+                raise RuntimeError("FEATHERLESS_API_KEY missing")
+            return _openai_style_chat(FEATH_BASE_URL, FEATH_API_KEY, GEMMA_MODEL, img_bytes)
+        else:
+            raise RuntimeError(f"Unknown PROVIDER: {PROVIDER}")
+    except Exception as e:
+        logger.error(f"AI identification failed: {e}")
+        raise
+
+def _openai_style_chat(base_url: str, api_key: str, model_id: str, img_bytes: bytes) -> str:
+    """Enhanced API communication with better error handling"""
+    b64 = base64.b64encode(img_bytes).decode("utf-8")
+    url = f"{base_url.rstrip('/')}/chat/completions"
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    payload = {
+        "model": model_id,
+        "temperature": 0,
+        "messages": [
+            {"role": "system", "content": "You label item being held in the image for a food bank. Return ONLY the item name."},
+            {"role": "user", "content": [
+                {"type": "text", "text": "What is the name of the item in the picture? Return only the item name."},
+                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}}
+            ]}
+        ]
+    }
+    
+    try:
+        r = requests.post(url, json=payload, headers=headers, timeout=90)
+        if r.status_code != 200:
+            raise RuntimeError(f"LLM HTTP {r.status_code}: {r.text[:200]}")
+        data = r.json()
+        return (data["choices"][0]["message"]["content"] or "").strip()
+    except requests.exceptions.Timeout:
+        raise RuntimeError("AI service timeout - please try again")
+    except requests.exceptions.RequestException as e:
+        raise RuntimeError(f"AI service error: {e}")
+
+def normalize_item_name(s: str) -> str:
+    """Enhanced item name normalization"""
+    s = (s or "").strip()
+    if not s: 
+        return ""
+    
+    # Enhanced brand and type recognition
+    BRANDS = {
+        "whiskas","tetley","kellogg's","kelloggs","campbell's","campbells","heinz",
+        "nestle","kraft","general mills","cheerios","oreo","oreos","pringles","lays","doritos",
+        "ice river","green bottle","great value","wheat thins","vegetable thins","raid"
+    }
+    GENERIC_TYPES = {
+        "water","toothpaste","deodorant","antiperspirant","soap","shampoo","conditioner",
+        "lotion","tea","coffee","cereal","pasta","rice","beans","sauce","salsa","cleaner",
+        "peanut butter","jam","jelly","tuna","chicken","beef","flour","sugar","salt","oil",
+        "crackers","cookies","soup","insect killer","spray"
+    }
+    
+    low = re.sub(r"[®™]", "", s.lower())
+    for b in BRANDS: 
+        low = low.replace(b, "")
+    
+    chosen = None
+    for t in GENERIC_TYPES:
+        if t in low: 
+            chosen = t
+            break
+    
+    cleaned = " ".join(low.split())
+    return (chosen or cleaned.title())[:120]
+
+def clean_text(v: Optional[str], maxlen: int = 120) -> Optional[str]:
+    """Enhanced text cleaning"""
+    if not v: 
+        return None
+    v = re.sub(r"\s+", " ", v).strip()
+    return v[:maxlen] if v else None
+
+def deterministic_ingest_id(v_id: int, email: str, name: str, qty: int, ts_iso: str) -> str:
+    """Enhanced ID generation for data integrity"""
+    key = f"visit_items::{v_id}::{email}::{name}::{qty}::{ts_iso}"
+    return str(uuid.uuid5(uuid.NAMESPACE_URL, key))
+
+def try_rpc_ingest(email: str, v_id: int, name: str, qty: int,
+                   category: Optional[str], unit: Optional[str],
+                   barcode: Optional[str], ts_iso: str, ingest_id: str) -> tuple[bool,str]:
+    """Enhanced RPC ingestion with better error handling"""
+    try:
+        res = sb.rpc("safe_ingest_visit_item", {
+            "p_email": email,
+            "p_visit_id": v_id,
+            "p_item_name": name,
+            "p_qty": qty,
+            "p_category": category,
+            "p_unit": unit,
+            "p_barcode": barcode,
+            "p_ts": ts_iso,
+            "p_ingest_id": ingest_id
+        }).execute()
+        
+        rows = res.data if isinstance(res.data, list) else []
+        if rows:
+            r0 = rows[0]
+            ok = bool(r0.get("ok", False))
+            msg = str(r0.get("msg", ""))
+            return ok, msg or ("ok" if ok else "failed")
+        return True, "ok"
+    except Exception as e:
+        logger.warning(f"RPC ingest failed, using fallback: {e}")
+        raise e
+
+def fallback_direct_insert(email: str, v_id: int, name: str, qty: int,
+                           category: Optional[str], unit: Optional[str],
+                           barcode: Optional[str], ts_iso: str, ingest_id: str) -> None:
+    """Enhanced fallback insertion with better error handling"""
+    payload = {
+        "visit_id": v_id,
+        "timestamp": ts_iso,
+        "volunteer": email,
+        "item_name": name,
+        "category": category,
+        "unit": unit,
+        "qty": qty,
+        "barcode": barcode,
+        "weather_type": None,
+        "temp_c": None,
+        "ingest_id": ingest_id
+    }
+    
+    try:
+        sb.table("visit_items_p").insert(payload).execute()
+    except Exception:
+        # Legacy table fallback
+        payload.pop("ingest_id", None)
+        sb.table("visit_items").insert(payload).execute()
+
+def load_items_for_visit(visit_id: int) -> list[dict]:
+    """Enhanced item loading with better error handling"""
+    try:
+        return sb.table("visit_items_p").select("*").eq("visit_id", visit_id) \
+            .order("timestamp", desc=True).limit(500).execute().data or []
+    except Exception:
+        try:
+            return sb.table("visit_items").select("*").eq("visit_id", visit_id) \
+                .order("timestamp", desc=True).limit(500).execute().data or []
+        except Exception as e:
+            logger.warning(f"Failed to load items for visit {visit_id}: {e}")
+            return []
+
+def delete_item(table: str, item_id: int):
+    """Enhanced item deletion with better error handling"""
+    try:
+        sb.table(table).delete().eq("id", item_id).execute()
+    except Exception as e:
+        logger.error(f"Failed to delete item {item_id} from {table}: {e}")
+        raise e
+
+# ------------------------ App Configuration Display ------------------------
+st.sidebar.markdown("### ⚙️ Configuration")
+st.sidebar.info(f"""
+**Provider:** `{PROVIDER}`  
+**Model:** `{GEMMA_MODEL}`  
+**Timezone:** `{TZ}`  
+**Cutoff:** {CUTOFF_HOUR}:00 PM  
+**Inactivity:** {INACTIVITY_MIN} min
+""")
+
+# ------------------------ Main App Execution ------------------------
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        logger.error(f"Application error: {e}")
+        st.error(f"❌ Application error: {e}")
+        st.info("Please refresh the page or contact support if the issue persists.")

backups/pre_modern_deployment_20250923_205210/test_app.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""
+Care Count App Testing Framework
+Tests UI/UX changes and backend functionality
+"""
+
+import sys
+import os
+import time
+import logging
+from datetime import datetime
+from typing import Dict, Any, List
+import subprocess
+import requests
+from pathlib import Path
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('test_results.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+class CareCountTester:
+    def __init__(self):
+        self.test_results = []
+        self.app_url = "http://localhost:8501"
+        self.backup_dir = Path("backups")
+        self.backup_dir.mkdir(exist_ok=True)
+        
+    def create_backup(self, description: str = "manual_backup"):
+        """Create a timestamped backup of current app state"""
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        backup_name = f"{description}_{timestamp}"
+        
+        # Backup main files
+        files_to_backup = [
+            "streamlit_app.py",
+            ".streamlit/secrets.toml",
+            "requirements.txt"
+        ]
+        
+        backup_path = self.backup_dir / backup_name
+        backup_path.mkdir(exist_ok=True)
+        
+        for file_path in files_to_backup:
+            if os.path.exists(file_path):
+                subprocess.run(["cp", file_path, str(backup_path / os.path.basename(file_path))])
+        
+        logger.info(f"Backup created: {backup_name}")
+        return backup_name
+    
+    def restore_backup(self, backup_name: str):
+        """Restore from a backup"""
+        backup_path = self.backup_dir / backup_name
+        
+        if not backup_path.exists():
+            logger.error(f"Backup {backup_name} not found")
+            return False
+        
+        # Restore files
+        files_to_restore = [
+            "streamlit_app.py",
+            ".streamlit/secrets.toml", 
+            "requirements.txt"
+        ]
+        
+        for file_path in files_to_restore:
+            backup_file = backup_path / os.path.basename(file_path)
+            if backup_file.exists():
+                subprocess.run(["cp", str(backup_file), file_path])
+        
+        logger.info(f"Restored from backup: {backup_name}")
+        return True
+    
+    def test_app_startup(self) -> bool:
+        """Test if the app starts without errors"""
+        try:
+            # Check if app is already running
+            response = requests.get(self.app_url, timeout=5)
+            if response.status_code == 200:
+                logger.info("✅ App is running and accessible")
+                return True
+            else:
+                logger.error(f"❌ App returned status code: {response.status_code}")
+                return False
+        except requests.exceptions.RequestException as e:
+            logger.error(f"❌ App startup test failed: {e}")
+            return False
+    
+    def test_ui_elements(self) -> Dict[str, bool]:
+        """Test key UI elements are present"""
+        results = {}
+        try:
+            response = requests.get(self.app_url, timeout=10)
+            content = response.text.lower()
+            
+            # Test for key UI elements
+            ui_tests = {
+                "title_present": "care count" in content,
+                "signin_form": "sign in" in content or "email" in content,
+                "camera_input": "camera" in content or "webcam" in content,
+                "file_upload": "upload" in content or "file" in content,
+                "visit_management": "visit" in content,
+                "item_logging": "item" in content,
+                "css_styling": "style" in content or "css" in content
+            }
+            
+            for test_name, result in ui_tests.items():
+                results[test_name] = result
+                status = "✅" if result else "❌"
+                logger.info(f"{status} {test_name}: {result}")
+            
+            return results
+            
+        except Exception as e:
+            logger.error(f"❌ UI elements test failed: {e}")
+            return {}
+    
+    def test_responsive_design(self) -> bool:
+        """Test if the app has responsive design elements"""
+        try:
+            response = requests.get(self.app_url, timeout=10)
+            content = response.text
+            
+            # Check for responsive design indicators
+            responsive_indicators = [
+                "container" in content,
+                "column" in content,
+                "responsive" in content,
+                "mobile" in content
+            ]
+            
+            responsive_score = sum(responsive_indicators) / len(responsive_indicators)
+            is_responsive = responsive_score >= 0.5
+            
+            logger.info(f"📱 Responsive design score: {responsive_score:.2f} ({'✅' if is_responsive else '❌'})")
+            return is_responsive
+            
+        except Exception as e:
+            logger.error(f"❌ Responsive design test failed: {e}")
+            return False
+    
+    def test_performance(self) -> Dict[str, float]:
+        """Test app performance metrics"""
+        try:
+            start_time = time.time()
+            response = requests.get(self.app_url, timeout=30)
+            load_time = time.time() - start_time
+            
+            results = {
+                "load_time": load_time,
+                "status_code": response.status_code,
+                "content_size": len(response.content)
+            }
+            
+            logger.info(f"⚡ Load time: {load_time:.2f}s")
+            logger.info(f"📊 Content size: {len(response.content)} bytes")
+            
+            return results
+            
+        except Exception as e:
+            logger.error(f"❌ Performance test failed: {e}")
+            return {}
+    
+    def run_all_tests(self) -> Dict[str, Any]:
+        """Run all tests and return comprehensive results"""
+        logger.info("🧪 Starting comprehensive app testing...")
+        
+        # Create backup before testing
+        backup_name = self.create_backup("pre_test_backup")
+        
+        test_results = {
+            "timestamp": datetime.now().isoformat(),
+            "backup_created": backup_name,
+            "startup_test": self.test_app_startup(),
+            "ui_elements": self.test_ui_elements(),
+            "responsive_design": self.test_responsive_design(),
+            "performance": self.test_performance()
+        }
+        
+        # Calculate overall score
+        ui_score = sum(test_results["ui_elements"].values()) / len(test_results["ui_elements"]) if test_results["ui_elements"] else 0
+        overall_score = (
+            (1 if test_results["startup_test"] else 0) +
+            ui_score +
+            (1 if test_results["responsive_design"] else 0)
+        ) / 3
+        
+        test_results["overall_score"] = overall_score
+        test_results["status"] = "PASS" if overall_score >= 0.8 else "FAIL"
+        
+        logger.info(f"🎯 Overall test score: {overall_score:.2f} ({test_results['status']})")
+        
+        return test_results
+
+def main():
+    """Main testing function"""
+    tester = CareCountTester()
+    
+    if len(sys.argv) > 1:
+        command = sys.argv[1]
+        
+        if command == "backup":
+            description = sys.argv[2] if len(sys.argv) > 2 else "manual_backup"
+            tester.create_backup(description)
+        elif command == "restore":
+            if len(sys.argv) > 2:
+                tester.restore_backup(sys.argv[2])
+            else:
+                print("Usage: python test_app.py restore <backup_name>")
+        elif command == "test":
+            results = tester.run_all_tests()
+            print(f"\n📋 Test Results Summary:")
+            print(f"Status: {results['status']}")
+            print(f"Score: {results['overall_score']:.2f}")
+            print(f"Backup: {results['backup_created']}")
+        else:
+            print("Available commands: backup, restore, test")
+    else:
+        # Run all tests by default
+        results = tester.run_all_tests()
+        print(f"\n📋 Test Results Summary:")
+        print(f"Status: {results['status']}")
+        print(f"Score: {results['overall_score']:.2f}")
+        print(f"Backup: {results['backup_created']}")
+
+if __name__ == "__main__":
+    main()

backups/pre_modern_deployment_20250923_205210/ui_improvements.py

@@ -0,0 +1,583 @@
+"""
+Care Count UI/UX Improvements Module
+Industry-standard UI components and styling
+"""
+
+import streamlit as st
+from typing import Dict, Any, Optional
+import base64
+from pathlib import Path
+
+class ModernUIComponents:
+    """Modern UI components for Care Count app"""
+    
+    @staticmethod
+    def get_modern_css() -> str:
+        """Return modern, industry-standard CSS"""
+        return """
+        <style>
+        /* Modern Design System - Laurier University Inspired */
+        :root {
+            /* Color Palette - Laurier University Theme */
+            --primary-purple: #6b46c1;  /* Laurier purple - more vibrant */
+            --primary-gold: #fbbf24;    /* Laurier gold - warmer tone */
+            --primary-dark: #1e1b4b;    /* Deep purple background */
+            --secondary-dark: #312e81;  /* Slightly lighter purple */
+            --accent-blue: #3b82f6;
+            --accent-green: #10b981;
+            --accent-red: #ef4444;
+            --accent-orange: #f59e0b;
+            
+            /* Neutral Colors */
+            --gray-50: #f9fafb;
+            --gray-100: #f3f4f6;
+            --gray-200: #e5e7eb;
+            --gray-300: #d1d5db;
+            --gray-400: #9ca3af;
+            --gray-500: #6b7280;
+            --gray-600: #4b5563;
+            --gray-700: #374151;
+            --gray-800: #1f2937;
+            --gray-900: #111827;
+            
+            /* Typography */
+            --font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            --font-size-xs: 0.75rem;
+            --font-size-sm: 0.875rem;
+            --font-size-base: 1rem;
+            --font-size-lg: 1.125rem;
+            --font-size-xl: 1.25rem;
+            --font-size-2xl: 1.5rem;
+            --font-size-3xl: 1.875rem;
+            
+            /* Spacing */
+            --space-1: 0.25rem;
+            --space-2: 0.5rem;
+            --space-3: 0.75rem;
+            --space-4: 1rem;
+            --space-5: 1.25rem;
+            --space-6: 1.5rem;
+            --space-8: 2rem;
+            --space-10: 2.5rem;
+            --space-12: 3rem;
+            
+            /* Border Radius */
+            --radius-sm: 0.375rem;
+            --radius-md: 0.5rem;
+            --radius-lg: 0.75rem;
+            --radius-xl: 1rem;
+            --radius-2xl: 1.5rem;
+            
+            /* Shadows */
+            --shadow-sm: 0 1px 2px 0 rgb(0 0 0 / 0.05);
+            --shadow-md: 0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1);
+            --shadow-lg: 0 10px 15px -3px rgb(0 0 0 / 0.1), 0 4px 6px -4px rgb(0 0 0 / 0.1);
+            --shadow-xl: 0 20px 25px -5px rgb(0 0 0 / 0.1), 0 8px 10px -6px rgb(0 0 0 / 0.1);
+        }
+        
+        /* Global Styles */
+        * {
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: var(--font-family);
+            background: var(--gray-50);
+            color: var(--gray-800);
+            line-height: 1.6;
+        }
+        
+        /* Streamlit Overrides */
+        .main .block-container {
+            padding: var(--space-6) var(--space-4);
+            max-width: 1200px;
+            background: var(--gray-50);
+        }
+        
+        .stApp {
+            background: var(--gray-50);
+        }
+        
+        /* Typography */
+        h1, h2, h3, h4, h5, h6 {
+            font-weight: 700;
+            letter-spacing: -0.025em;
+            color: var(--gray-800);
+        }
+        
+        h1 {
+            font-size: var(--font-size-3xl);
+            margin-bottom: var(--space-6);
+        }
+        
+        h2 {
+            font-size: var(--font-size-2xl);
+            margin-bottom: var(--space-4);
+        }
+        
+        h3 {
+            font-size: var(--font-size-xl);
+            margin-bottom: var(--space-3);
+        }
+        
+        /* Modern Cards - Laurier Style */
+        .modern-card {
+            background: white;
+            border: 1px solid var(--gray-200);
+            border-radius: var(--radius-xl);
+            padding: var(--space-6);
+            margin-bottom: var(--space-4);
+            box-shadow: var(--shadow-md);
+            transition: all 0.2s ease;
+            color: var(--gray-800);
+        }
+        
+        .modern-card:hover {
+            border-color: var(--primary-purple);
+            box-shadow: var(--shadow-lg);
+            transform: translateY(-2px);
+        }
+        
+        .modern-card:hover h1,
+        .modern-card:hover h2,
+        .modern-card:hover h3,
+        .modern-card:hover h4,
+        .modern-card:hover h5,
+        .modern-card:hover h6,
+        .modern-card:hover p,
+        .modern-card:hover span,
+        .modern-card:hover div {
+            color: var(--gray-800) !important;
+        }
+        
+        /* Status Cards */
+        .status-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: var(--space-4);
+            margin-bottom: var(--space-6);
+        }
+        
+        .status-card {
+            background: white;
+            border: 1px solid var(--gray-200);
+            border-radius: var(--radius-lg);
+            padding: var(--space-5);
+            text-align: center;
+            transition: all 0.2s ease;
+            box-shadow: var(--shadow-sm);
+        }
+        
+        .status-card:hover {
+            transform: translateY(-2px);
+            box-shadow: var(--shadow-md);
+            border-color: var(--primary-purple);
+        }
+        
+        .status-card:hover h4,
+        .status-card:hover .value,
+        .status-card:hover .subtitle {
+            color: var(--gray-800) !important;
+        }
+        
+        .status-card:hover .value {
+            color: var(--primary-purple) !important;
+        }
+        
+        .status-card h4 {
+            margin: 0 0 var(--space-2) 0;
+            font-size: var(--font-size-sm);
+            color: var(--gray-600);
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+            font-weight: 600;
+        }
+        
+        .status-card .value {
+            font-size: var(--font-size-2xl);
+            font-weight: 800;
+            color: var(--primary-purple);
+            margin: 0;
+        }
+        
+        .status-card .subtitle {
+            font-size: var(--font-size-xs);
+            color: var(--gray-500);
+            margin: var(--space-1) 0 0 0;
+        }
+        
+        /* Modern Buttons */
+        .modern-btn {
+            background: var(--primary-purple);
+            color: white;
+            border: none;
+            border-radius: var(--radius-md);
+            padding: var(--space-3) var(--space-6);
+            font-weight: 600;
+            font-size: var(--font-size-sm);
+            cursor: pointer;
+            transition: all 0.2s ease;
+            box-shadow: var(--shadow-sm);
+            position: relative;
+        }
+        
+        .modern-btn:hover {
+            background: #5b21b6;
+            transform: translateY(-1px);
+            box-shadow: var(--shadow-md);
+            color: white !important;
+        }
+        
+        .modern-btn:active {
+            transform: translateY(0);
+        }
+        
+        /* Tooltip styles */
+        .tooltip {
+            position: relative;
+            display: inline-block;
+        }
+        
+        .tooltip .tooltiptext {
+            visibility: hidden;
+            width: 200px;
+            background-color: var(--gray-800);
+            color: white;
+            text-align: center;
+            border-radius: var(--radius-md);
+            padding: var(--space-2) var(--space-3);
+            position: absolute;
+            z-index: 1;
+            bottom: 125%;
+            left: 50%;
+            margin-left: -100px;
+            opacity: 0;
+            transition: opacity 0.3s;
+            font-size: var(--font-size-xs);
+            box-shadow: var(--shadow-lg);
+        }
+        
+        .tooltip .tooltiptext::after {
+            content: "";
+            position: absolute;
+            top: 100%;
+            left: 50%;
+            margin-left: -5px;
+            border-width: 5px;
+            border-style: solid;
+            border-color: var(--gray-800) transparent transparent transparent;
+        }
+        
+        .tooltip:hover .tooltiptext {
+            visibility: visible;
+            opacity: 1;
+        }
+        
+        .modern-btn-secondary {
+            background: var(--gray-700);
+            color: var(--gray-100);
+        }
+        
+        .modern-btn-secondary:hover {
+            background: var(--gray-600);
+        }
+        
+        .modern-btn-success {
+            background: var(--accent-green);
+        }
+        
+        .modern-btn-success:hover {
+            background: #059669;
+        }
+        
+        .modern-btn-danger {
+            background: var(--accent-red);
+        }
+        
+        .modern-btn-danger:hover {
+            background: #dc2626;
+        }
+        
+        /* Form Elements */
+        .modern-input {
+            background: white;
+            border: 1px solid var(--gray-300);
+            border-radius: var(--radius-md);
+            padding: var(--space-3);
+            color: var(--gray-800);
+            font-size: var(--font-size-sm);
+            transition: all 0.2s ease;
+        }
+        
+        .modern-input:focus {
+            outline: none;
+            border-color: var(--primary-purple);
+            box-shadow: 0 0 0 3px rgb(107 70 193 / 0.1);
+        }
+        
+        /* Hero Section - Laurier Style */
+        .hero-section {
+            background: var(--primary-purple);
+            border-radius: var(--radius-2xl);
+            padding: var(--space-10);
+            margin-bottom: var(--space-8);
+            text-align: left;
+            color: white;
+            box-shadow: var(--shadow-xl);
+            position: relative;
+            overflow: hidden;
+        }
+        
+        .hero-section::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            right: 0;
+            width: 40%;
+            height: 100%;
+            background: linear-gradient(135deg, rgba(255,255,255,0.1) 0%, rgba(255,255,255,0.05) 100%);
+            border-radius: 0 var(--radius-2xl) var(--radius-2xl) 0;
+        }
+        
+        .hero-section h1 {
+            color: white;
+            margin-bottom: var(--space-4);
+        }
+        
+        .hero-section p {
+            font-size: var(--font-size-lg);
+            opacity: 0.9;
+            margin: 0;
+        }
+        
+        /* Progress Indicators */
+        .progress-bar {
+            background: var(--gray-700);
+            border-radius: var(--radius-lg);
+            height: 8px;
+            overflow: hidden;
+            margin: var(--space-2) 0;
+        }
+        
+        .progress-fill {
+            background: linear-gradient(90deg, var(--primary-purple), var(--primary-gold));
+            height: 100%;
+            transition: width 0.3s ease;
+        }
+        
+        /* Badges */
+        .badge {
+            display: inline-block;
+            padding: var(--space-1) var(--space-2);
+            border-radius: var(--radius-sm);
+            font-size: var(--font-size-xs);
+            font-weight: 600;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+        }
+        
+        .badge-success {
+            background: var(--accent-green);
+            color: white;
+        }
+        
+        .badge-warning {
+            background: var(--accent-orange);
+            color: white;
+        }
+        
+        .badge-danger {
+            background: var(--accent-red);
+            color: white;
+        }
+        
+        .badge-info {
+            background: var(--accent-blue);
+            color: white;
+        }
+        
+        /* Responsive Design */
+        @media (max-width: 768px) {
+            .main .block-container {
+                padding: var(--space-4) var(--space-2);
+            }
+            
+            .status-grid {
+                grid-template-columns: 1fr;
+            }
+            
+            .hero-section {
+                padding: var(--space-6);
+            }
+            
+            h1 {
+                font-size: var(--font-size-2xl);
+            }
+        }
+        
+        /* Loading States */
+        .loading {
+            display: inline-block;
+            width: 20px;
+            height: 20px;
+            border: 3px solid var(--gray-600);
+            border-radius: 50%;
+            border-top-color: var(--primary-purple);
+            animation: spin 1s ease-in-out infinite;
+        }
+        
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+        
+        /* Animations */
+        .fade-in {
+            animation: fadeIn 0.5s ease-in;
+        }
+        
+        @keyframes fadeIn {
+            from { opacity: 0; transform: translateY(20px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+        
+        .slide-in {
+            animation: slideIn 0.3s ease-out;
+        }
+        
+        @keyframes slideIn {
+            from { transform: translateX(-100%); }
+            to { transform: translateX(0); }
+        }
+        
+        /* Accessibility */
+        .sr-only {
+            position: absolute;
+            width: 1px;
+            height: 1px;
+            padding: 0;
+            margin: -1px;
+            overflow: hidden;
+            clip: rect(0, 0, 0, 0);
+            white-space: nowrap;
+            border: 0;
+        }
+        
+        /* Focus states for accessibility */
+        button:focus,
+        input:focus,
+        select:focus,
+        textarea:focus {
+            outline: 2px solid var(--primary-purple);
+            outline-offset: 2px;
+        }
+        </style>
+        """
+    
+    @staticmethod
+    def create_hero_section(title: str, subtitle: str, user_email: str = None) -> str:
+        """Create a Laurier-style hero section"""
+        if user_email:
+            return f"""
+            <div class="hero-section fade-in">
+                <div style="position: relative; z-index: 2;">
+                    <h1 style="font-size: 2.5rem; margin-bottom: var(--space-4); color: white;">💜💛 {title}</h1>
+                    <p style="font-size: 1.25rem; margin-bottom: var(--space-6); color: white; opacity: 0.9;">{subtitle}</p>
+                    <div style="margin-top: var(--space-6); padding: var(--space-5); background: rgba(255,255,255,0.15); border-radius: var(--radius-lg); backdrop-filter: blur(10px);">
+                        <div style="font-size: var(--font-size-sm); opacity: 0.8; color: white;">Welcome,</div>
+                        <div style="font-weight: 800; font-size: var(--font-size-xl); margin: var(--space-2) 0; color: white;">{user_email}</div>
+                        <div style="font-size: var(--font-size-sm); opacity: 0.8; color: white;">Thank you for showing up for the community today. 💜💛</div>
+                    </div>
+                </div>
+            </div>
+            """
+        else:
+            return f"""
+            <div class="hero-section fade-in">
+                <div style="position: relative; z-index: 2;">
+                    <h1 style="font-size: 2.5rem; margin-bottom: var(--space-4); color: white;">💜💛 {title}</h1>
+                    <p style="font-size: 1.25rem; color: white; opacity: 0.9;">{subtitle}</p>
+                </div>
+            </div>
+            """
+    
+    @staticmethod
+    def create_status_cards(data: Dict[str, Any]) -> str:
+        """Create modern status cards"""
+        cards_html = '<div class="status-grid">'
+        
+        for key, value in data.items():
+            if key == "shift_active":
+                cards_html += f"""
+                <div class="status-card slide-in">
+                    <h4>Shift Active</h4>
+                    <div class="value">{value}</div>
+                    <div class="subtitle">since you signed in</div>
+                </div>
+                """
+            elif key == "items_today":
+                cards_html += f"""
+                <div class="status-card slide-in">
+                    <h4>Items Logged Today</h4>
+                    <div class="value">{value}</div>
+                    <div class="subtitle">items processed</div>
+                </div>
+                """
+            elif key == "lifetime_hours":
+                cards_html += f"""
+                <div class="status-card slide-in">
+                    <h4>Lifetime Hours</h4>
+                    <div class="value">{value}</div>
+                    <div class="subtitle">volunteer hours</div>
+                </div>
+                """
+        
+        cards_html += '</div>'
+        return cards_html
+    
+    @staticmethod
+    def create_modern_form_section(title: str, description: str = None) -> str:
+        """Create a modern form section header"""
+        desc_html = f'<p style="color: var(--gray-400); margin-bottom: var(--space-4);">{description}</p>' if description else ''
+        return f"""
+        <div class="modern-card fade-in">
+            <h3>{title}</h3>
+            {desc_html}
+        """
+    
+    @staticmethod
+    def create_progress_indicator(current: int, total: int, label: str) -> str:
+        """Create a modern progress indicator"""
+        percentage = (current / total * 100) if total > 0 else 0
+        return f"""
+        <div style="margin: var(--space-4) 0;">
+            <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: var(--space-2);">
+                <span style="font-weight: 600; color: var(--gray-300);">{label}</span>
+                <span style="font-weight: 700; color: var(--primary-gold);">{current}/{total}</span>
+            </div>
+            <div class="progress-bar">
+                <div class="progress-fill" style="width: {percentage}%;"></div>
+            </div>
+        </div>
+        """
+    
+    @staticmethod
+    def create_badge(text: str, variant: str = "info") -> str:
+        """Create a modern badge"""
+        return f'<span class="badge badge-{variant}">{text}</span>'
+    
+    @staticmethod
+    def create_loading_spinner() -> str:
+        """Create a loading spinner"""
+        return '<div class="loading"></div>'
+
+def apply_modern_ui():
+    """Apply modern UI styling to the Streamlit app"""
+    st.markdown(ModernUIComponents.get_modern_css(), unsafe_allow_html=True)
+
+def create_modern_layout():
+    """Create a modern layout structure"""
+    return {
+        "container_style": "max-width: 1200px; margin: 0 auto;",
+        "sidebar_style": "background: var(--secondary-dark); border-right: 1px solid var(--gray-700);",
+        "main_style": "background: var(--primary-dark); padding: var(--space-6);"
+    }

backups/pre_test_backup_20250923_202554/requirements.txt

@@ -0,0 +1,9 @@
+streamlit>=1.33
+pandas>=2.1
+Pillow>=10.1
+supabase>=2.5
+huggingface_hub>=0.24.6
+requests>=2.31
+python-dotenv>=1.0.0
+pytz>=2023.3
+

backups/pre_test_backup_20250923_202554/secrets.toml

@@ -0,0 +1,15 @@
+# Supabase connection
+SUPABASE_URL = "https://oudjcqhyldpncjbxohsg.supabase.co"
+SUPABASE_KEY ="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im91ZGpjcWh5bGRwbmNqYnhvaHNnIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTUzMDgyNDQsImV4cCI6MjA3MDg4NDI0NH0.SYwTtCe3r7WOZ25CRggL-lBkvGPjKnQhY_dT4Kjv9Dg"
+
+# App settings
+APP_TZ = "America/Toronto"
+
+# Hugging Face
+HF_TOKEN = "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"
+
+# Optional VLM model provider
+PROVIDER = "nebius"
+GEMMA_MODEL = "google/gemma-3-27b-it"
+NEBIUS_API_KEY = "eyJhbGciOiJIUzI1NiIsImtpZCI6IlV6SXJWd1h0dnprLVRvdzlLZWstc0M1akptWXBvX1VaVkxUZlpnMDRlOFUiLCJ0eXAiOiJKV1QifQ.eyJzdWIiOiJnb29nbGUtb2F1dGgyfDEwMjk4MzMxNjQ1OTQzNjA5ODYxMyIsInNjb3BlIjoib3BlbmlkIG9mZmxpbmVfYWNjZXNzIiwiaXNzIjoiYXBpX2tleV9pc3N1ZXIiLCJhdWQiOlsiaHR0cHM6Ly9uZWJpdXMtaW5mZXJlbmNlLmV1LmF1dGgwLmNvbS9hcGkvdjIvIl0sImV4cCI6MTkxNTEzMTE3MiwidXVpZCI6IjJmOTUxZmM1LWEyNTgtNDg5OC1iNWI4LTkwZTljY2RkZjU2NSIsIm5hbWUiOiJjYXJlIGNvdW50IGFwcCIsImV4cGlyZXNfYXQiOiIyMDMwLTA5LTA4VDIwOjUyOjUyKzAwMDAifQ.awAHOieD93pCnYmFMgRQ64-i6yZdO0XvXczD4eS6xEI"
+NEBIUS_BASE_URL = "https://api.nebius.ai/v1"

backups/pre_test_backup_20250923_202554/streamlit_app.py

@@ -0,0 +1,612 @@
+# --- Care Count (Volunteers → Visits → Items) ---
+# Delightful Laurier-themed UX + enterprise data hygiene
+# - OTP email login (Supabase)
+# - Shift tracking & idle/8pm auto sign-out
+# - Human-friendly visit_code (with DB trigger or safe fallback)
+# - VLM-assisted item name
+# - RPC ingest with validation/quarantine (fallback to direct insert)
+# - Volunteer Impact card (today + lifetime)
+
+from __future__ import annotations
+
+import os, io, time, base64, re, uuid, json
+from datetime import datetime, timedelta
+from typing import Optional
+
+import pytz
+import requests
+import pandas as pd
+import streamlit as st
+from PIL import Image, ImageOps, ImageEnhance
+from supabase import create_client, Client
+
+# ------------------------ App config ------------------------
+os.environ.setdefault("HOME", "/tmp")
+os.environ["STREAMLIT_BROWSER_GATHER_USAGE_STATS"] = "false"
+
+TZ             = os.getenv("APP_TZ", "America/Toronto")
+CUTOFF_HOUR    = int(os.getenv("CUTOFF_HOUR", "20"))   # 8pm local
+INACTIVITY_MIN = int(os.getenv("INACTIVITY_MIN", "30"))
+
+def local_now() -> datetime:
+    return datetime.now(pytz.timezone(TZ))
+
+st.set_page_config(page_title="Care Count", layout="centered")
+st.markdown("""
+<style>
+/* Laurier theme vibes */
+:root { --cc-purple:#6d28d9; --cc-gold:#fde047; --cc-bg:#0b1420; --cc-panel:#0f1a2a; --cc-border:#1d2a44; }
+.block-container { padding-top: 2rem; }
+h1, h2, .stMarkdown h1, .stMarkdown h2 { letter-spacing:.2px }
+.cc-pill { display:inline-block; padding:4px 10px; border-radius:999px; background:var(--cc-gold); color:#111827; font-weight:700; font-size:12px; }
+.cc-hint { background:#10233b; border:1px solid #1f3b5b; color:#e6e8f0; padding:12px 16px; border-radius:10px; }
+.cc-hero { background:#0f1a2a; border:1px solid #1f2a44; padding:16px 18px; border-radius:14px; }
+.cc-btn-primary button { background:var(--cc-purple)!important; color:#fff!important; border:0!important; }
+.cc-danger button { background:#7f1d1d!important; color:#fff!important; }
+.status-card { display:flex; gap:16px; flex-wrap:wrap; }
+.card { background:#0f1a2a; border:1px solid #1f2a44; border-radius:14px; padding:14px 16px; min-width:200px; }
+.card h4 { margin:0 0 6px 0; font-size:0.95rem; color:#cbd5e1 }
+.card .big { font-size:1.6rem; font-weight:700; color:#e5e7eb }
+.small { color:#9aa3b2; font-size:12px }
+</style>
+""", unsafe_allow_html=True)
+
+st.title("💜💛 Care Count")
+st.caption("Thanks for showing up for the community today. Snap items, keep visits tidy, and help us understand the impact of your time.")
+
+# ------------------------ Secrets & client ------------------------
+# Robust env/secrets helpers that work with Streamlit (st.secrets) and .env/CI.
+# Order of precedence: OS env > Streamlit secrets > default.
+
+# Optional: allow plain `python` runs to pick up a local .env if present
+try:
+    from dotenv import load_dotenv  # pip install python-dotenv (optional)
+    load_dotenv()
+except Exception:
+    pass
+
+# Make Streamlit secrets safe to access even when not launched via `streamlit run`
+try:
+    _SECRETS = getattr(st, "secrets", {})
+except Exception:
+    _SECRETS = {}
+
+def _is_useful(val: Optional[str]) -> bool:
+    return val is not None and str(val).strip() != ""
+
+def get_secret(name: str, default: Optional[str] = None) -> Optional[str]:
+    """
+    Flat TOML usage:
+      SUPABASE_URL = "..."
+      SUPABASE_KEY = "..."
+    Looks in OS env first, then st.secrets, else returns default.
+    """
+    # 1) OS env
+    v = os.getenv(name)
+    if _is_useful(v):
+        return v
+
+    # 2) Streamlit secrets (flat)
+    try:
+        if hasattr(_SECRETS, "get"):
+            v = _SECRETS.get(name, default)
+            if _is_useful(v):
+                return v
+    except Exception:
+        pass
+
+    # 3) default
+    return default
+
+def require_secret(name: str) -> str:
+    """
+    Same as get_secret but fails fast with a clear error if missing/blank.
+    """
+    v = get_secret(name, None)
+    if not _is_useful(v):
+        st.error(
+            f"Missing secret: {name}. "
+            "Ensure it exists as an environment variable or in .streamlit/secrets.toml"
+        )
+        st.stop()
+    return str(v)
+
+# (Optional) lightweight visibility check during setup. Comment out in prod.
+# st.write("Secrets present:",
+#          bool(get_secret("SUPABASE_URL")),
+#          bool(get_secret("SUPABASE_KEY")))
+
+# Required Supabase credentials (flat keys)
+SUPABASE_URL = require_secret("SUPABASE_URL")
+SUPABASE_KEY = require_secret("SUPABASE_KEY")   # anon key (RLS should be ON)
+
+# Initialize Supabase client
+sb: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+
+# Optional provider/config (all flat keys with safe defaults)
+PROVIDER         = (get_secret("PROVIDER", "nebius") or "nebius").strip().lower()
+GEMMA_MODEL      = (get_secret("GEMMA_MODEL", "google/gemma-3-27b-it") or "google/gemma-3-27b-it").strip()
+NEBIUS_API_KEY   = get_secret("NEBIUS_API_KEY")
+NEBIUS_BASE_URL  = get_secret("NEBIUS_BASE_URL", "https://api.nebius.ai/v1")
+FEATH_API_KEY    = get_secret("FEATHERLESS_API_KEY")
+FEATH_BASE_URL   = get_secret("FEATHERLESS_BASE_URL", "https://api.featherless.ai/v1")
+
+
+
+st.caption(f"Provider: `{PROVIDER}` · Model: `{GEMMA_MODEL}` · TZ: `{TZ}`")
+
+# ------------------------ Light events/audit (non-blocking) ------------------------
+def log_event(action: str, actor: Optional[str], details: dict):
+    try:
+        sb.table("events").insert({"actor_email": actor, "action": action, "details": details}).execute()
+    except Exception:
+        pass
+
+# ------------------------ Auth (Email OTP) ------------------------
+def auth_block() -> tuple[bool, Optional[str]]:
+    if "auth_email" not in st.session_state:
+        st.session_state["auth_email"] = None
+    if "user_email" in st.session_state:
+        return True, st.session_state["user_email"]
+
+    st.subheader("Sign in")
+    with st.form("otp_request", clear_on_submit=False, border=False):
+        email = st.text_input("Email", value=st.session_state.get("auth_email") or "", autocomplete="email")
+        send = st.form_submit_button("Send login code")
+        if send:
+            if not email or "@" not in email:
+                st.error("Please enter a valid email.")
+            else:
+                try:
+                    sb.auth.sign_in_with_otp({"email": email, "shouldCreateUser": True})
+                    st.session_state["auth_email"] = email
+                    st.success("We emailed you a one-time code. Enter it to continue.")
+                except Exception as e:
+                    st.error(f"Could not send code: {e}")
+
+    if st.session_state.get("auth_email"):
+        with st.form("otp_verify", clear_on_submit=True, border=False):
+            code = st.text_input("Enter 6-digit code", max_chars=6)
+            ok = st.form_submit_button("Verify & start shift")
+            if ok:
+                try:
+                    res = sb.auth.verify_otp({"email": st.session_state["auth_email"], "token": code, "type": "email"})
+                    if res and res.user:
+                        email = st.session_state["auth_email"]
+                        # Idempotent upsert for volunteer & start shift
+                        sb.table("volunteers").upsert({
+                            "email": email,
+                            "last_login_at": datetime.utcnow().isoformat(),
+                            "shift_started_at": datetime.utcnow().isoformat(),
+                            "shift_ended_at": None
+                        }, on_conflict="email").execute()
+                        st.session_state["user_email"] = email
+                        st.session_state["shift_started"] = True
+                        st.session_state["last_activity_at"] = local_now()
+                        log_event("login", email, {"method":"otp"})
+                        st.toast("Welcome back! Shift started. 💜", icon="✅")
+                        return True, email
+                except Exception as e:
+                    st.error(f"Verification failed: {e}")
+    return False, None
+
+def end_shift(email: str, reason: str):
+    try:
+        sb.table("volunteers").update({"shift_ended_at": datetime.utcnow().isoformat()}).eq("email", email).execute()
+        log_event("shift_end", email, {"reason": reason})
+    except Exception:
+        pass
+
+def guard_cutoff_and_idle(email: str):
+    now = local_now()
+    last = st.session_state.get("last_activity_at")
+    if last and (now - last).total_seconds() > INACTIVITY_MIN * 60:
+        end_shift(email, "inactivity")
+        st.session_state.clear()
+        st.info("You were logged out due to inactivity. Thank you for volunteering today!")
+        st.stop()
+    st.session_state["last_activity_at"] = now
+
+    cutoff = now.replace(hour=CUTOFF_HOUR, minute=0, second=0, microsecond=0)
+    if now >= cutoff:
+        end_shift(email, "cutoff_8pm")
+        st.session_state.clear()
+        st.info("We close the day at 8pm. Your shift has been ended. Thank you so much!")
+        st.stop()
+
+signed_in, user_email = auth_block()
+if not signed_in:
+    st.stop()
+guard_cutoff_and_idle(user_email)
+
+# Welcome banner (visceral, kind)
+st.markdown(
+    f"""<div class="cc-hero">
+    <div class="small">Welcome,</div>
+    <div style="font-weight:800;font-size:1.15rem"> {user_email}</div>
+    <div class="small">Thank you for showing up for the community today. 💜💛</div>
+    </div>""",
+    unsafe_allow_html=True
+)
+
+# Sign-out button (prominent)
+c_signout = st.columns([1,1,6])[1]
+with c_signout:
+    st.markdown('<div class="cc-btn-primary">', unsafe_allow_html=True)
+    if st.button("🔒 Sign out"):
+        end_shift(user_email, "manual")
+        st.session_state.clear()
+        st.success("Signed out. See you next time!")
+        st.stop()
+    st.markdown('</div>', unsafe_allow_html=True)
+
+# ------------------------ Volunteer Impact card ------------------------
+def fetch_volunteer_row(email: str) -> dict | None:
+    try:
+        return sb.table("volunteers").select("*").eq("email", email).single().execute().data
+    except Exception:
+        return None
+
+def items_today(email: str) -> int:
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        # try partitioned table first
+        data = sb.table("visit_items_p").select("id,timestamp,volunteer") \
+                .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                .eq("volunteer", email).execute().data
+        return len(data or [])
+    except Exception:
+        try:
+            data = sb.table("visit_items").select("id,timestamp,volunteer") \
+                    .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                    .eq("volunteer", email).execute().data
+            return len(data or [])
+        except Exception:
+            return 0
+
+vrow = fetch_volunteer_row(user_email) or {}
+shift_started_at = vrow.get("shift_started_at")
+lifetime_hours = vrow.get("total_hours")  # may not exist yet; handled below
+mins_active = 0
+try:
+    if shift_started_at:
+        t0 = datetime.fromisoformat(str(shift_started_at).replace("Z","+00:00"))
+        mins_active = max(0, int((datetime.utcnow() - t0).total_seconds() // 60))
+except Exception:
+    pass
+
+st.markdown('<div class="status-card">', unsafe_allow_html=True)
+st.markdown(f'<div class="card"><h4>Shift active</h4><div class="big">{mins_active} min</div><div class="small">since you signed in</div></div>', unsafe_allow_html=True)
+st.markdown(f'<div class="card"><h4>Items you logged today</h4><div class="big">{items_today(user_email)}</div></div>', unsafe_allow_html=True)
+if isinstance(lifetime_hours, (int, float)):
+    st.markdown(f'<div class="card"><h4>Lifetime hours</h4><div class="big">{round(float(lifetime_hours),1)}</div></div>', unsafe_allow_html=True)
+st.markdown('</div>', unsafe_allow_html=True)
+
+# ------------------------ Image helpers ------------------------
+def _to_png_bytes(img: Image.Image) -> bytes:
+    b = io.BytesIO(); img.save(b, format="PNG"); return b.getvalue()
+
+def preprocess_for_label(img: Image.Image) -> Image.Image:
+    img = img.convert("RGB")
+    w, h = img.size
+    scale = 1024 / max(w, h) if max(w, h) > 1024 else 1.0
+    if scale < 1.0: img = img.resize((int(w * scale), int(h * scale)))
+    img = ImageOps.autocontrast(img, cutoff=2)
+    img = ImageEnhance.Brightness(img).enhance(1.06)
+    img = ImageEnhance.Contrast(img).enhance(1.05)
+    img = ImageEnhance.Sharpness(img).enhance(1.15)
+    return img
+
+# ------------------------ VLM client ------------------------
+SYSTEM_HINT = "You label item being held in the image for a food bank. Return ONLY the item name."
+
+def _openai_style_chat(base_url: str, api_key: str, model_id: str, img_bytes: bytes) -> str:
+    b64 = base64.b64encode(img_bytes).decode("utf-8")
+    url = f"{base_url.rstrip('/')}/chat/completions"
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    payload = {
+        "model": model_id,
+        "temperature": 0,
+        "messages": [
+            {"role": "system", "content": SYSTEM_HINT},
+            {"role": "user", "content": [
+                {"type": "text", "text": "What is the name of the item in the picture? Return only the item name."},
+                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}}
+            ]}
+        ]
+    }
+    r = requests.post(url, json=payload, headers=headers, timeout=90)
+    if r.status_code != 200:
+        raise RuntimeError(f"LLM HTTP {r.status_code}: {r.text[:200]}")
+    data = r.json()
+    return (data["choices"][0]["message"]["content"] or "").strip()
+
+def gemma_item_name(img_bytes: bytes) -> str:
+    if PROVIDER == "nebius":
+        if not NEBIUS_API_KEY: raise RuntimeError("NEBIUS_API_KEY missing")
+        return _openai_style_chat(NEBIUS_BASE_URL, NEBIUS_API_KEY, GEMMA_MODEL, img_bytes)
+    elif PROVIDER == "featherless":
+        if not FEATH_API_KEY: raise RuntimeError("FEATHERLESS_API_KEY missing")
+        return _openai_style_chat(FEATH_BASE_URL, FEATH_API_KEY, GEMMA_MODEL, img_bytes)
+    else:
+        raise RuntimeError(f"Unknown PROVIDER: {PROVIDER}")
+
+# ------------------------ Normalization ------------------------
+BRANDS = {
+    "whiskas","tetley","kellogg's","kelloggs","campbell's","campbells","heinz",
+    "nestle","kraft","general mills","cheerios","oreo","oreos","pringles","lays","doritos",
+    "ice river","green bottle","great value","wheat thins","vegetable thins","raid"
+}
+GENERIC_TYPES = {
+    "water","toothpaste","deodorant","antiperspirant","soap","shampoo","conditioner",
+    "lotion","tea","coffee","cereal","pasta","rice","beans","sauce","salsa","cleaner",
+    "peanut butter","jam","jelly","tuna","chicken","beef","flour","sugar","salt","oil",
+    "crackers","cookies","soup","insect killer","spray"
+}
+def normalize_item_name(s: str) -> str:
+    s = (s or "").strip()
+    if not s: return ""
+    low = re.sub(r"[®™]", "", s.lower())
+    for b in BRANDS: low = low.replace(b, "")
+    chosen = None
+    for t in GENERIC_TYPES:
+        if t in low: chosen = t; break
+    cleaned = " ".join(low.split())
+    return (chosen or cleaned.title())[:120]
+
+def clean_text(v: Optional[str], maxlen: int = 120) -> Optional[str]:
+    if not v: return None
+    v = re.sub(r"\s+", " ", v).strip()
+    return v[:maxlen] if v else None
+
+# ------------------------ Visit flow ------------------------
+st.subheader("🪪 Anonymous Student Visit")
+
+active_visit = st.session_state.get("active_visit")
+
+def fallback_visit_code() -> str:
+    """Readable visit_code if DB trigger isn't present."""
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        todays = sb.table("visits").select("id,started_at").gte("started_at", f"{day} 00:00:00") \
+                 .lte("started_at", f"{day} 23:59:59").execute().data or []
+        seq = len(todays) + 1
+    except Exception:
+        seq = int(time.time()) % 1000
+    return f"V-{seq}-{local_now().strftime('%Y%m%d')}-{str(uuid.uuid4())[:6]}"
+
+c1, c2, c3 = st.columns(3)
+with c1:
+    st.markdown('<div class="cc-btn-primary">', unsafe_allow_html=True)
+    if not active_visit and st.button("Start Visit"):
+        try:
+            payload = {
+                "visit_code": fallback_visit_code(),  # DB trigger will override if present
+                "started_at": datetime.utcnow().isoformat(),
+                "ended_at": None,
+                "created_by": user_email
+            }
+            v = sb.table("visits").insert(payload).execute().data[0]
+            # If trigger generated code, keep that
+            if not v.get("visit_code"):
+                v["visit_code"] = payload["visit_code"]
+            st.session_state["active_visit"] = v
+            st.success(f"Visit #{v['id']} started · code: **{v['visit_code']}**")
+            log_event("visit_start", user_email, {"visit_id": v["id"], "visit_code": v["visit_code"]})
+        except Exception as e:
+            st.error(f"Could not start visit: {e}")
+    st.markdown('</div>', unsafe_allow_html=True)
+
+with c2:
+    if active_visit and st.button("End Visit (Checkout)"):
+        try:
+            sb.table("visits").update({"ended_at": datetime.utcnow().isoformat()}) \
+              .eq("id", active_visit["id"]).execute()
+            st.success("Visit checked out. Ready for the next student.")
+            log_event("visit_end", user_email, {"visit_id": active_visit["id"]})
+            st.session_state.pop("active_visit", None)
+        except Exception as e:
+            st.error(f"Could not end visit: {e}")
+
+with c3:
+    if st.session_state.get("active_visit"):
+        v = st.session_state["active_visit"]
+        st.caption(f"Active visit_id: {v['id']} · code: {v.get('visit_code','')}")
+    else:
+        st.caption("No active visit.")
+
+# ------------------------ Identify item ------------------------
+st.subheader("📸 Identify item from image")
+
+c4, c5 = st.columns(2)
+with c4: cam = st.camera_input("Use your phone or webcam")
+with c5: up  = st.file_uploader("…or upload an image", type=["png","jpg","jpeg"])
+
+img_file = cam or up
+if img_file:
+    img = Image.open(img_file).convert("RGB")
+    st.image(img, use_container_width=True)
+    if st.button("🔍 Ask model for item name"):
+        t0, raw = time.time(), ""
+        try:
+            pre = preprocess_for_label(img); raw = gemma_item_name(_to_png_bytes(pre))
+        except Exception as e:
+            st.error(f"Provider error: {e}"); log_event("vlm_error", user_email, {"error": str(e)})
+        norm = normalize_item_name(raw)
+        if raw: st.success(f"🧠 Model: **{raw}**")
+        st.info(f"✨ Normalized: **{norm or '(unknown)'}** · ⏱️ {time.time()-t0:.2f}s")
+        st.session_state["scanned_item_name"] = norm or raw or ""
+        st.session_state["last_activity_at"] = local_now()
+
+# ------------------------ Log item ------------------------
+st.subheader("📬 Log item to current visit")
+
+item_name = st.text_input("Item name", value=st.session_state.get("scanned_item_name",""))
+quantity  = st.number_input("Quantity", min_value=1, max_value=9999, step=1, value=1)
+category  = st.text_input("Category (optional)")
+unit      = st.text_input("Unit (optional, e.g., 500 mL, 1 L, 250 g)")
+barcode   = st.text_input("Barcode (optional)")
+
+def deterministic_ingest_id(v_id: int, email: str, name: str, qty: int, ts_iso: str) -> str:
+    key = f"visit_items::{v_id}::{email}::{name}::{qty}::{ts_iso}"
+    return str(uuid.uuid5(uuid.NAMESPACE_URL, key))
+
+def try_rpc_ingest(email: str, v_id: int, name: str, qty: int,
+                   category: Optional[str], unit: Optional[str],
+                   barcode: Optional[str], ts_iso: str, ingest_id: str) -> tuple[bool,str]:
+    """
+    Call the RPC safe_ingest_visit_item if it exists.
+    Returns (ok, msg). If function is missing, raises to trigger fallback.
+    """
+    try:
+        res = sb.rpc("safe_ingest_visit_item", {
+            "p_email": email,
+            "p_visit_id": v_id,
+            "p_item_name": name,
+            "p_qty": qty,
+            "p_category": category,
+            "p_unit": unit,
+            "p_barcode": barcode,
+            "p_ts": ts_iso,
+            "p_ingest_id": ingest_id
+        }).execute()
+        # RPC returns a setof (ok boolean, msg text) — normalize
+        rows = res.data if isinstance(res.data, list) else []
+        if rows:
+            r0 = rows[0]
+            ok = bool(r0.get("ok", False))
+            msg = str(r0.get("msg", ""))
+            return ok, msg or ("ok" if ok else "failed")
+        # Some PostgREST setups return {} — treat as ok
+        return True, "ok"
+    except Exception as e:
+        # If function missing (42883) or not exposed, re-raise to use fallback
+        raise e
+
+def fallback_direct_insert(email: str, v_id: int, name: str, qty: int,
+                           category: Optional[str], unit: Optional[str],
+                           barcode: Optional[str], ts_iso: str, ingest_id: str) -> None:
+    """Write into visit_items_p if present, else visit_items (keeps app working)."""
+    payload = {
+        "visit_id": v_id,
+        "timestamp": ts_iso,
+        "volunteer": email,
+        "item_name": name,
+        "category": category,
+        "unit": unit,
+        "qty": qty,
+        "barcode": barcode,
+        "weather_type": None,
+        "temp_c": None,
+        "ingest_id": ingest_id
+    }
+    try:
+        sb.table("visit_items_p").insert(payload).execute()
+    except Exception:
+        # legacy table fallback
+        payload.pop("ingest_id", None)
+        sb.table("visit_items").insert(payload).execute()
+
+st.markdown('<div class="cc-btn-primary">', unsafe_allow_html=True)
+save_disabled = not st.session_state.get("active_visit")
+if st.button("✅ Save Item to Visit", disabled=save_disabled):
+    v = st.session_state.get("active_visit")
+    if not v:
+        st.warning("Start a visit first, then save items.")
+    else:
+        name_clean = clean_text(item_name, 120)
+        if not name_clean:
+            st.warning("Item name is required.")
+        else:
+            ts_iso = datetime.utcnow().isoformat()
+            ingest_id = deterministic_ingest_id(int(v["id"]), user_email, name_clean, int(quantity), ts_iso)
+            try:
+                ok, msg = try_rpc_ingest(
+                    email=user_email, v_id=int(v["id"]), name=name_clean, qty=int(quantity),
+                    category=clean_text(category, 80), unit=clean_text(unit, 40),
+                    barcode=clean_text(barcode, 64), ts_iso=ts_iso, ingest_id=ingest_id
+                )
+                if ok:
+                    st.success("Item logged ✅")
+                else:
+                    st.warning(f"Ingest said: {msg}. (Will try direct insert.)")
+                    fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                           clean_text(category,80), clean_text(unit,40),
+                                           clean_text(barcode,64), ts_iso, ingest_id)
+                    st.success("Item logged ✅ (fallback)")
+            except Exception as e:
+                # RPC missing or failed → direct insert
+                try:
+                    fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                           clean_text(category,80), clean_text(unit,40),
+                                           clean_text(barcode,64), ts_iso, ingest_id)
+                    st.success("Item logged ✅ (fallback)")
+                except Exception as e2:
+                    st.error(f"Ingest failed: {e2}")
+            st.session_state["last_activity_at"] = local_now()
+            st.session_state["scanned_item_name"] = name_clean
+st.markdown('</div>', unsafe_allow_html=True)
+
+# ------------------------ Visit items view + delete ------------------------
+def load_items_for_visit(visit_id: int) -> list[dict]:
+    # Prefer partitioned table
+    try:
+        return sb.table("visit_items_p").select("*").eq("visit_id", visit_id) \
+            .order("timestamp", desc=True).limit(500).execute().data or []
+    except Exception:
+        try:
+            return sb.table("visit_items").select("*").eq("visit_id", visit_id) \
+                .order("timestamp", desc=True).limit(500).execute().data or []
+        except Exception:
+            return []
+
+def delete_item(table: str, item_id: int):
+    try:
+        sb.table(table).delete().eq("id", item_id).execute()
+    except Exception as e:
+        raise e
+
+if st.session_state.get("active_visit"):
+    st.subheader("🧾 Items in this visit")
+    rows = load_items_for_visit(int(st.session_state["active_visit"]["id"]))
+    if rows:
+        df = pd.DataFrame(rows)
+        st.dataframe(df, use_container_width=True)
+        with st.expander("🗑️ Delete an item (if mis-logged)"):
+            ids = [r["id"] for r in rows if "id" in r]
+            choice = st.selectbox("Choose item id", ids) if ids else None
+            st.markdown('<div class="cc-danger">', unsafe_allow_html=True)
+            if st.button("Delete selected", disabled=not bool(ids)):
+                if choice is None:
+                    st.warning("Pick an id.")
+                else:
+                    # try both tables safely
+                    try:
+                        delete_item("visit_items_p", int(choice))
+                    except Exception:
+                        delete_item("visit_items", int(choice))
+                    st.success("Deleted.")
+            st.markdown('</div>', unsafe_allow_html=True)
+    else:
+        st.caption("No items logged for this visit yet.")
+
+# ------------------------ Analytics (light) ------------------------
+st.subheader("📈 Today")
+try:
+    daily = sb.table("v_daily_activity").select("*").execute().data
+    today_str = local_now().strftime("%Y-%m-%d")
+    today = next((r for r in daily if str(r.get("day",""))[:10]==today_str), None)
+    visits = int(today["visits"]) if today and "visits" in today else 0
+    items  = int(today["items"]) if today and "items" in today else 0
+    st.markdown(f"**Visits:** {visits} · **Items:** {items}")
+except Exception:
+    st.caption("Analytics view unavailable yet.")
+
+# ------------------------ Gentle reminder ------------------------
+st.markdown(
+    """<div class="cc-hint">
+    💡 When you’re done, please <b>End Visit</b> and <b>Sign out</b>.<br>
+    We’ll auto-sign you out after inactivity or at 8pm local time. 💜
+    </div>""",
+    unsafe_allow_html=True
+)

backups/pre_test_backup_20250923_202613/requirements.txt

@@ -0,0 +1,9 @@
+streamlit>=1.33
+pandas>=2.1
+Pillow>=10.1
+supabase>=2.5
+huggingface_hub>=0.24.6
+requests>=2.31
+python-dotenv>=1.0.0
+pytz>=2023.3
+

backups/pre_test_backup_20250923_202613/secrets.toml

@@ -0,0 +1,15 @@
+# Supabase connection
+SUPABASE_URL = "https://oudjcqhyldpncjbxohsg.supabase.co"
+SUPABASE_KEY ="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im91ZGpjcWh5bGRwbmNqYnhvaHNnIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTUzMDgyNDQsImV4cCI6MjA3MDg4NDI0NH0.SYwTtCe3r7WOZ25CRggL-lBkvGPjKnQhY_dT4Kjv9Dg"
+
+# App settings
+APP_TZ = "America/Toronto"
+
+# Hugging Face
+HF_TOKEN = "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"
+
+# Optional VLM model provider
+PROVIDER = "nebius"
+GEMMA_MODEL = "google/gemma-3-27b-it"
+NEBIUS_API_KEY = "eyJhbGciOiJIUzI1NiIsImtpZCI6IlV6SXJWd1h0dnprLVRvdzlLZWstc0M1akptWXBvX1VaVkxUZlpnMDRlOFUiLCJ0eXAiOiJKV1QifQ.eyJzdWIiOiJnb29nbGUtb2F1dGgyfDEwMjk4MzMxNjQ1OTQzNjA5ODYxMyIsInNjb3BlIjoib3BlbmlkIG9mZmxpbmVfYWNjZXNzIiwiaXNzIjoiYXBpX2tleV9pc3N1ZXIiLCJhdWQiOlsiaHR0cHM6Ly9uZWJpdXMtaW5mZXJlbmNlLmV1LmF1dGgwLmNvbS9hcGkvdjIvIl0sImV4cCI6MTkxNTEzMTE3MiwidXVpZCI6IjJmOTUxZmM1LWEyNTgtNDg5OC1iNWI4LTkwZTljY2RkZjU2NSIsIm5hbWUiOiJjYXJlIGNvdW50IGFwcCIsImV4cGlyZXNfYXQiOiIyMDMwLTA5LTA4VDIwOjUyOjUyKzAwMDAifQ.awAHOieD93pCnYmFMgRQ64-i6yZdO0XvXczD4eS6xEI"
+NEBIUS_BASE_URL = "https://api.nebius.ai/v1"

backups/pre_test_backup_20250923_202613/streamlit_app.py

@@ -0,0 +1,612 @@
+# --- Care Count (Volunteers → Visits → Items) ---
+# Delightful Laurier-themed UX + enterprise data hygiene
+# - OTP email login (Supabase)
+# - Shift tracking & idle/8pm auto sign-out
+# - Human-friendly visit_code (with DB trigger or safe fallback)
+# - VLM-assisted item name
+# - RPC ingest with validation/quarantine (fallback to direct insert)
+# - Volunteer Impact card (today + lifetime)
+
+from __future__ import annotations
+
+import os, io, time, base64, re, uuid, json
+from datetime import datetime, timedelta
+from typing import Optional
+
+import pytz
+import requests
+import pandas as pd
+import streamlit as st
+from PIL import Image, ImageOps, ImageEnhance
+from supabase import create_client, Client
+
+# ------------------------ App config ------------------------
+os.environ.setdefault("HOME", "/tmp")
+os.environ["STREAMLIT_BROWSER_GATHER_USAGE_STATS"] = "false"
+
+TZ             = os.getenv("APP_TZ", "America/Toronto")
+CUTOFF_HOUR    = int(os.getenv("CUTOFF_HOUR", "20"))   # 8pm local
+INACTIVITY_MIN = int(os.getenv("INACTIVITY_MIN", "30"))
+
+def local_now() -> datetime:
+    return datetime.now(pytz.timezone(TZ))
+
+st.set_page_config(page_title="Care Count", layout="centered")
+st.markdown("""
+<style>
+/* Laurier theme vibes */
+:root { --cc-purple:#6d28d9; --cc-gold:#fde047; --cc-bg:#0b1420; --cc-panel:#0f1a2a; --cc-border:#1d2a44; }
+.block-container { padding-top: 2rem; }
+h1, h2, .stMarkdown h1, .stMarkdown h2 { letter-spacing:.2px }
+.cc-pill { display:inline-block; padding:4px 10px; border-radius:999px; background:var(--cc-gold); color:#111827; font-weight:700; font-size:12px; }
+.cc-hint { background:#10233b; border:1px solid #1f3b5b; color:#e6e8f0; padding:12px 16px; border-radius:10px; }
+.cc-hero { background:#0f1a2a; border:1px solid #1f2a44; padding:16px 18px; border-radius:14px; }
+.cc-btn-primary button { background:var(--cc-purple)!important; color:#fff!important; border:0!important; }
+.cc-danger button { background:#7f1d1d!important; color:#fff!important; }
+.status-card { display:flex; gap:16px; flex-wrap:wrap; }
+.card { background:#0f1a2a; border:1px solid #1f2a44; border-radius:14px; padding:14px 16px; min-width:200px; }
+.card h4 { margin:0 0 6px 0; font-size:0.95rem; color:#cbd5e1 }
+.card .big { font-size:1.6rem; font-weight:700; color:#e5e7eb }
+.small { color:#9aa3b2; font-size:12px }
+</style>
+""", unsafe_allow_html=True)
+
+st.title("💜💛 Care Count")
+st.caption("Thanks for showing up for the community today. Snap items, keep visits tidy, and help us understand the impact of your time.")
+
+# ------------------------ Secrets & client ------------------------
+# Robust env/secrets helpers that work with Streamlit (st.secrets) and .env/CI.
+# Order of precedence: OS env > Streamlit secrets > default.
+
+# Optional: allow plain `python` runs to pick up a local .env if present
+try:
+    from dotenv import load_dotenv  # pip install python-dotenv (optional)
+    load_dotenv()
+except Exception:
+    pass
+
+# Make Streamlit secrets safe to access even when not launched via `streamlit run`
+try:
+    _SECRETS = getattr(st, "secrets", {})
+except Exception:
+    _SECRETS = {}
+
+def _is_useful(val: Optional[str]) -> bool:
+    return val is not None and str(val).strip() != ""
+
+def get_secret(name: str, default: Optional[str] = None) -> Optional[str]:
+    """
+    Flat TOML usage:
+      SUPABASE_URL = "..."
+      SUPABASE_KEY = "..."
+    Looks in OS env first, then st.secrets, else returns default.
+    """
+    # 1) OS env
+    v = os.getenv(name)
+    if _is_useful(v):
+        return v
+
+    # 2) Streamlit secrets (flat)
+    try:
+        if hasattr(_SECRETS, "get"):
+            v = _SECRETS.get(name, default)
+            if _is_useful(v):
+                return v
+    except Exception:
+        pass
+
+    # 3) default
+    return default
+
+def require_secret(name: str) -> str:
+    """
+    Same as get_secret but fails fast with a clear error if missing/blank.
+    """
+    v = get_secret(name, None)
+    if not _is_useful(v):
+        st.error(
+            f"Missing secret: {name}. "
+            "Ensure it exists as an environment variable or in .streamlit/secrets.toml"
+        )
+        st.stop()
+    return str(v)
+
+# (Optional) lightweight visibility check during setup. Comment out in prod.
+# st.write("Secrets present:",
+#          bool(get_secret("SUPABASE_URL")),
+#          bool(get_secret("SUPABASE_KEY")))
+
+# Required Supabase credentials (flat keys)
+SUPABASE_URL = require_secret("SUPABASE_URL")
+SUPABASE_KEY = require_secret("SUPABASE_KEY")   # anon key (RLS should be ON)
+
+# Initialize Supabase client
+sb: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+
+# Optional provider/config (all flat keys with safe defaults)
+PROVIDER         = (get_secret("PROVIDER", "nebius") or "nebius").strip().lower()
+GEMMA_MODEL      = (get_secret("GEMMA_MODEL", "google/gemma-3-27b-it") or "google/gemma-3-27b-it").strip()
+NEBIUS_API_KEY   = get_secret("NEBIUS_API_KEY")
+NEBIUS_BASE_URL  = get_secret("NEBIUS_BASE_URL", "https://api.nebius.ai/v1")
+FEATH_API_KEY    = get_secret("FEATHERLESS_API_KEY")
+FEATH_BASE_URL   = get_secret("FEATHERLESS_BASE_URL", "https://api.featherless.ai/v1")
+
+
+
+st.caption(f"Provider: `{PROVIDER}` · Model: `{GEMMA_MODEL}` · TZ: `{TZ}`")
+
+# ------------------------ Light events/audit (non-blocking) ------------------------
+def log_event(action: str, actor: Optional[str], details: dict):
+    try:
+        sb.table("events").insert({"actor_email": actor, "action": action, "details": details}).execute()
+    except Exception:
+        pass
+
+# ------------------------ Auth (Email OTP) ------------------------
+def auth_block() -> tuple[bool, Optional[str]]:
+    if "auth_email" not in st.session_state:
+        st.session_state["auth_email"] = None
+    if "user_email" in st.session_state:
+        return True, st.session_state["user_email"]
+
+    st.subheader("Sign in")
+    with st.form("otp_request", clear_on_submit=False, border=False):
+        email = st.text_input("Email", value=st.session_state.get("auth_email") or "", autocomplete="email")
+        send = st.form_submit_button("Send login code")
+        if send:
+            if not email or "@" not in email:
+                st.error("Please enter a valid email.")
+            else:
+                try:
+                    sb.auth.sign_in_with_otp({"email": email, "shouldCreateUser": True})
+                    st.session_state["auth_email"] = email
+                    st.success("We emailed you a one-time code. Enter it to continue.")
+                except Exception as e:
+                    st.error(f"Could not send code: {e}")
+
+    if st.session_state.get("auth_email"):
+        with st.form("otp_verify", clear_on_submit=True, border=False):
+            code = st.text_input("Enter 6-digit code", max_chars=6)
+            ok = st.form_submit_button("Verify & start shift")
+            if ok:
+                try:
+                    res = sb.auth.verify_otp({"email": st.session_state["auth_email"], "token": code, "type": "email"})
+                    if res and res.user:
+                        email = st.session_state["auth_email"]
+                        # Idempotent upsert for volunteer & start shift
+                        sb.table("volunteers").upsert({
+                            "email": email,
+                            "last_login_at": datetime.utcnow().isoformat(),
+                            "shift_started_at": datetime.utcnow().isoformat(),
+                            "shift_ended_at": None
+                        }, on_conflict="email").execute()
+                        st.session_state["user_email"] = email
+                        st.session_state["shift_started"] = True
+                        st.session_state["last_activity_at"] = local_now()
+                        log_event("login", email, {"method":"otp"})
+                        st.toast("Welcome back! Shift started. 💜", icon="✅")
+                        return True, email
+                except Exception as e:
+                    st.error(f"Verification failed: {e}")
+    return False, None
+
+def end_shift(email: str, reason: str):
+    try:
+        sb.table("volunteers").update({"shift_ended_at": datetime.utcnow().isoformat()}).eq("email", email).execute()
+        log_event("shift_end", email, {"reason": reason})
+    except Exception:
+        pass
+
+def guard_cutoff_and_idle(email: str):
+    now = local_now()
+    last = st.session_state.get("last_activity_at")
+    if last and (now - last).total_seconds() > INACTIVITY_MIN * 60:
+        end_shift(email, "inactivity")
+        st.session_state.clear()
+        st.info("You were logged out due to inactivity. Thank you for volunteering today!")
+        st.stop()
+    st.session_state["last_activity_at"] = now
+
+    cutoff = now.replace(hour=CUTOFF_HOUR, minute=0, second=0, microsecond=0)
+    if now >= cutoff:
+        end_shift(email, "cutoff_8pm")
+        st.session_state.clear()
+        st.info("We close the day at 8pm. Your shift has been ended. Thank you so much!")
+        st.stop()
+
+signed_in, user_email = auth_block()
+if not signed_in:
+    st.stop()
+guard_cutoff_and_idle(user_email)
+
+# Welcome banner (visceral, kind)
+st.markdown(
+    f"""<div class="cc-hero">
+    <div class="small">Welcome,</div>
+    <div style="font-weight:800;font-size:1.15rem"> {user_email}</div>
+    <div class="small">Thank you for showing up for the community today. 💜💛</div>
+    </div>""",
+    unsafe_allow_html=True
+)
+
+# Sign-out button (prominent)
+c_signout = st.columns([1,1,6])[1]
+with c_signout:
+    st.markdown('<div class="cc-btn-primary">', unsafe_allow_html=True)
+    if st.button("🔒 Sign out"):
+        end_shift(user_email, "manual")
+        st.session_state.clear()
+        st.success("Signed out. See you next time!")
+        st.stop()
+    st.markdown('</div>', unsafe_allow_html=True)
+
+# ------------------------ Volunteer Impact card ------------------------
+def fetch_volunteer_row(email: str) -> dict | None:
+    try:
+        return sb.table("volunteers").select("*").eq("email", email).single().execute().data
+    except Exception:
+        return None
+
+def items_today(email: str) -> int:
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        # try partitioned table first
+        data = sb.table("visit_items_p").select("id,timestamp,volunteer") \
+                .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                .eq("volunteer", email).execute().data
+        return len(data or [])
+    except Exception:
+        try:
+            data = sb.table("visit_items").select("id,timestamp,volunteer") \
+                    .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                    .eq("volunteer", email).execute().data
+            return len(data or [])
+        except Exception:
+            return 0
+
+vrow = fetch_volunteer_row(user_email) or {}
+shift_started_at = vrow.get("shift_started_at")
+lifetime_hours = vrow.get("total_hours")  # may not exist yet; handled below
+mins_active = 0
+try:
+    if shift_started_at:
+        t0 = datetime.fromisoformat(str(shift_started_at).replace("Z","+00:00"))
+        mins_active = max(0, int((datetime.utcnow() - t0).total_seconds() // 60))
+except Exception:
+    pass
+
+st.markdown('<div class="status-card">', unsafe_allow_html=True)
+st.markdown(f'<div class="card"><h4>Shift active</h4><div class="big">{mins_active} min</div><div class="small">since you signed in</div></div>', unsafe_allow_html=True)
+st.markdown(f'<div class="card"><h4>Items you logged today</h4><div class="big">{items_today(user_email)}</div></div>', unsafe_allow_html=True)
+if isinstance(lifetime_hours, (int, float)):
+    st.markdown(f'<div class="card"><h4>Lifetime hours</h4><div class="big">{round(float(lifetime_hours),1)}</div></div>', unsafe_allow_html=True)
+st.markdown('</div>', unsafe_allow_html=True)
+
+# ------------------------ Image helpers ------------------------
+def _to_png_bytes(img: Image.Image) -> bytes:
+    b = io.BytesIO(); img.save(b, format="PNG"); return b.getvalue()
+
+def preprocess_for_label(img: Image.Image) -> Image.Image:
+    img = img.convert("RGB")
+    w, h = img.size
+    scale = 1024 / max(w, h) if max(w, h) > 1024 else 1.0
+    if scale < 1.0: img = img.resize((int(w * scale), int(h * scale)))
+    img = ImageOps.autocontrast(img, cutoff=2)
+    img = ImageEnhance.Brightness(img).enhance(1.06)
+    img = ImageEnhance.Contrast(img).enhance(1.05)
+    img = ImageEnhance.Sharpness(img).enhance(1.15)
+    return img
+
+# ------------------------ VLM client ------------------------
+SYSTEM_HINT = "You label item being held in the image for a food bank. Return ONLY the item name."
+
+def _openai_style_chat(base_url: str, api_key: str, model_id: str, img_bytes: bytes) -> str:
+    b64 = base64.b64encode(img_bytes).decode("utf-8")
+    url = f"{base_url.rstrip('/')}/chat/completions"
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    payload = {
+        "model": model_id,
+        "temperature": 0,
+        "messages": [
+            {"role": "system", "content": SYSTEM_HINT},
+            {"role": "user", "content": [
+                {"type": "text", "text": "What is the name of the item in the picture? Return only the item name."},
+                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}}
+            ]}
+        ]
+    }
+    r = requests.post(url, json=payload, headers=headers, timeout=90)
+    if r.status_code != 200:
+        raise RuntimeError(f"LLM HTTP {r.status_code}: {r.text[:200]}")
+    data = r.json()
+    return (data["choices"][0]["message"]["content"] or "").strip()
+
+def gemma_item_name(img_bytes: bytes) -> str:
+    if PROVIDER == "nebius":
+        if not NEBIUS_API_KEY: raise RuntimeError("NEBIUS_API_KEY missing")
+        return _openai_style_chat(NEBIUS_BASE_URL, NEBIUS_API_KEY, GEMMA_MODEL, img_bytes)
+    elif PROVIDER == "featherless":
+        if not FEATH_API_KEY: raise RuntimeError("FEATHERLESS_API_KEY missing")
+        return _openai_style_chat(FEATH_BASE_URL, FEATH_API_KEY, GEMMA_MODEL, img_bytes)
+    else:
+        raise RuntimeError(f"Unknown PROVIDER: {PROVIDER}")
+
+# ------------------------ Normalization ------------------------
+BRANDS = {
+    "whiskas","tetley","kellogg's","kelloggs","campbell's","campbells","heinz",
+    "nestle","kraft","general mills","cheerios","oreo","oreos","pringles","lays","doritos",
+    "ice river","green bottle","great value","wheat thins","vegetable thins","raid"
+}
+GENERIC_TYPES = {
+    "water","toothpaste","deodorant","antiperspirant","soap","shampoo","conditioner",
+    "lotion","tea","coffee","cereal","pasta","rice","beans","sauce","salsa","cleaner",
+    "peanut butter","jam","jelly","tuna","chicken","beef","flour","sugar","salt","oil",
+    "crackers","cookies","soup","insect killer","spray"
+}
+def normalize_item_name(s: str) -> str:
+    s = (s or "").strip()
+    if not s: return ""
+    low = re.sub(r"[®™]", "", s.lower())
+    for b in BRANDS: low = low.replace(b, "")
+    chosen = None
+    for t in GENERIC_TYPES:
+        if t in low: chosen = t; break
+    cleaned = " ".join(low.split())
+    return (chosen or cleaned.title())[:120]
+
+def clean_text(v: Optional[str], maxlen: int = 120) -> Optional[str]:
+    if not v: return None
+    v = re.sub(r"\s+", " ", v).strip()
+    return v[:maxlen] if v else None
+
+# ------------------------ Visit flow ------------------------
+st.subheader("🪪 Anonymous Student Visit")
+
+active_visit = st.session_state.get("active_visit")
+
+def fallback_visit_code() -> str:
+    """Readable visit_code if DB trigger isn't present."""
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        todays = sb.table("visits").select("id,started_at").gte("started_at", f"{day} 00:00:00") \
+                 .lte("started_at", f"{day} 23:59:59").execute().data or []
+        seq = len(todays) + 1
+    except Exception:
+        seq = int(time.time()) % 1000
+    return f"V-{seq}-{local_now().strftime('%Y%m%d')}-{str(uuid.uuid4())[:6]}"
+
+c1, c2, c3 = st.columns(3)
+with c1:
+    st.markdown('<div class="cc-btn-primary">', unsafe_allow_html=True)
+    if not active_visit and st.button("Start Visit"):
+        try:
+            payload = {
+                "visit_code": fallback_visit_code(),  # DB trigger will override if present
+                "started_at": datetime.utcnow().isoformat(),
+                "ended_at": None,
+                "created_by": user_email
+            }
+            v = sb.table("visits").insert(payload).execute().data[0]
+            # If trigger generated code, keep that
+            if not v.get("visit_code"):
+                v["visit_code"] = payload["visit_code"]
+            st.session_state["active_visit"] = v
+            st.success(f"Visit #{v['id']} started · code: **{v['visit_code']}**")
+            log_event("visit_start", user_email, {"visit_id": v["id"], "visit_code": v["visit_code"]})
+        except Exception as e:
+            st.error(f"Could not start visit: {e}")
+    st.markdown('</div>', unsafe_allow_html=True)
+
+with c2:
+    if active_visit and st.button("End Visit (Checkout)"):
+        try:
+            sb.table("visits").update({"ended_at": datetime.utcnow().isoformat()}) \
+              .eq("id", active_visit["id"]).execute()
+            st.success("Visit checked out. Ready for the next student.")
+            log_event("visit_end", user_email, {"visit_id": active_visit["id"]})
+            st.session_state.pop("active_visit", None)
+        except Exception as e:
+            st.error(f"Could not end visit: {e}")
+
+with c3:
+    if st.session_state.get("active_visit"):
+        v = st.session_state["active_visit"]
+        st.caption(f"Active visit_id: {v['id']} · code: {v.get('visit_code','')}")
+    else:
+        st.caption("No active visit.")
+
+# ------------------------ Identify item ------------------------
+st.subheader("📸 Identify item from image")
+
+c4, c5 = st.columns(2)
+with c4: cam = st.camera_input("Use your phone or webcam")
+with c5: up  = st.file_uploader("…or upload an image", type=["png","jpg","jpeg"])
+
+img_file = cam or up
+if img_file:
+    img = Image.open(img_file).convert("RGB")
+    st.image(img, use_container_width=True)
+    if st.button("🔍 Ask model for item name"):
+        t0, raw = time.time(), ""
+        try:
+            pre = preprocess_for_label(img); raw = gemma_item_name(_to_png_bytes(pre))
+        except Exception as e:
+            st.error(f"Provider error: {e}"); log_event("vlm_error", user_email, {"error": str(e)})
+        norm = normalize_item_name(raw)
+        if raw: st.success(f"🧠 Model: **{raw}**")
+        st.info(f"✨ Normalized: **{norm or '(unknown)'}** · ⏱️ {time.time()-t0:.2f}s")
+        st.session_state["scanned_item_name"] = norm or raw or ""
+        st.session_state["last_activity_at"] = local_now()
+
+# ------------------------ Log item ------------------------
+st.subheader("📬 Log item to current visit")
+
+item_name = st.text_input("Item name", value=st.session_state.get("scanned_item_name",""))
+quantity  = st.number_input("Quantity", min_value=1, max_value=9999, step=1, value=1)
+category  = st.text_input("Category (optional)")
+unit      = st.text_input("Unit (optional, e.g., 500 mL, 1 L, 250 g)")
+barcode   = st.text_input("Barcode (optional)")
+
+def deterministic_ingest_id(v_id: int, email: str, name: str, qty: int, ts_iso: str) -> str:
+    key = f"visit_items::{v_id}::{email}::{name}::{qty}::{ts_iso}"
+    return str(uuid.uuid5(uuid.NAMESPACE_URL, key))
+
+def try_rpc_ingest(email: str, v_id: int, name: str, qty: int,
+                   category: Optional[str], unit: Optional[str],
+                   barcode: Optional[str], ts_iso: str, ingest_id: str) -> tuple[bool,str]:
+    """
+    Call the RPC safe_ingest_visit_item if it exists.
+    Returns (ok, msg). If function is missing, raises to trigger fallback.
+    """
+    try:
+        res = sb.rpc("safe_ingest_visit_item", {
+            "p_email": email,
+            "p_visit_id": v_id,
+            "p_item_name": name,
+            "p_qty": qty,
+            "p_category": category,
+            "p_unit": unit,
+            "p_barcode": barcode,
+            "p_ts": ts_iso,
+            "p_ingest_id": ingest_id
+        }).execute()
+        # RPC returns a setof (ok boolean, msg text) — normalize
+        rows = res.data if isinstance(res.data, list) else []
+        if rows:
+            r0 = rows[0]
+            ok = bool(r0.get("ok", False))
+            msg = str(r0.get("msg", ""))
+            return ok, msg or ("ok" if ok else "failed")
+        # Some PostgREST setups return {} — treat as ok
+        return True, "ok"
+    except Exception as e:
+        # If function missing (42883) or not exposed, re-raise to use fallback
+        raise e
+
+def fallback_direct_insert(email: str, v_id: int, name: str, qty: int,
+                           category: Optional[str], unit: Optional[str],
+                           barcode: Optional[str], ts_iso: str, ingest_id: str) -> None:
+    """Write into visit_items_p if present, else visit_items (keeps app working)."""
+    payload = {
+        "visit_id": v_id,
+        "timestamp": ts_iso,
+        "volunteer": email,
+        "item_name": name,
+        "category": category,
+        "unit": unit,
+        "qty": qty,
+        "barcode": barcode,
+        "weather_type": None,
+        "temp_c": None,
+        "ingest_id": ingest_id
+    }
+    try:
+        sb.table("visit_items_p").insert(payload).execute()
+    except Exception:
+        # legacy table fallback
+        payload.pop("ingest_id", None)
+        sb.table("visit_items").insert(payload).execute()
+
+st.markdown('<div class="cc-btn-primary">', unsafe_allow_html=True)
+save_disabled = not st.session_state.get("active_visit")
+if st.button("✅ Save Item to Visit", disabled=save_disabled):
+    v = st.session_state.get("active_visit")
+    if not v:
+        st.warning("Start a visit first, then save items.")
+    else:
+        name_clean = clean_text(item_name, 120)
+        if not name_clean:
+            st.warning("Item name is required.")
+        else:
+            ts_iso = datetime.utcnow().isoformat()
+            ingest_id = deterministic_ingest_id(int(v["id"]), user_email, name_clean, int(quantity), ts_iso)
+            try:
+                ok, msg = try_rpc_ingest(
+                    email=user_email, v_id=int(v["id"]), name=name_clean, qty=int(quantity),
+                    category=clean_text(category, 80), unit=clean_text(unit, 40),
+                    barcode=clean_text(barcode, 64), ts_iso=ts_iso, ingest_id=ingest_id
+                )
+                if ok:
+                    st.success("Item logged ✅")
+                else:
+                    st.warning(f"Ingest said: {msg}. (Will try direct insert.)")
+                    fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                           clean_text(category,80), clean_text(unit,40),
+                                           clean_text(barcode,64), ts_iso, ingest_id)
+                    st.success("Item logged ✅ (fallback)")
+            except Exception as e:
+                # RPC missing or failed → direct insert
+                try:
+                    fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                           clean_text(category,80), clean_text(unit,40),
+                                           clean_text(barcode,64), ts_iso, ingest_id)
+                    st.success("Item logged ✅ (fallback)")
+                except Exception as e2:
+                    st.error(f"Ingest failed: {e2}")
+            st.session_state["last_activity_at"] = local_now()
+            st.session_state["scanned_item_name"] = name_clean
+st.markdown('</div>', unsafe_allow_html=True)
+
+# ------------------------ Visit items view + delete ------------------------
+def load_items_for_visit(visit_id: int) -> list[dict]:
+    # Prefer partitioned table
+    try:
+        return sb.table("visit_items_p").select("*").eq("visit_id", visit_id) \
+            .order("timestamp", desc=True).limit(500).execute().data or []
+    except Exception:
+        try:
+            return sb.table("visit_items").select("*").eq("visit_id", visit_id) \
+                .order("timestamp", desc=True).limit(500).execute().data or []
+        except Exception:
+            return []
+
+def delete_item(table: str, item_id: int):
+    try:
+        sb.table(table).delete().eq("id", item_id).execute()
+    except Exception as e:
+        raise e
+
+if st.session_state.get("active_visit"):
+    st.subheader("🧾 Items in this visit")
+    rows = load_items_for_visit(int(st.session_state["active_visit"]["id"]))
+    if rows:
+        df = pd.DataFrame(rows)
+        st.dataframe(df, use_container_width=True)
+        with st.expander("🗑️ Delete an item (if mis-logged)"):
+            ids = [r["id"] for r in rows if "id" in r]
+            choice = st.selectbox("Choose item id", ids) if ids else None
+            st.markdown('<div class="cc-danger">', unsafe_allow_html=True)
+            if st.button("Delete selected", disabled=not bool(ids)):
+                if choice is None:
+                    st.warning("Pick an id.")
+                else:
+                    # try both tables safely
+                    try:
+                        delete_item("visit_items_p", int(choice))
+                    except Exception:
+                        delete_item("visit_items", int(choice))
+                    st.success("Deleted.")
+            st.markdown('</div>', unsafe_allow_html=True)
+    else:
+        st.caption("No items logged for this visit yet.")
+
+# ------------------------ Analytics (light) ------------------------
+st.subheader("📈 Today")
+try:
+    daily = sb.table("v_daily_activity").select("*").execute().data
+    today_str = local_now().strftime("%Y-%m-%d")
+    today = next((r for r in daily if str(r.get("day",""))[:10]==today_str), None)
+    visits = int(today["visits"]) if today and "visits" in today else 0
+    items  = int(today["items"]) if today and "items" in today else 0
+    st.markdown(f"**Visits:** {visits} · **Items:** {items}")
+except Exception:
+    st.caption("Analytics view unavailable yet.")
+
+# ------------------------ Gentle reminder ------------------------
+st.markdown(
+    """<div class="cc-hint">
+    💡 When you’re done, please <b>End Visit</b> and <b>Sign out</b>.<br>
+    We’ll auto-sign you out after inactivity or at 8pm local time. 💜
+    </div>""",
+    unsafe_allow_html=True
+)

backups/pre_test_backup_20250923_202627/requirements.txt

@@ -0,0 +1,9 @@
+streamlit>=1.33
+pandas>=2.1
+Pillow>=10.1
+supabase>=2.5
+huggingface_hub>=0.24.6
+requests>=2.31
+python-dotenv>=1.0.0
+pytz>=2023.3
+

backups/pre_test_backup_20250923_202627/secrets.toml

@@ -0,0 +1,15 @@
+# Supabase connection
+SUPABASE_URL = "https://oudjcqhyldpncjbxohsg.supabase.co"
+SUPABASE_KEY ="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im91ZGpjcWh5bGRwbmNqYnhvaHNnIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTUzMDgyNDQsImV4cCI6MjA3MDg4NDI0NH0.SYwTtCe3r7WOZ25CRggL-lBkvGPjKnQhY_dT4Kjv9Dg"
+
+# App settings
+APP_TZ = "America/Toronto"
+
+# Hugging Face
+HF_TOKEN = "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"
+
+# Optional VLM model provider
+PROVIDER = "nebius"
+GEMMA_MODEL = "google/gemma-3-27b-it"
+NEBIUS_API_KEY = "eyJhbGciOiJIUzI1NiIsImtpZCI6IlV6SXJWd1h0dnprLVRvdzlLZWstc0M1akptWXBvX1VaVkxUZlpnMDRlOFUiLCJ0eXAiOiJKV1QifQ.eyJzdWIiOiJnb29nbGUtb2F1dGgyfDEwMjk4MzMxNjQ1OTQzNjA5ODYxMyIsInNjb3BlIjoib3BlbmlkIG9mZmxpbmVfYWNjZXNzIiwiaXNzIjoiYXBpX2tleV9pc3N1ZXIiLCJhdWQiOlsiaHR0cHM6Ly9uZWJpdXMtaW5mZXJlbmNlLmV1LmF1dGgwLmNvbS9hcGkvdjIvIl0sImV4cCI6MTkxNTEzMTE3MiwidXVpZCI6IjJmOTUxZmM1LWEyNTgtNDg5OC1iNWI4LTkwZTljY2RkZjU2NSIsIm5hbWUiOiJjYXJlIGNvdW50IGFwcCIsImV4cGlyZXNfYXQiOiIyMDMwLTA5LTA4VDIwOjUyOjUyKzAwMDAifQ.awAHOieD93pCnYmFMgRQ64-i6yZdO0XvXczD4eS6xEI"
+NEBIUS_BASE_URL = "https://api.nebius.ai/v1"

backups/pre_test_backup_20250923_202627/streamlit_app.py

@@ -0,0 +1,891 @@
+# --- Care Count (Volunteers → Visits → Items) ---
+# Modern UI/UX with industry-standard design patterns
+# Enhanced version with improved user experience
+
+from __future__ import annotations
+
+import os, io, time, base64, re, uuid, json
+from datetime import datetime, timedelta
+from typing import Optional
+import logging
+
+import pytz
+import requests
+import pandas as pd
+import streamlit as st
+from PIL import Image, ImageOps, ImageEnhance
+from supabase import create_client, Client
+
+# Import our modern UI components
+from ui_improvements import ModernUIComponents, apply_modern_ui, create_modern_layout
+
+# ------------------------ Enhanced Logging ------------------------
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('care_count.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# ------------------------ App config ------------------------
+os.environ.setdefault("HOME", "/tmp")
+os.environ["STREAMLIT_BROWSER_GATHER_USAGE_STATS"] = "false"
+
+TZ             = os.getenv("APP_TZ", "America/Toronto")
+CUTOFF_HOUR    = int(os.getenv("CUTOFF_HOUR", "20"))   # 8pm local
+INACTIVITY_MIN = int(os.getenv("INACTIVITY_MIN", "30"))
+
+def local_now() -> datetime:
+    return datetime.now(pytz.timezone(TZ))
+
+# Enhanced page config with modern settings
+st.set_page_config(
+    page_title="Care Count - Volunteer Management",
+    page_icon="💜",
+    layout="wide",
+    initial_sidebar_state="expanded",
+    menu_items={
+        'Get Help': 'https://github.com/your-repo/care-count',
+        'Report a bug': "https://github.com/your-repo/care-count/issues",
+        'About': "# Care Count\nVolunteer management system for community impact tracking"
+    }
+)
+
+# Apply modern UI styling
+apply_modern_ui()
+
+# ------------------------ Enhanced Secrets Management ------------------------
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except Exception:
+    pass
+
+try:
+    _SECRETS = getattr(st, "secrets", {})
+except Exception:
+    _SECRETS = {}
+
+def _is_useful(val: Optional[str]) -> bool:
+    return val is not None and str(val).strip() != ""
+
+def get_secret(name: str, default: Optional[str] = None) -> Optional[str]:
+    """Enhanced secret management with logging"""
+    v = os.getenv(name)
+    if _is_useful(v):
+        logger.info(f"Secret {name} loaded from environment")
+        return v
+
+    try:
+        if hasattr(_SECRETS, "get"):
+            v = _SECRETS.get(name, default)
+            if _is_useful(v):
+                logger.info(f"Secret {name} loaded from Streamlit secrets")
+                return v
+    except Exception as e:
+        logger.warning(f"Failed to load secret {name} from Streamlit secrets: {e}")
+
+    return default
+
+def require_secret(name: str) -> str:
+    """Enhanced secret requirement with better error handling"""
+    v = get_secret(name, None)
+    if not _is_useful(v):
+        st.error(
+            f"🔐 **Configuration Error**\n\n"
+            f"Missing required configuration: `{name}`\n\n"
+            f"Please ensure this is set in your environment variables or `.streamlit/secrets.toml` file.\n\n"
+            f"For help, check the [documentation](https://github.com/your-repo/care-count#configuration)."
+        )
+        st.stop()
+    return str(v)
+
+# Required Supabase credentials
+SUPABASE_URL = require_secret("SUPABASE_URL")
+SUPABASE_KEY = require_secret("SUPABASE_KEY")
+
+# Initialize Supabase client with error handling
+try:
+    sb: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+    logger.info("Supabase client initialized successfully")
+except Exception as e:
+    st.error(f"Failed to connect to Supabase: {e}")
+    logger.error(f"Supabase connection failed: {e}")
+    st.stop()
+
+# Optional provider/config
+PROVIDER         = (get_secret("PROVIDER", "nebius") or "nebius").strip().lower()
+GEMMA_MODEL      = (get_secret("GEMMA_MODEL", "google/gemma-3-27b-it") or "google/gemma-3-27b-it").strip()
+NEBIUS_API_KEY   = get_secret("NEBIUS_API_KEY")
+NEBIUS_BASE_URL  = get_secret("NEBIUS_BASE_URL", "https://api.nebius.ai/v1")
+FEATH_API_KEY    = get_secret("FEATHERLESS_API_KEY")
+FEATH_BASE_URL   = get_secret("FEATHERLESS_BASE_URL", "https://api.featherless.ai/v1")
+
+# ------------------------ Enhanced Event Logging ------------------------
+def log_event(action: str, actor: Optional[str], details: dict, level: str = "info"):
+    """Enhanced event logging with multiple levels"""
+    log_data = {
+        "timestamp": datetime.utcnow().isoformat(),
+        "action": action,
+        "actor_email": actor,
+        "details": details,
+        "level": level
+    }
+    
+    # Log to file
+    if level == "error":
+        logger.error(f"Event: {action} by {actor} - {details}")
+    elif level == "warning":
+        logger.warning(f"Event: {action} by {actor} - {details}")
+    else:
+        logger.info(f"Event: {action} by {actor} - {details}")
+    
+    # Log to database
+    try:
+        sb.table("events").insert(log_data).execute()
+    except Exception as e:
+        logger.error(f"Failed to log event to database: {e}")
+
+# ------------------------ Modern Authentication UI ------------------------
+def auth_block() -> tuple[bool, Optional[str]]:
+    """Enhanced authentication with modern UI"""
+    if "auth_email" not in st.session_state:
+        st.session_state["auth_email"] = None
+    if "user_email" in st.session_state:
+        return True, st.session_state["user_email"]
+
+    # Modern hero section for login
+    st.markdown(ModernUIComponents.create_hero_section(
+        "Care Count",
+        "Thanks for showing up for the community today. Snap items, keep visits tidy, and help us understand the impact of your time."
+    ))
+
+    # Modern login form
+    with st.container():
+        st.markdown('<div class="modern-card">', unsafe_allow_html=True)
+        st.subheader("🔐 Sign In")
+        st.markdown("Enter your email to receive a secure login code.")
+        
+        with st.form("otp_request", clear_on_submit=False):
+            email = st.text_input(
+                "Email Address", 
+                value=st.session_state.get("auth_email") or "", 
+                placeholder="your.email@example.com",
+                help="We'll send you a secure 6-digit code"
+            )
+            
+            col1, col2, col3 = st.columns([1, 2, 1])
+            with col2:
+                send = st.form_submit_button("📧 Send Login Code", use_container_width=True)
+            
+            if send:
+                if not email or "@" not in email:
+                    st.error("Please enter a valid email address.")
+                else:
+                    try:
+                        with st.spinner("Sending login code..."):
+                            sb.auth.sign_in_with_otp({"email": email, "shouldCreateUser": True})
+                            st.session_state["auth_email"] = email
+                            st.success("✅ Login code sent! Check your email.")
+                            log_event("otp_requested", email, {"method": "email"})
+                    except Exception as e:
+                        st.error(f"❌ Could not send code: {e}")
+                        log_event("otp_failed", email, {"error": str(e)}, "error")
+
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    # OTP verification form
+    if st.session_state.get("auth_email"):
+        with st.container():
+            st.markdown('<div class="modern-card">', unsafe_allow_html=True)
+            st.subheader("🔢 Verify Code")
+            st.markdown(f"Enter the 6-digit code sent to **{st.session_state['auth_email']}**")
+            
+            with st.form("otp_verify", clear_on_submit=True):
+                code = st.text_input(
+                    "Verification Code", 
+                    max_chars=6,
+                    placeholder="123456",
+                    help="Enter the 6-digit code from your email"
+                )
+                
+                col1, col2, col3 = st.columns([1, 2, 1])
+                with col2:
+                    ok = st.form_submit_button("✅ Verify & Start Shift", use_container_width=True)
+                
+                if ok:
+                    if len(code) != 6 or not code.isdigit():
+                        st.error("Please enter a valid 6-digit code.")
+                    else:
+                        try:
+                            with st.spinner("Verifying code..."):
+                                res = sb.auth.verify_otp({"email": st.session_state["auth_email"], "token": code, "type": "email"})
+                                if res and res.user:
+                                    email = st.session_state["auth_email"]
+                                    
+                                    # Enhanced volunteer upsert
+                                    volunteer_data = {
+                                        "email": email,
+                                        "last_login_at": datetime.utcnow().isoformat(),
+                                        "shift_started_at": datetime.utcnow().isoformat(),
+                                        "shift_ended_at": None,
+                                        "login_count": 1  # Track login frequency
+                                    }
+                                    
+                                    sb.table("volunteers").upsert(volunteer_data, on_conflict="email").execute()
+                                    
+                                    st.session_state["user_email"] = email
+                                    st.session_state["shift_started"] = True
+                                    st.session_state["last_activity_at"] = local_now()
+                                    
+                                    log_event("login_success", email, {"method": "otp"})
+                                    st.success("🎉 Welcome back! Your shift has started.")
+                                    st.balloons()
+                                    return True, email
+                        except Exception as e:
+                            st.error(f"❌ Verification failed: {e}")
+                            log_event("otp_verification_failed", st.session_state["auth_email"], {"error": str(e)}, "error")
+            
+            st.markdown('</div>', unsafe_allow_html=True)
+    
+    return False, None
+
+def end_shift(email: str, reason: str):
+    """Enhanced shift ending with better logging"""
+    try:
+        end_time = datetime.utcnow().isoformat()
+        sb.table("volunteers").update({"shift_ended_at": end_time}).eq("email", email).execute()
+        log_event("shift_end", email, {"reason": reason, "end_time": end_time})
+    except Exception as e:
+        logger.error(f"Failed to end shift for {email}: {e}")
+
+def guard_cutoff_and_idle(email: str):
+    """Enhanced session management with better UX"""
+    now = local_now()
+    last = st.session_state.get("last_activity_at")
+    
+    if last and (now - last).total_seconds() > INACTIVITY_MIN * 60:
+        end_shift(email, "inactivity")
+        st.session_state.clear()
+        st.warning("⏰ You were logged out due to inactivity. Thank you for volunteering today!")
+        st.stop()
+    
+    st.session_state["last_activity_at"] = now
+
+    cutoff = now.replace(hour=CUTOFF_HOUR, minute=0, second=0, microsecond=0)
+    if now >= cutoff:
+        end_shift(email, "cutoff_8pm")
+        st.session_state.clear()
+        st.info("🌅 We close the day at 8pm. Your shift has been ended. Thank you so much!")
+        st.stop()
+
+# ------------------------ Main App Flow ------------------------
+def main():
+    """Main application flow with modern UI"""
+    
+    # Authentication
+    signed_in, user_email = auth_block()
+    if not signed_in:
+        st.stop()
+    
+    guard_cutoff_and_idle(user_email)
+
+    # Modern welcome section
+    st.markdown(ModernUIComponents.create_hero_section(
+        "Care Count Dashboard",
+        "Manage visits, track items, and make a difference in your community.",
+        user_email
+    ))
+
+    # Enhanced status cards
+    vrow = fetch_volunteer_row(user_email) or {}
+    shift_started_at = vrow.get("shift_started_at")
+    lifetime_hours = vrow.get("total_hours", 0)
+    
+    mins_active = 0
+    try:
+        if shift_started_at:
+            t0 = datetime.fromisoformat(str(shift_started_at).replace("Z","+00:00"))
+            mins_active = max(0, int((datetime.utcnow() - t0).total_seconds() // 60))
+    except Exception:
+        pass
+
+    status_data = {
+        "shift_active": f"{mins_active} min",
+        "items_today": items_today(user_email),
+        "lifetime_hours": f"{round(float(lifetime_hours), 1)} hrs" if isinstance(lifetime_hours, (int, float)) else "0.0 hrs"
+    }
+    
+    st.markdown(ModernUIComponents.create_status_cards(status_data), unsafe_allow_html=True)
+
+    # Modern sign-out button
+    col1, col2, col3 = st.columns([1, 1, 1])
+    with col2:
+        if st.button("🔒 Sign Out", use_container_width=True, type="secondary"):
+            end_shift(user_email, "manual")
+            st.session_state.clear()
+            st.success("✅ Signed out successfully. See you next time!")
+            st.rerun()
+
+    # Enhanced visit management section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "🪪 Visit Management",
+        "Start and manage student visits with unique tracking codes"
+    ), unsafe_allow_html=True)
+    
+    active_visit = st.session_state.get("active_visit")
+    
+    col1, col2, col3 = st.columns([1, 1, 1])
+    
+    with col1:
+        if not active_visit and st.button("🚀 Start New Visit", use_container_width=True, type="primary"):
+            try:
+                with st.spinner("Creating visit..."):
+                    payload = {
+                        "visit_code": fallback_visit_code(),
+                        "started_at": datetime.utcnow().isoformat(),
+                        "ended_at": None,
+                        "created_by": user_email
+                    }
+                    v = sb.table("visits").insert(payload).execute().data[0]
+                    if not v.get("visit_code"):
+                        v["visit_code"] = payload["visit_code"]
+                    st.session_state["active_visit"] = v
+                    st.success(f"✅ Visit #{v['id']} started")
+                    st.info(f"**Visit Code:** `{v['visit_code']}`")
+                    log_event("visit_start", user_email, {"visit_id": v["id"], "visit_code": v["visit_code"]})
+                    st.rerun()
+            except Exception as e:
+                st.error(f"❌ Could not start visit: {e}")
+                log_event("visit_start_failed", user_email, {"error": str(e)}, "error")
+
+    with col2:
+        if active_visit and st.button("🏁 End Visit", use_container_width=True, type="secondary"):
+            try:
+                with st.spinner("Ending visit..."):
+                    sb.table("visits").update({"ended_at": datetime.utcnow().isoformat()}) \
+                      .eq("id", active_visit["id"]).execute()
+                    st.success("✅ Visit completed successfully")
+                    log_event("visit_end", user_email, {"visit_id": active_visit["id"]})
+                    st.session_state.pop("active_visit", None)
+                    st.rerun()
+            except Exception as e:
+                st.error(f"❌ Could not end visit: {e}")
+                log_event("visit_end_failed", user_email, {"error": str(e)}, "error")
+
+    with col3:
+        if st.session_state.get("active_visit"):
+            v = st.session_state["active_visit"]
+            st.info(f"**Active Visit:** #{v['id']}\n**Code:** {v.get('visit_code','')}")
+        else:
+            st.info("No active visit")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced item identification section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📸 Item Identification",
+        "Use AI-powered image recognition to identify items quickly and accurately"
+    ), unsafe_allow_html=True)
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("📷 Camera Capture")
+        cam = st.camera_input("Take a photo of the item", help="Position the item clearly in the frame")
+    
+    with col2:
+        st.subheader("📁 File Upload")
+        up = st.file_uploader(
+            "Upload an image", 
+            type=["png","jpg","jpeg"],
+            help="Supported formats: PNG, JPG, JPEG"
+        )
+
+    img_file = cam or up
+    if img_file:
+        try:
+            img = Image.open(img_file).convert("RGB")
+            st.image(img, use_container_width=True, caption="Captured Image")
+            
+            if st.button("🔍 Identify Item with AI", use_container_width=True, type="primary"):
+                with st.spinner("Analyzing image with AI..."):
+                    t0 = time.time()
+                    try:
+                        pre = preprocess_for_label(img)
+                        raw = gemma_item_name(_to_png_bytes(pre))
+                        processing_time = time.time() - t0
+                        
+                        norm = normalize_item_name(raw)
+                        
+                        if raw:
+                            st.success(f"🤖 **AI Detection:** {raw}")
+                        st.info(f"✨ **Normalized:** {norm or '(unknown)'} · ⏱️ {processing_time:.2f}s")
+                        
+                        st.session_state["scanned_item_name"] = norm or raw or ""
+                        st.session_state["last_activity_at"] = local_now()
+                        
+                        log_event("item_identified", user_email, {
+                            "raw_name": raw,
+                            "normalized_name": norm,
+                            "processing_time": processing_time
+                        })
+                        
+                    except Exception as e:
+                        st.error(f"❌ AI identification failed: {e}")
+                        log_event("ai_identification_failed", user_email, {"error": str(e)}, "error")
+        except Exception as e:
+            st.error(f"❌ Failed to process image: {e}")
+            log_event("image_processing_failed", user_email, {"error": str(e)}, "error")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced item logging section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📬 Item Logging",
+        "Log items to the current visit with detailed information"
+    ), unsafe_allow_html=True)
+    
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        item_name = st.text_input(
+            "Item Name", 
+            value=st.session_state.get("scanned_item_name",""),
+            placeholder="Enter item name or use AI detection above",
+            help="Required field - item name for tracking"
+        )
+    
+    with col2:
+        quantity = st.number_input(
+            "Quantity", 
+            min_value=1, 
+            max_value=9999, 
+            step=1, 
+            value=1,
+            help="Number of items"
+        )
+    
+    col3, col4 = st.columns(2)
+    
+    with col3:
+        category = st.text_input(
+            "Category (optional)", 
+            placeholder="e.g., Food, Hygiene, Clothing",
+            help="Item category for better organization"
+        )
+    
+    with col4:
+        unit = st.text_input(
+            "Unit (optional)", 
+            placeholder="e.g., 500 mL, 1 L, 250 g",
+            help="Unit of measurement"
+        )
+    
+    barcode = st.text_input(
+        "Barcode (optional)", 
+        placeholder="Scan or enter barcode",
+        help="Product barcode for inventory tracking"
+    )
+
+    save_disabled = not st.session_state.get("active_visit")
+    if st.button("✅ Save Item to Visit", disabled=save_disabled, use_container_width=True, type="primary"):
+        v = st.session_state.get("active_visit")
+        if not v:
+            st.warning("⚠️ Please start a visit first before logging items.")
+        else:
+            name_clean = clean_text(item_name, 120)
+            if not name_clean:
+                st.warning("⚠️ Item name is required.")
+            else:
+                with st.spinner("Saving item..."):
+                    ts_iso = datetime.utcnow().isoformat()
+                    ingest_id = deterministic_ingest_id(int(v["id"]), user_email, name_clean, int(quantity), ts_iso)
+                    
+                    try:
+                        ok, msg = try_rpc_ingest(
+                            email=user_email, v_id=int(v["id"]), name=name_clean, qty=int(quantity),
+                            category=clean_text(category, 80), unit=clean_text(unit, 40),
+                            barcode=clean_text(barcode, 64), ts_iso=ts_iso, ingest_id=ingest_id
+                        )
+                        
+                        if ok:
+                            st.success("✅ Item logged successfully!")
+                            log_event("item_logged", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                        else:
+                            st.warning(f"⚠️ {msg}. Trying fallback method...")
+                            fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                                   clean_text(category,80), clean_text(unit,40),
+                                                   clean_text(barcode,64), ts_iso, ingest_id)
+                            st.success("✅ Item logged successfully (fallback method)!")
+                            log_event("item_logged_fallback", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                    except Exception as e:
+                        try:
+                            fallback_direct_insert(user_email, int(v["id"]), name_clean, int(quantity),
+                                                   clean_text(category,80), clean_text(unit,40),
+                                                   clean_text(barcode,64), ts_iso, ingest_id)
+                            st.success("✅ Item logged successfully (fallback method)!")
+                            log_event("item_logged_fallback", user_email, {
+                                "visit_id": v["id"],
+                                "item_name": name_clean,
+                                "quantity": quantity
+                            })
+                        except Exception as e2:
+                            st.error(f"❌ Failed to log item: {e2}")
+                            log_event("item_log_failed", user_email, {"error": str(e2)}, "error")
+                    
+                    st.session_state["last_activity_at"] = local_now()
+                    st.session_state["scanned_item_name"] = name_clean
+                    st.rerun()
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced visit items view
+    if st.session_state.get("active_visit"):
+        st.markdown(ModernUIComponents.create_modern_form_section(
+            "🧾 Current Visit Items",
+            "Review and manage items in the current visit"
+        ), unsafe_allow_html=True)
+        
+        rows = load_items_for_visit(int(st.session_state["active_visit"]["id"]))
+        if rows:
+            df = pd.DataFrame(rows)
+            
+            # Enhanced dataframe display
+            st.dataframe(
+                df, 
+                use_container_width=True,
+                hide_index=True,
+                column_config={
+                    "timestamp": st.column_config.DatetimeColumn("Time", format="MM/DD/YY HH:mm"),
+                    "item_name": st.column_config.TextColumn("Item Name", width="medium"),
+                    "qty": st.column_config.NumberColumn("Quantity", width="small"),
+                    "category": st.column_config.TextColumn("Category", width="small"),
+                    "unit": st.column_config.TextColumn("Unit", width="small")
+                }
+            )
+            
+            # Enhanced delete functionality
+            with st.expander("🗑️ Delete Item (if mis-logged)"):
+                if rows:
+                    item_options = {f"{r['item_name']} (Qty: {r['qty']})": r["id"] for r in rows if "id" in r}
+                    selected_item = st.selectbox("Select item to delete", list(item_options.keys()))
+                    
+                    if st.button("🗑️ Delete Selected Item", type="secondary"):
+                        item_id = item_options[selected_item]
+                        try:
+                            # Try both tables safely
+                            try:
+                                delete_item("visit_items_p", int(item_id))
+                            except Exception:
+                                delete_item("visit_items", int(item_id))
+                            
+                            st.success("✅ Item deleted successfully")
+                            log_event("item_deleted", user_email, {"item_id": item_id})
+                            st.rerun()
+                        except Exception as e:
+                            st.error(f"❌ Failed to delete item: {e}")
+                            log_event("item_delete_failed", user_email, {"error": str(e)}, "error")
+                else:
+                    st.info("No items to delete")
+        else:
+            st.info("📝 No items logged for this visit yet.")
+        
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced analytics section
+    st.markdown(ModernUIComponents.create_modern_form_section(
+        "📈 Today's Analytics",
+        "Real-time insights into today's volunteer activity"
+    ), unsafe_allow_html=True)
+    
+    try:
+        daily = sb.table("v_daily_activity").select("*").execute().data
+        today_str = local_now().strftime("%Y-%m-%d")
+        today = next((r for r in daily if str(r.get("day",""))[:10]==today_str), None)
+        
+        if today:
+            visits = int(today.get("visits", 0))
+            items = int(today.get("items", 0))
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                st.metric("Total Visits Today", visits, delta=None)
+            with col2:
+                st.metric("Total Items Processed", items, delta=None)
+            
+            # Progress indicator
+            if visits > 0:
+                st.markdown(ModernUIComponents.create_progress_indicator(
+                    items, visits * 10, "Items per Visit Target"
+                ), unsafe_allow_html=True)
+        else:
+            st.info("📊 Analytics data will appear here as activity increases.")
+            
+    except Exception as e:
+        st.info("📊 Analytics view will be available once the database view is set up.")
+        logger.warning(f"Analytics view not available: {e}")
+
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Enhanced footer with helpful information
+    st.markdown("""
+    <div class="modern-card" style="margin-top: var(--space-8); text-align: center;">
+        <h4>💡 Quick Tips</h4>
+        <p style="color: var(--gray-400); margin: 0;">
+            When you're done, please <strong>End Visit</strong> and <strong>Sign out</strong>.<br>
+            We'll auto-sign you out after inactivity or at 8pm local time. 💜
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+
+# ------------------------ Helper Functions (Enhanced) ------------------------
+def fetch_volunteer_row(email: str) -> dict | None:
+    """Enhanced volunteer data fetching with error handling"""
+    try:
+        return sb.table("volunteers").select("*").eq("email", email).single().execute().data
+    except Exception as e:
+        logger.warning(f"Failed to fetch volunteer data for {email}: {e}")
+        return None
+
+def items_today(email: str) -> int:
+    """Enhanced item counting with better error handling"""
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        # Try partitioned table first
+        data = sb.table("visit_items_p").select("id,timestamp,volunteer") \
+                .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                .eq("volunteer", email).execute().data
+        return len(data or [])
+    except Exception:
+        try:
+            data = sb.table("visit_items").select("id,timestamp,volunteer") \
+                    .gte("timestamp", f"{day} 00:00:00").lte("timestamp", f"{day} 23:59:59") \
+                    .eq("volunteer", email).execute().data
+            return len(data or [])
+        except Exception as e:
+            logger.warning(f"Failed to count items for {email}: {e}")
+            return 0
+
+def fallback_visit_code() -> str:
+    """Enhanced visit code generation with better uniqueness"""
+    try:
+        day = local_now().strftime("%Y-%m-%d")
+        todays = sb.table("visits").select("id,started_at").gte("started_at", f"{day} 00:00:00") \
+                 .lte("started_at", f"{day} 23:59:59").execute().data or []
+        seq = len(todays) + 1
+    except Exception:
+        seq = int(time.time()) % 1000
+    return f"V-{seq}-{local_now().strftime('%Y%m%d')}-{str(uuid.uuid4())[:6]}"
+
+def _to_png_bytes(img: Image.Image) -> bytes:
+    """Convert image to PNG bytes"""
+    b = io.BytesIO()
+    img.save(b, format="PNG")
+    return b.getvalue()
+
+def preprocess_for_label(img: Image.Image) -> Image.Image:
+    """Enhanced image preprocessing for better AI recognition"""
+    img = img.convert("RGB")
+    w, h = img.size
+    scale = 1024 / max(w, h) if max(w, h) > 1024 else 1.0
+    if scale < 1.0: 
+        img = img.resize((int(w * scale), int(h * scale)))
+    img = ImageOps.autocontrast(img, cutoff=2)
+    img = ImageEnhance.Brightness(img).enhance(1.06)
+    img = ImageEnhance.Contrast(img).enhance(1.05)
+    img = ImageEnhance.Sharpness(img).enhance(1.15)
+    return img
+
+def gemma_item_name(img_bytes: bytes) -> str:
+    """Enhanced AI item identification with better error handling"""
+    try:
+        if PROVIDER == "nebius":
+            if not NEBIUS_API_KEY: 
+                raise RuntimeError("NEBIUS_API_KEY missing")
+            return _openai_style_chat(NEBIUS_BASE_URL, NEBIUS_API_KEY, GEMMA_MODEL, img_bytes)
+        elif PROVIDER == "featherless":
+            if not FEATH_API_KEY: 
+                raise RuntimeError("FEATHERLESS_API_KEY missing")
+            return _openai_style_chat(FEATH_BASE_URL, FEATH_API_KEY, GEMMA_MODEL, img_bytes)
+        else:
+            raise RuntimeError(f"Unknown PROVIDER: {PROVIDER}")
+    except Exception as e:
+        logger.error(f"AI identification failed: {e}")
+        raise
+
+def _openai_style_chat(base_url: str, api_key: str, model_id: str, img_bytes: bytes) -> str:
+    """Enhanced API communication with better error handling"""
+    b64 = base64.b64encode(img_bytes).decode("utf-8")
+    url = f"{base_url.rstrip('/')}/chat/completions"
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    payload = {
+        "model": model_id,
+        "temperature": 0,
+        "messages": [
+            {"role": "system", "content": "You label item being held in the image for a food bank. Return ONLY the item name."},
+            {"role": "user", "content": [
+                {"type": "text", "text": "What is the name of the item in the picture? Return only the item name."},
+                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}}
+            ]}
+        ]
+    }
+    
+    try:
+        r = requests.post(url, json=payload, headers=headers, timeout=90)
+        if r.status_code != 200:
+            raise RuntimeError(f"LLM HTTP {r.status_code}: {r.text[:200]}")
+        data = r.json()
+        return (data["choices"][0]["message"]["content"] or "").strip()
+    except requests.exceptions.Timeout:
+        raise RuntimeError("AI service timeout - please try again")
+    except requests.exceptions.RequestException as e:
+        raise RuntimeError(f"AI service error: {e}")
+
+def normalize_item_name(s: str) -> str:
+    """Enhanced item name normalization"""
+    s = (s or "").strip()
+    if not s: 
+        return ""
+    
+    # Enhanced brand and type recognition
+    BRANDS = {
+        "whiskas","tetley","kellogg's","kelloggs","campbell's","campbells","heinz",
+        "nestle","kraft","general mills","cheerios","oreo","oreos","pringles","lays","doritos",
+        "ice river","green bottle","great value","wheat thins","vegetable thins","raid"
+    }
+    GENERIC_TYPES = {
+        "water","toothpaste","deodorant","antiperspirant","soap","shampoo","conditioner",
+        "lotion","tea","coffee","cereal","pasta","rice","beans","sauce","salsa","cleaner",
+        "peanut butter","jam","jelly","tuna","chicken","beef","flour","sugar","salt","oil",
+        "crackers","cookies","soup","insect killer","spray"
+    }
+    
+    low = re.sub(r"[®™]", "", s.lower())
+    for b in BRANDS: 
+        low = low.replace(b, "")
+    
+    chosen = None
+    for t in GENERIC_TYPES:
+        if t in low: 
+            chosen = t
+            break
+    
+    cleaned = " ".join(low.split())
+    return (chosen or cleaned.title())[:120]
+
+def clean_text(v: Optional[str], maxlen: int = 120) -> Optional[str]:
+    """Enhanced text cleaning"""
+    if not v: 
+        return None
+    v = re.sub(r"\s+", " ", v).strip()
+    return v[:maxlen] if v else None
+
+def deterministic_ingest_id(v_id: int, email: str, name: str, qty: int, ts_iso: str) -> str:
+    """Enhanced ID generation for data integrity"""
+    key = f"visit_items::{v_id}::{email}::{name}::{qty}::{ts_iso}"
+    return str(uuid.uuid5(uuid.NAMESPACE_URL, key))
+
+def try_rpc_ingest(email: str, v_id: int, name: str, qty: int,
+                   category: Optional[str], unit: Optional[str],
+                   barcode: Optional[str], ts_iso: str, ingest_id: str) -> tuple[bool,str]:
+    """Enhanced RPC ingestion with better error handling"""
+    try:
+        res = sb.rpc("safe_ingest_visit_item", {
+            "p_email": email,
+            "p_visit_id": v_id,
+            "p_item_name": name,
+            "p_qty": qty,
+            "p_category": category,
+            "p_unit": unit,
+            "p_barcode": barcode,
+            "p_ts": ts_iso,
+            "p_ingest_id": ingest_id
+        }).execute()
+        
+        rows = res.data if isinstance(res.data, list) else []
+        if rows:
+            r0 = rows[0]
+            ok = bool(r0.get("ok", False))
+            msg = str(r0.get("msg", ""))
+            return ok, msg or ("ok" if ok else "failed")
+        return True, "ok"
+    except Exception as e:
+        logger.warning(f"RPC ingest failed, using fallback: {e}")
+        raise e
+
+def fallback_direct_insert(email: str, v_id: int, name: str, qty: int,
+                           category: Optional[str], unit: Optional[str],
+                           barcode: Optional[str], ts_iso: str, ingest_id: str) -> None:
+    """Enhanced fallback insertion with better error handling"""
+    payload = {
+        "visit_id": v_id,
+        "timestamp": ts_iso,
+        "volunteer": email,
+        "item_name": name,
+        "category": category,
+        "unit": unit,
+        "qty": qty,
+        "barcode": barcode,
+        "weather_type": None,
+        "temp_c": None,
+        "ingest_id": ingest_id
+    }
+    
+    try:
+        sb.table("visit_items_p").insert(payload).execute()
+    except Exception:
+        # Legacy table fallback
+        payload.pop("ingest_id", None)
+        sb.table("visit_items").insert(payload).execute()
+
+def load_items_for_visit(visit_id: int) -> list[dict]:
+    """Enhanced item loading with better error handling"""
+    try:
+        return sb.table("visit_items_p").select("*").eq("visit_id", visit_id) \
+            .order("timestamp", desc=True).limit(500).execute().data or []
+    except Exception:
+        try:
+            return sb.table("visit_items").select("*").eq("visit_id", visit_id) \
+                .order("timestamp", desc=True).limit(500).execute().data or []
+        except Exception as e:
+            logger.warning(f"Failed to load items for visit {visit_id}: {e}")
+            return []
+
+def delete_item(table: str, item_id: int):
+    """Enhanced item deletion with better error handling"""
+    try:
+        sb.table(table).delete().eq("id", item_id).execute()
+    except Exception as e:
+        logger.error(f"Failed to delete item {item_id} from {table}: {e}")
+        raise e
+
+# ------------------------ App Configuration Display ------------------------
+st.sidebar.markdown("### ⚙️ Configuration")
+st.sidebar.info(f"""
+**Provider:** `{PROVIDER}`  
+**Model:** `{GEMMA_MODEL}`  
+**Timezone:** `{TZ}`  
+**Cutoff:** {CUTOFF_HOUR}:00 PM  
+**Inactivity:** {INACTIVITY_MIN} min
+""")
+
+# ------------------------ Main App Execution ------------------------
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        logger.error(f"Application error: {e}")
+        st.error(f"❌ Application error: {e}")
+        st.info("Please refresh the page or contact support if the issue persists.")