diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index 0190d8f..05cb7ad 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -92,7 +92,7 @@ jobs:
         python -m pip install --upgrade pip
     
     - name: Build project
-      run: python build.py
+      run: python scripts/build.py
     
     - name: Verify build outputs
       run: |
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index fbdd8bd..b1f40c3 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -88,7 +88,7 @@ jobs:
         python -m pip install --upgrade pip
     
     - name: Build project
-      run: python build.py
+      run: python scripts/build.py
     
     - name: Verify build outputs
       run: |
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..214d109
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,393 @@
+# Contributing to Peloterm
+
+Thank you for your interest in contributing to Peloterm! This guide will help you get started with development, understand the project structure, and submit pull requests.
+
+## 📁 Project Structure
+
+```
+peloterm/
+├── peloterm/              # Python package
+│   ├── web/
+│   │   ├── static/        # Built Vue files (auto-generated)
+│   │   └── server.py      # FastAPI backend
+│   ├── devices/           # Bluetooth device handlers
+│   ├── cli.py             # Terminal interface
+│   └── ...                # Other Python modules
+├── frontend/              # Vue 3 web interface
+│   ├── src/
+│   │   ├── components/    # Vue components
+│   │   ├── composables/   # Reusable logic
+│   │   └── types/         # TypeScript definitions
+│   ├── package.json
+│   └── vite.config.ts
+├── build.py               # Build frontend → Python package
+├── dev.py                 # Development server runner
+└── pyproject.toml         # Python package configuration
+```
+
+## 🚀 Development Setup
+
+### Prerequisites
+
+- Python 3.8+
+- Node.js 16+
+- Git
+
+### Initial Setup
+
+1. **Clone the repository:**
+   ```bash
+   git clone https://github.com/yourusername/peloterm.git
+   cd peloterm
+   ```
+
+2. **Create a virtual environment:**
+   ```bash
+   python -m venv venv
+   source venv/bin/activate  # On Windows: venv\Scripts\activate
+   ```
+
+3. **Install Python dependencies:**
+   ```bash
+   pip install -e ".[dev]"
+   ```
+
+4. **Install frontend dependencies:**
+   ```bash
+   cd frontend
+   npm install
+   cd ..
+   ```
+
+## 🛠 Development Workflow
+
+### Quick Start (Recommended)
+
+For most development work, use the unified development server:
+
+```bash
+# Run both Vue dev server + FastAPI backend
+python dev.py
+```
+
+This provides:
+- Vue UI: http://localhost:5173 (with hot reload)
+- FastAPI: http://localhost:8000
+- Automatic proxy setup between frontend and backend
+
+### Frontend Development
+
+For frontend-focused work:
+
+```bash
+# Terminal 1: Run backend
+python -m peloterm.web.server
+
+# Terminal 2: Run frontend with proxy
+cd frontend
+npm run dev
+```
+
+### Backend Development
+
+For backend-focused work:
+
+```bash
+# Run just the FastAPI server
+python -m peloterm.web.server
+```
+
+### Building for Production
+
+```bash
+# Build frontend into Python package
+python build.py
+
+# Test production build
+python dev.py prod
+```
+
+## 🏗 Architecture
+
+### Backend (Python)
+
+- **FastAPI** web server with WebSocket support
+- **Bluetooth** device communication using `bleak`
+- **Real-time** metrics processing
+- **Configuration** management
+- **FIT file** generation for ride recording
+- **Strava API** integration
+
+Key modules:
+- `peloterm/cli.py` - Command-line interface
+- `peloterm/web/server.py` - Web server and API
+- `peloterm/devices/` - Bluetooth device handlers
+- `peloterm/strava/` - Strava integration
+- `peloterm/recording/` - Ride recording and FIT file generation
+
+### Frontend (Vue 3)
+
+- **Component-based** architecture with TypeScript
+- **Chart.js** for real-time visualizations
+- **Responsive** design with mobile support
+- **WebSocket** connection for real-time data
+- **Hot reload** development
+
+Key directories:
+- `frontend/src/components/` - Vue components
+- `frontend/src/composables/` - Reusable logic
+- `frontend/src/types/` - TypeScript definitions
+
+### Build Process
+
+1. Vue builds optimized production files using Vite
+2. `build.py` copies files to `peloterm/web/static/`
+3. FastAPI serves the built files as static assets
+4. Single Python command runs everything in production
+
+## 🧪 Testing
+
+### Python Tests
+
+```bash
+# Run all Python tests
+pytest
+
+# Run with coverage
+pytest --cov=peloterm
+
+# Run specific test file
+pytest tests/test_devices.py
+```
+
+### Frontend Tests
+
+```bash
+cd frontend
+
+# Run unit tests
+npm run test:unit
+
+# Run tests in watch mode
+npm run test:unit -- --watch
+
+# Run with coverage
+npm run test:unit -- --coverage
+```
+
+### Integration Tests
+
+```bash
+# Test the full build process
+python build.py
+python dev.py prod
+# Verify http://localhost:8000 works correctly
+```
+
+## 📦 Distribution
+
+The build process creates a self-contained Python package:
+- All frontend assets bundled into the package
+- No separate frontend server needed in production
+- Single `pip install` for end users
+- Automatic static file serving via FastAPI
+
+## 🎯 Advanced Features
+
+### Command Options
+
+The `peloterm start` command supports many options:
+
+- `--config PATH` - Use a specific configuration file
+- `--timeout 60` - Set connection timeout in seconds (default: 60)
+- `--debug` - Enable debug output
+- `--web/--no-web` - Enable/disable web UI (default: enabled)
+- `--port 8000` - Set web server port
+- `--duration 30` - Set target ride duration in minutes
+- `--no-recording` - Disable automatic ride recording
+
+### Strava Integration
+
+Peloterm includes comprehensive Strava integration:
+
+```bash
+# Set up Strava (interactive)
+peloterm strava setup
+
+# Test connection
+peloterm strava test
+
+# List recorded rides
+peloterm strava list
+
+# Upload specific ride
+peloterm strava upload ride_file.fit --name "Epic Ride"
+```
+
+### File Formats
+
+Peloterm generates **FIT files** for ride recording:
+- ✅ **Compact**: Binary format, smaller than TCX/GPX
+- ✅ **Complete**: Supports all cycling metrics
+- ✅ **Compatible**: Works with Garmin devices and most apps
+- ✅ **Strava-optimized**: Best format for Strava uploads
+
+Files are saved to `~/.peloterm/rides/`
+
+## 🔧 Configuration
+
+### Development Configuration
+
+Create a `.env` file in the project root:
+
+```env
+DEBUG=true
+LOG_LEVEL=debug
+STRAVA_CLIENT_ID=your_client_id
+STRAVA_CLIENT_SECRET=your_client_secret
+```
+
+### Device Configuration
+
+Device configuration is stored in `~/.peloterm/config.json`:
+
+```json
+{
+  "devices": {
+    "heart_rate": "AA:BB:CC:DD:EE:FF",
+    "power_meter": "11:22:33:44:55:66",
+    "cadence": "77:88:99:AA:BB:CC"
+  },
+  "web": {
+    "iframe_url": "https://www.youtube.com/embed/VIDEO_ID",
+    "port": 8000
+  }
+}
+```
+
+## 📈 Performance Considerations
+
+### Frontend Optimization
+
+- **Tree-shaking** removes unused code
+- **Asset optimization** and caching
+- **Efficient reactivity** with Vue 3 Composition API
+- **WebSocket** for low-latency data updates
+
+### Backend Optimization
+
+- **Async/await** for non-blocking operations
+- **Efficient Bluetooth** scanning and connection
+- **Minimal memory** footprint for long rides
+- **Graceful error handling** and reconnection
+
+## 🤝 Contributing Guidelines
+
+### Code Style
+
+**Python:**
+- Follow PEP 8
+- Use `black` for formatting: `black .`
+- Use `isort` for imports: `isort .`
+- Type hints are encouraged
+
+**TypeScript/Vue:**
+- Follow Vue 3 style guide
+- Use Prettier for formatting: `npm run format`
+- Use ESLint: `npm run lint`
+
+### Commit Messages
+
+Use conventional commits:
+- `feat:` new features
+- `fix:` bug fixes
+- `docs:` documentation changes
+- `style:` formatting changes
+- `refactor:` code refactoring
+- `test:` adding tests
+- `chore:` maintenance tasks
+
+Examples:
+```
+feat: add power meter support for Wahoo devices
+fix: resolve WebSocket connection timeout issue
+docs: update installation instructions
+```
+
+### Pull Request Process
+
+1. **Fork** the repository
+2. **Create** a feature branch: `git checkout -b feature/amazing-feature`
+3. **Make** your changes
+4. **Add** tests for new functionality
+5. **Run** the test suite: `pytest && cd frontend && npm test`
+6. **Commit** your changes with conventional commit messages
+7. **Push** to your fork: `git push origin feature/amazing-feature`
+8. **Open** a Pull Request
+
+### Pull Request Checklist
+
+- [ ] Tests pass locally
+- [ ] Code follows style guidelines
+- [ ] Documentation updated if needed
+- [ ] Commit messages follow conventional format
+- [ ] No breaking changes (or clearly documented)
+- [ ] Frontend builds successfully (`python build.py`)
+
+## 🐛 Debugging
+
+### Common Issues
+
+**Bluetooth connection problems:**
+```bash
+# Enable debug mode
+peloterm start --debug
+
+# Check device permissions (Linux)
+sudo usermod -a -G dialout $USER
+```
+
+**Frontend build issues:**
+```bash
+# Clear node modules and reinstall
+cd frontend
+rm -rf node_modules package-lock.json
+npm install
+
+# Clear build cache
+rm -rf peloterm/web/static/*
+python build.py
+```
+
+**WebSocket connection issues:**
+- Check firewall settings
+- Verify port 8000 is available
+- Try different port: `peloterm start --port 8001`
+
+### Development Tools
+
+- **Vue DevTools** browser extension for frontend debugging
+- **FastAPI docs** at http://localhost:8000/docs for API testing
+- **WebSocket testing** tools for real-time connection debugging
+
+## 📚 References
+
+- [FastAPI Documentation](https://fastapi.tiangolo.com/)
+- [Vue 3 Documentation](https://vuejs.org/)
+- [Chart.js Documentation](https://www.chartjs.org/)
+- [Bleak (Bluetooth) Documentation](https://bleak.readthedocs.io/)
+- [FIT SDK Documentation](https://developer.garmin.com/fit/overview/)
+
+### Related Projects
+
+- [GoldenCheetah](https://github.com/goldencheetah/goldencheetah) - Cycling analytics
+- [Endurain](https://github.com/joaovitoriasilva/endurain) - Self-hosted fitness tracking
+- [PyCycling](https://github.com/zacharyedwardbull/pycycling) - Python cycling sensors library
+
+## 📞 Getting Help
+
+- **Issues**: Open a GitHub issue for bugs or feature requests
+- **Discussions**: Use GitHub Discussions for questions and ideas
+- **Discord**: Join our community Discord server (link in README)
+
+Thank you for contributing to Peloterm! 🚴‍♂️
diff --git a/LICENSE b/LICENSE
index b437526..f6c5b03 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Your Name
+Copyright (c) 2025 Andrew Marder
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/README.md b/README.md
index 8163b72..3286c5b 100644
--- a/README.md
+++ b/README.md
@@ -1,160 +1,14 @@
 # Peloterm
 
-A terminal-based cycling metrics visualization tool with a modern web interface.
-
-## 📁 Project Structure
-
-```
-bike/
-├── peloterm/              # Python package
-│   ├── web/
-│   │   ├── static/        # Built Vue files (auto-generated)
-│   │   └── server.py      # FastAPI backend
-│   ├── devices/           # Bluetooth device handlers
-│   ├── cli.py             # Terminal interface
-│   └── ...                # Other Python modules
-├── frontend/              # Vue 3 web interface
-│   ├── src/
-│   │   ├── components/    # Vue components
-│   │   ├── composables/   # Reusable logic
-│   │   └── types/         # TypeScript definitions
-│   ├── package.json
-│   └── vite.config.ts
-├── build.py               # Build frontend → Python package
-├── dev.py                 # Development server runner
-└── pyproject.toml         # Python package configuration
-```
-
-## 🚀 Quick Start
-
-### Development Mode (Hot Reload)
-```bash
-# Run both Vue dev server + FastAPI backend
-python dev.py
-```
-- Vue UI: http://localhost:5173 (with hot reload)
-- FastAPI: http://localhost:8000
-
-### Production Mode
-```bash
-# Build frontend and run production server
-python build.py
-python dev.py prod
-```
-- Production server: http://localhost:8000
-
-### Frontend Only
-```bash
-cd frontend
-npm install
-npm run dev
-```
-
-## 🛠 Development Workflow
-
-### 1. Frontend Development
-```bash
-# Terminal 1: Run backend
-python -m peloterm.web.server
-
-# Terminal 2: Run frontend with proxy
-cd frontend
-npm run dev
-```
-
-### 2. Building for Production
-```bash
-# Build frontend into Python package
-python build.py
-
-# Verify build
-python dev.py prod
-```
-
-### 3. One-Command Development
-```bash
-# Runs both servers together
-python dev.py
-```
-
-## 🏗 Architecture
-
-### Backend (Python)
-- **FastAPI** web server with WebSocket support
-- **Bluetooth** device communication
-- **Real-time** metrics processing
-- **Configuration** management
-
-### Frontend (Vue 3)
-- **Component-based** architecture
-- **TypeScript** for type safety
-- **Chart.js** for real-time visualizations
-- **Responsive** design
-- **Hot reload** development
-
-### Build Process
-1. Vue builds optimized production files
-2. Files are automatically placed in `peloterm/web/static/`
-3. FastAPI serves the built files
-4. Single Python command runs everything
-
-## 📦 Distribution
-
-The build process creates a self-contained Python package:
-- All frontend assets bundled into the package
-- No separate frontend server needed in production
-- Single `pip install` for end users
-
-## 🎯 Features
-
-- **Real-time Metrics**: Power, speed, cadence, heart rate
-- **Interactive Charts**: Historical data visualization
-- **Responsive Design**: Works on desktop and mobile
-- **Resizable Panels**: Customizable layout
-- **Dark Theme**: Easy on the eyes
-- **WebSocket Updates**: Low-latency data streaming
-
-## 🔧 Configuration
-
-Configure iframe URL and metrics in the web interface or via config files.
-
-## 📱 Web Interface
-
-The Vue frontend provides:
-- Real-time cycling metrics display
-- Interactive Chart.js visualizations
-- Resizable video panel
-- Mobile-responsive design
-- Dark theme matching terminal aesthetic
-
-## 🧪 Testing
-
-```bash
-# Frontend tests
-cd frontend
-npm run test:unit
-
-# Python tests
-pytest
-```
-
-## 📈 Performance
-
-- **Optimized builds** with Vite
-- **Tree-shaking** removes unused code
-- **Asset optimization** and caching
-- **Efficient reactivity** with Vue 3
+A cycling metrics application that connects to Bluetooth sensors to display real-time performance data while you ride. Supports embedding compatible streaming content (like Jellyfin) in the built-in media player using HTML iframes. When you're done, easily save and upload your rides to Strava.
 
 ## Features
 
-- Real-time BLE sensor connection with concurrent device scanning
-- Modern web-based UI with configurable video integration (YouTube by default)
-- Support for multiple sensor types
-- Easy-to-use command line interface
-- Automatic device reconnection if connection is lost
-- Smart listening mode that waits for you to turn on devices - no more timing issues!
-- **Automatic ride recording with FIT file generation**
-- **Interactive Strava upload during shutdown**
+- Real-time BLE sensor connection (heart rate, power, cadence, speed)
+- Modern web-based UI with configurable video integration
+- Automatic ride recording with FIT file generation
+- Interactive Strava upload
+- Smart listening mode - turn on devices when you're ready
 
 ## Installation
 
@@ -162,138 +16,30 @@ pytest
 pip install peloterm
 ```
 
-## Usage
+## Quick Start
 
-First, scan for available Bluetooth sensors in your area:
+1. **First time setup - scan for your sensors:**
+   ```bash
+   peloterm scan
+   ```
+   This saves your device addresses to a config file, so you only need to do this once.
 
-```bash
-peloterm scan
-```
-
-This will show all available BLE devices and help you set up your configuration file with the correct sensor IDs.
-
-### Starting Your Session
-
-```bash
-peloterm start
-```
-
-**Perfect for devices that auto-sleep quickly!** By default, peloterm now uses smart listening mode:
-- Shows you which devices it's waiting for
-- Lets you turn on your devices when you're ready
-- Connects to all devices concurrently as they become available
-- Automatically starts monitoring once all devices are connected
-- **Records your ride data automatically**
-
-**Example workflow:**
-1. Run `peloterm start`
-2. See the list of devices it's waiting for
-3. Turn on your heart rate monitor, cadence sensor, and trainer
-4. Watch as each device connects in real-time
-5. Start your workout once all devices are connected!
-6. **Press Ctrl+C when done - you'll be prompted to save and upload your ride**
-
-### Recording and Strava Integration
-
-When you stop Peloterm (Ctrl+C), you'll be prompted with:
-
-1. **💾 Save this ride as a FIT file?** - Save your ride data
-2. **📝 Enter a name for your ride** - Optional custom name
-3. **🚴 Upload this ride to Strava?** - Direct upload to Strava
-4. **Activity details** - Name and description for Strava
+2. **Start your ride:**
+   ```bash
+   peloterm start
+   ```
 
-If Strava isn't set up yet, you'll be guided through the setup process automatically.
+3. **Turn on your devices** when prompted and start cycling!
 
-### Strava Setup (Optional)
-
-To set up Strava integration ahead of time:
-
-```bash
-peloterm strava setup
-```
-
-This will guide you through:
-1. Creating a Strava API application
-2. Authorizing Peloterm to upload activities
-3. Storing your credentials securely
-
-### Other Strava Commands
-
-```bash
-# Test your Strava connection
-peloterm strava test
-
-# List all recorded rides
-peloterm strava list
-
-# Upload a specific ride file
-peloterm strava upload ride_file.fit --name "Epic Mountain Climb"
-```
+4. **Press Ctrl+C when done** to stop the session.
 
-### Command Options
+## Web Interface
 
-The `start` command supports these options:
-
-- `--config PATH` - Use a specific configuration file
-- `--timeout 60` - Set connection timeout in seconds (default: 60)
-- `--debug` - Enable debug output
-- `--web/--no-web` - Enable/disable web UI (default: enabled)
-- `--port 8000` - Set web server port
-- `--duration 30` - Set target ride duration in minutes
-- `--no-recording` - Disable automatic ride recording
-
-Examples:
-```bash
-# Standard ride with recording
-peloterm start
-
-# Disable recording (monitoring only)
-peloterm start --no-recording
-
-# Use debug mode to troubleshoot connections
-peloterm start --debug
-
-# Listen for devices with 2-minute timeout
-peloterm start --timeout 120
-```
-
-## File Formats
-
-When recording rides, Peloterm generates **FIT files** which are:
-- ✅ **Compact**: Binary format, much smaller than TCX/GPX
-- ✅ **Complete**: Supports all cycling metrics (power, cadence, heart rate, speed)
-- ✅ **Compatible**: Native format for Garmin devices and widely supported
-- ✅ **Strava-optimized**: Best format for uploading to Strava
-
-FIT files are saved to `~/.peloterm/rides/` and can be uploaded to Strava or imported into other cycling apps.
-
-## Development
-
-To set up the development environment:
-
-```bash
-# Clone the repository
-git clone https://github.com/yourusername/peloterm.git
-cd peloterm
-
-# Create a virtual environment
-python -m venv venv
-source venv/bin/activate  # On Windows: venv\Scripts\activate
-
-# Install dependencies
-pip install -e ".[dev]"
-```
-
-### Running Tests
-
-To run the test suite:
-
-```bash
-pytest
-```
+When you run `peloterm start`, a web interface opens at http://localhost:8000 with:
+- Real-time cycling metrics
+- Interactive chart
+- Configurable video panel (Jellyfin by default)
 
-## References
+## Contributing
 
-- https://github.com/goldencheetah/goldencheetah
-- https://github.com/joaovitoriasilva/endurain
-- https://github.com/zacharyedwardbull/pycycling
\ No newline at end of file
+Want to contribute? Check out our [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, project structure, and how to submit pull requests.
diff --git a/frontend/src/components/MetricCard.vue b/frontend/src/components/MetricCard.vue
index 7a4b711..c20a257 100644
--- a/frontend/src/components/MetricCard.vue
+++ b/frontend/src/components/MetricCard.vue
@@ -1,7 +1,6 @@
 <template>
   <div class="metric-card">
     <div class="metric-content">
-      <span class="metric-symbol">{{ metric.symbol }}</span>
       <div class="metric-info">
         <span 
           class="metric-value"
@@ -59,8 +58,8 @@ watch(() => [props.value, props.timestamp], () => {
 <style scoped>
 .metric-card {
   padding: 8px 12px;
-  min-width: 120px;
-  flex: 1;
+  width: 150px;
+  flex: 0 0 150px;
   display: flex;
   align-items: center;
   justify-content: flex-start;
@@ -81,27 +80,25 @@ watch(() => [props.value, props.timestamp], () => {
 .metric-content {
   display: flex;
   align-items: center;
-  gap: 8px;
-  text-align: left;
-}
-
-.metric-symbol {
-  font-size: 20px;
-  opacity: 0.8;
+  justify-content: center;
+  text-align: center;
+  width: 100%;
 }
 
 .metric-info {
   display: flex;
   flex-direction: column;
-  align-items: flex-start;
-  gap: 2px;
+  align-items: center;
+  gap: 1px;
+  width: 100%;
 }
 
 .metric-value {
-  font-size: 24px;
+  font-size: 48px;
   font-weight: 700;
   line-height: 1;
   color: #58a6ff;
+  font-family: 'SF Mono', 'Monaco', 'Inconsolata', 'Roboto Mono', 'Source Code Pro', monospace;
 }
 
 .metric-name {
@@ -134,12 +131,8 @@ watch(() => [props.value, props.timestamp], () => {
     gap: 12px;
   }
   
-  .metric-symbol {
-    font-size: 28px;
-  }
-  
   .metric-value {
-    font-size: 28px;
+    font-size: 52px;
   }
 }
 </style>
\ No newline at end of file
diff --git a/frontend/src/components/PelotermPanel.vue b/frontend/src/components/PelotermPanel.vue
index 78e5e9f..3289121 100644
--- a/frontend/src/components/PelotermPanel.vue
+++ b/frontend/src/components/PelotermPanel.vue
@@ -116,7 +116,7 @@ defineExpose({
 }
 
 .time-section {
-  flex: 0 0 150px;
+  flex: 0 0 auto;
   display: flex;
   align-items: center;
   border-right: 1px solid #21262d;
@@ -155,7 +155,7 @@ defineExpose({
 
 @media (max-width: 1200px) {
   .time-section {
-    flex: 0 0 120px;
+    flex: 0 0 auto;
     padding: 0 8px;
   }
   
diff --git a/frontend/src/components/TimeWidget.vue b/frontend/src/components/TimeWidget.vue
index 794822f..669b80c 100644
--- a/frontend/src/components/TimeWidget.vue
+++ b/frontend/src/components/TimeWidget.vue
@@ -1,7 +1,6 @@
 <template>
   <div class="time-widget">
     <div class="time-row">
-      <span class="time-label">🕐</span>
       <span class="time-value">{{ currentTime }}</span>
     </div>
     <div class="progress-bar">
@@ -38,6 +37,7 @@ const updateTime = () => {
   currentTime.value = date.toLocaleTimeString([], { 
     hour: '2-digit', 
     minute: '2-digit',
+    second: '2-digit',
     hour12: false 
   })
   now.value = date.getTime()
@@ -58,7 +58,6 @@ onUnmounted(() => {
 <style scoped>
 .time-widget {
   padding: 12px 16px;
-  width: 200px;
   flex-shrink: 0;
   display: flex;
   flex-direction: column;
@@ -68,20 +67,15 @@ onUnmounted(() => {
 .time-row {
   display: flex;
   align-items: center;
-  gap: 12px;
-  margin-bottom: 8px;
-}
-
-.time-label {
-  font-size: 16px;
-  width: 20px;
+  justify-content: flex-start;
 }
 
 .time-value {
-  font-size: 18px;
-  font-weight: 600;
+  font-size: 32px;
+  font-weight: 700;
   color: #58a6ff;
-  font-family: 'SF Mono', Monaco, 'Cascadia Code', 'Roboto Mono', Consolas, 'Courier New', monospace;
+  font-family: 'SF Mono', 'Monaco', 'Inconsolata', 'Roboto Mono', 'Source Code Pro', monospace;
+  line-height: 1;
 }
 
 .progress-bar {
diff --git a/frontend/src/components/__tests__/MetricCard.spec.ts b/frontend/src/components/__tests__/MetricCard.spec.ts
index 9ce9871..ebf9f5b 100644
--- a/frontend/src/components/__tests__/MetricCard.spec.ts
+++ b/frontend/src/components/__tests__/MetricCard.spec.ts
@@ -50,7 +50,7 @@ describe('MetricCard', () => {
     vi.clearAllMocks()
   })
 
-  it('should render metric symbol and display value', () => {
+  it('should render metric name and display value', () => {
     const wrapper = mount(MetricCard, {
       props: {
         ...defaultProps,
@@ -58,7 +58,7 @@ describe('MetricCard', () => {
       }
     })
 
-    expect(wrapper.find('.metric-symbol').text()).toBe('W')
+    expect(wrapper.find('.metric-name').text()).toBe('Power')
     expect(wrapper.find('.metric-value').text()).toBe('250')
   })
 
diff --git a/frontend/src/components/__tests__/TimeWidget.spec.ts b/frontend/src/components/__tests__/TimeWidget.spec.ts
index 057dace..5a183da 100644
--- a/frontend/src/components/__tests__/TimeWidget.spec.ts
+++ b/frontend/src/components/__tests__/TimeWidget.spec.ts
@@ -19,16 +19,15 @@ describe('TimeWidget', () => {
     vi.restoreAllMocks()
   })
 
-  it('should render time label and current time', () => {
+  it('should render current time', () => {
     const wrapper = mount(TimeWidget, {
       props: defaultProps
     })
 
-    expect(wrapper.find('.time-label').text()).toBe('🕐')
     expect(wrapper.find('.time-value').exists()).toBe(true)
   })
 
-  it('should display current time in HH:MM format', async () => {
+  it('should display current time in HH:MM:SS format', async () => {
     // Set a specific time
     vi.setSystemTime(new Date('2022-01-01T14:30:00Z'))
     
@@ -39,9 +38,9 @@ describe('TimeWidget', () => {
     // Wait for component to mount and update time
     await wrapper.vm.$nextTick()
 
-    // The exact format depends on locale, but should contain time
+    // The exact format depends on locale, but should contain time with seconds
     const timeValue = wrapper.find('.time-value').text()
-    expect(timeValue).toMatch(/\d{2}:\d{2}/)
+    expect(timeValue).toMatch(/\d{2}:\d{2}:\d{2}/)
   })
 
   it('should update time every second', async () => {
diff --git a/peloterm/devices/ftms_parsers.py b/peloterm/devices/ftms_parsers.py
index 31dabdc..da1f2e3 100644
--- a/peloterm/devices/ftms_parsers.py
+++ b/peloterm/devices/ftms_parsers.py
@@ -67,7 +67,7 @@ def parse_indoor_bike_data(message) -> IndoorBikeData:
     # Parse data based on flags
     i = 2  # Start after flags
 
-    if flag_more_data == 0:
+    if flag_more_data == 1:
         # Speed comes in as km/h * 100
         instant_speed = int.from_bytes(message[i:i + 2], "little", signed=False) / 100.0  # Convert to km/h
         i += 2
diff --git a/tests/__init__.py b/peloterm/tests/__init__.py
similarity index 100%
rename from tests/__init__.py
rename to peloterm/tests/__init__.py
diff --git a/tests/test_config.py b/peloterm/tests/test_config.py
similarity index 100%
rename from tests/test_config.py
rename to peloterm/tests/test_config.py
diff --git a/tests/test_controller.py b/peloterm/tests/test_controller.py
similarity index 100%
rename from tests/test_controller.py
rename to peloterm/tests/test_controller.py
diff --git a/tests/test_data_recorder.py b/peloterm/tests/test_data_recorder.py
similarity index 100%
rename from tests/test_data_recorder.py
rename to peloterm/tests/test_data_recorder.py
diff --git a/tests/test_devices.py b/peloterm/tests/test_devices.py
similarity index 100%
rename from tests/test_devices.py
rename to peloterm/tests/test_devices.py
diff --git a/tests/test_display.py b/peloterm/tests/test_display.py
similarity index 100%
rename from tests/test_display.py
rename to peloterm/tests/test_display.py
diff --git a/peloterm/tests/test_ftms_parsers.py b/peloterm/tests/test_ftms_parsers.py
new file mode 100644
index 0000000..2d6ae98
--- /dev/null
+++ b/peloterm/tests/test_ftms_parsers.py
@@ -0,0 +1,211 @@
+"""Tests for FTMS (Fitness Machine Service) parsers."""
+
+import pytest
+from peloterm.devices.ftms_parsers import parse_indoor_bike_data, IndoorBikeData
+
+
+class TestFTMSParsers:
+    """Test FTMS parser functions."""
+
+    def test_parse_indoor_bike_data_speed_present(self):
+        """Test parsing when speed data is present (flag_more_data = 1)."""
+        # Create FTMS message with speed data present
+        # Flags: byte 0 = 0x01 (more_data=1), byte 1 = 0x00
+        # Speed: 2500 (25.00 km/h) as little-endian uint16
+        message = bytearray([
+            0x01, 0x00,  # Flags: more_data=1, others=0
+            0xC4, 0x09   # Speed: 2500 (25.00 km/h when divided by 100)
+        ])
+        
+        result = parse_indoor_bike_data(message)
+        
+        assert result.instant_speed == 25.0
+        assert result.average_speed is None
+        assert result.instant_power is None
+        assert result.instant_cadence is None
+
+    def test_parse_indoor_bike_data_speed_absent(self):
+        """Test parsing when speed data is absent (flag_more_data = 0)."""
+        # Create FTMS message with no speed data
+        # Flags: byte 0 = 0x00 (more_data=0), byte 1 = 0x00
+        message = bytearray([
+            0x00, 0x00   # Flags: more_data=0, others=0
+        ])
+        
+        result = parse_indoor_bike_data(message)
+        
+        assert result.instant_speed is None
+        assert result.average_speed is None
+        assert result.instant_power is None
+        assert result.instant_cadence is None
+
+    def test_parse_indoor_bike_data_speed_and_power(self):
+        """Test parsing when both speed and power data are present."""
+        # Flags: byte 0 = 0x41 (more_data=1, instantaneous_power=1), byte 1 = 0x00
+        # Speed: 3000 (30.00 km/h), Power: 200W
+        message = bytearray([
+            0x41, 0x00,  # Flags: more_data=1, instantaneous_power=1
+            0xB8, 0x0B,  # Speed: 3000 (30.00 km/h)
+            0xC8, 0x00   # Power: 200W
+        ])
+        
+        result = parse_indoor_bike_data(message)
+        
+        assert result.instant_speed == 30.0
+        assert result.instant_power == 200
+        assert result.average_speed is None
+        assert result.instant_cadence is None
+
+    def test_parse_indoor_bike_data_realistic_speeds(self):
+        """Test parsing with realistic cycling speeds."""
+        test_cases = [
+            (1500, 15.0),  # 15 km/h - slow indoor pace
+            (2000, 20.0),  # 20 km/h - moderate pace
+            (2500, 25.0),  # 25 km/h - good pace
+            (3000, 30.0),  # 30 km/h - fast pace
+            (3500, 35.0),  # 35 km/h - very fast
+            (4000, 40.0),  # 40 km/h - sprint pace
+            (5000, 50.0),  # 50 km/h - maximum realistic
+        ]
+        
+        for raw_speed, expected_kmh in test_cases:
+            message = bytearray([
+                0x01, 0x00,  # Flags: more_data=1
+                raw_speed & 0xFF, (raw_speed >> 8) & 0xFF  # Speed as little-endian
+            ])
+            
+            result = parse_indoor_bike_data(message)
+            assert result.instant_speed == expected_kmh, \
+                f"Failed for raw speed {raw_speed}: expected {expected_kmh}, got {result.instant_speed}"
+
+    def test_parse_indoor_bike_data_edge_cases(self):
+        """Test parsing edge cases for speed data."""
+        # Test zero speed
+        message_zero = bytearray([
+            0x01, 0x00,  # Flags: more_data=1
+            0x00, 0x00   # Speed: 0 (0.00 km/h)
+        ])
+        result = parse_indoor_bike_data(message_zero)
+        assert result.instant_speed == 0.0
+
+        # Test maximum uint16 speed value
+        message_max = bytearray([
+            0x01, 0x00,  # Flags: more_data=1
+            0xFF, 0xFF   # Speed: 65535 (655.35 km/h - unrealistic but valid)
+        ])
+        result = parse_indoor_bike_data(message_max)
+        assert result.instant_speed == 655.35
+
+    def test_parse_indoor_bike_data_average_speed(self):
+        """Test parsing average speed when flag is set."""
+        # Flags: byte 0 = 0x03 (more_data=1, average_speed=1), byte 1 = 0x00
+        # Instant speed: 2500 (25.00 km/h), Average speed: 2200 (22.00 km/h)
+        message = bytearray([
+            0x03, 0x00,  # Flags: more_data=1, average_speed=1
+            0xC4, 0x09,  # Instant speed: 2500 (25.00 km/h)
+            0x98, 0x08   # Average speed: 2200 (22.00 km/h)
+        ])
+        
+        result = parse_indoor_bike_data(message)
+        
+        assert result.instant_speed == 25.0
+        assert result.average_speed == 22.0
+
+    def test_parse_indoor_bike_data_cadence(self):
+        """Test parsing cadence data."""
+        # Flags: byte 0 = 0x05 (more_data=1, instantaneous_cadence=1), byte 1 = 0x00
+        # Speed: 2500 (25.00 km/h), Cadence: 180 (90 RPM when divided by 2)
+        message = bytearray([
+            0x05, 0x00,  # Flags: more_data=1, instantaneous_cadence=1
+            0xC4, 0x09,  # Speed: 2500 (25.00 km/h)
+            0xB4, 0x00   # Cadence: 180 (90 RPM when divided by 2)
+        ])
+        
+        result = parse_indoor_bike_data(message)
+        
+        assert result.instant_speed == 25.0
+        assert result.instant_cadence == 90.0
+
+    def test_parse_indoor_bike_data_complex_message(self):
+        """Test parsing a complex message with multiple data fields."""
+        # Flags: byte 0 = 0x47 (more_data=1, average_speed=1, instantaneous_cadence=1, instantaneous_power=1)
+        #        byte 1 = 0x02 (heart_rate=1)
+        # Data: instant_speed, average_speed, instant_cadence, instant_power, heart_rate
+        message = bytearray([
+            0x47, 0x02,  # Flags
+            0xC4, 0x09,  # Instant speed: 2500 (25.00 km/h)
+            0x98, 0x08,  # Average speed: 2200 (22.00 km/h)
+            0xB4, 0x00,  # Cadence: 180 (90 RPM)
+            0xC8, 0x00,  # Power: 200W
+            0x96         # Heart rate: 150 BPM
+        ])
+        
+        result = parse_indoor_bike_data(message)
+        
+        assert result.instant_speed == 25.0
+        assert result.average_speed == 22.0
+        assert result.instant_cadence == 90.0
+        assert result.instant_power == 200
+        assert result.heart_rate == 150
+
+    def test_parse_indoor_bike_data_power_only(self):
+        """Test parsing when only power data is present (no speed)."""
+        # Flags: byte 0 = 0x40 (instantaneous_power=1), byte 1 = 0x00
+        # Power: 250W
+        message = bytearray([
+            0x40, 0x00,  # Flags: instantaneous_power=1, more_data=0
+            0xFA, 0x00   # Power: 250W
+        ])
+        
+        result = parse_indoor_bike_data(message)
+        
+        assert result.instant_speed is None  # No speed data should be parsed
+        assert result.instant_power == 250
+        assert result.instant_cadence is None
+
+    def test_parse_indoor_bike_data_regression_test(self):
+        """Regression test to ensure the speed parsing bug doesn't return.
+        
+        This test specifically validates that we don't parse speed data
+        when flag_more_data = 0, which was the original bug.
+        """
+        # This message has flag_more_data = 0 but contains power data
+        # The old buggy code would try to parse the power bytes as speed
+        message = bytearray([
+            0x40, 0x00,  # Flags: more_data=0, instantaneous_power=1
+            0xFA, 0x00   # Power: 250W (should NOT be parsed as speed)
+        ])
+        
+        result = parse_indoor_bike_data(message)
+        
+        # Critical assertion: speed should be None, not some garbage value
+        assert result.instant_speed is None, \
+            "Speed should be None when flag_more_data=0 (regression test failed)"
+        assert result.instant_power == 250, \
+            "Power should still be parsed correctly"
+
+    def test_parse_indoor_bike_data_empty_message(self):
+        """Test parsing with minimal message (just flags)."""
+        message = bytearray([0x00, 0x00])  # No data flags set
+        
+        result = parse_indoor_bike_data(message)
+        
+        # All values should be None
+        assert result.instant_speed is None
+        assert result.average_speed is None
+        assert result.instant_cadence is None
+        assert result.average_cadence is None
+        assert result.instant_power is None
+        assert result.average_power is None
+        assert result.heart_rate is None
+
+    def test_parse_indoor_bike_data_return_type(self):
+        """Test that the function returns the correct type."""
+        message = bytearray([0x01, 0x00, 0xC4, 0x09])  # Simple speed message
+        
+        result = parse_indoor_bike_data(message)
+        
+        assert isinstance(result, IndoorBikeData)
+        assert hasattr(result, 'instant_speed')
+        assert hasattr(result, 'instant_power')
+        assert hasattr(result, 'instant_cadence') 
\ No newline at end of file
diff --git a/tests/test_mock_data.py b/peloterm/tests/test_mock_data.py
similarity index 100%
rename from tests/test_mock_data.py
rename to peloterm/tests/test_mock_data.py
diff --git a/tests/test_scanner.py b/peloterm/tests/test_scanner.py
similarity index 100%
rename from tests/test_scanner.py
rename to peloterm/tests/test_scanner.py
diff --git a/tests/test_web_server.py b/peloterm/tests/test_web_server.py
similarity index 100%
rename from tests/test_web_server.py
rename to peloterm/tests/test_web_server.py
diff --git a/pyproject.toml b/pyproject.toml
index 9bdd6eb..6ca58dc 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "peloterm"
-version = "0.1.1"
+version = "0.1.2"
 description = "A terminal-based cycling metrics visualization tool"
 authors = [{ name = "Andrew Marder", email = "andrew.n.marder@gmail.com" }]
 readme = "README.md"
@@ -65,7 +65,7 @@ dev = [
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "function"
-testpaths = ["tests"]
+testpaths = ["peloterm/tests"]
 python_files = ["test_*.py"]
 python_functions = ["test_*"]
 addopts = "-v --tb=short"
diff --git a/build.py b/scripts/build.py
similarity index 89%
rename from build.py
rename to scripts/build.py
index cb1f95c..e27e219 100644
--- a/build.py
+++ b/scripts/build.py
@@ -13,7 +13,9 @@ def build_frontend():
     """Build the Vue frontend."""
     print("🏗️  Building Vue frontend...")
     
-    frontend_dir = Path(__file__).parent / "frontend"
+    scripts_dir = Path(__file__).parent
+    root_dir = scripts_dir.parent
+    frontend_dir = root_dir / "frontend"
     
     # Install dependencies if node_modules doesn't exist
     if not (frontend_dir / "node_modules").exists():
@@ -47,8 +49,11 @@ def build_python_package():
     """Build the Python package distributions."""
     print("📦 Building Python package...")
     
+    scripts_dir = Path(__file__).parent
+    root_dir = scripts_dir.parent
+    
     # Clean previous dist
-    dist_dir = Path(__file__).parent / "dist"
+    dist_dir = root_dir / "dist"
     if dist_dir.exists():
         shutil.rmtree(dist_dir)
     dist_dir.mkdir()
@@ -80,7 +85,9 @@ def build_python_package():
 
 def verify_build():
     """Verify that the build output exists."""
-    static_dir = Path(__file__).parent / "peloterm" / "web" / "static"
+    scripts_dir = Path(__file__).parent
+    root_dir = scripts_dir.parent
+    static_dir = root_dir / "peloterm" / "web" / "static"
     index_file = static_dir / "index.html"
     
     if not index_file.exists():
@@ -97,7 +104,9 @@ def verify_build():
 
 def clean_build():
     """Clean previous build artifacts."""
-    static_dir = Path(__file__).parent / "peloterm" / "web" / "static"
+    scripts_dir = Path(__file__).parent
+    root_dir = scripts_dir.parent
+    static_dir = root_dir / "peloterm" / "web" / "static"
     
     if static_dir.exists():
         print("🧹 Cleaning previous build...")
diff --git a/dev.py b/scripts/dev.py
similarity index 93%
rename from dev.py
rename to scripts/dev.py
index 49a332c..4629a9e 100644
--- a/dev.py
+++ b/scripts/dev.py
@@ -12,7 +12,7 @@
 
 def run_vue_dev():
     """Run the Vue development server."""
-    frontend_dir = Path(__file__).parent / "frontend"
+    frontend_dir = Path(__file__).parent.parent / "frontend"
     return subprocess.Popen(
         ["npm", "run", "dev"],
         cwd=frontend_dir
@@ -22,7 +22,7 @@ def run_fastapi_dev():
     """Run the FastAPI development server."""
     return subprocess.Popen(
         [sys.executable, "-m", "peloterm.web.server"],
-        cwd=Path(__file__).parent
+        cwd=Path(__file__).parent.parent
     )
 
 def dev_mode():
@@ -63,7 +63,7 @@ def prod_mode():
     print("=" * 40)
     
     # Check if built files exist
-    static_dir = Path(__file__).parent / "peloterm" / "web" / "static"
+    static_dir = Path(__file__).parent.parent / "peloterm" / "web" / "static"
     if not (static_dir / "index.html").exists():
         print("❌ No built frontend found. Run 'python build.py' first.")
         sys.exit(1)