chore(main): release 0.7.2 (#559 )

fix: docker image not loading libgomp.so.1 for torch (#560 )
On ARM64, the docker iamge crash because torch cannot load libgomp.so.1 -- Look like pytorch does not install the same packages depending the platform. AMD64: /app/.venv/lib/python3.12/site-packages/torch/lib/libgomp.so.1 /app/.venv/lib/python3.12/site-packages/ctranslate2.libs/libgomp-a34b3233.so.1.0.0 /app/.venv/lib/python3.12/site-packages/scikit_learn.libs/libgomp-a34b3233.so.1.0.0 ARM64: /app/.venv/lib/python3.12/site-packages/ctranslate2.libs/libgomp-d22c30c5.so.1.0.0 /app/.venv/lib/python3.12/site-packages/scikit_learn.libs/libgomp-947d5fa1.so.1.0.0 /app/.venv/lib/python3.12/site-packages/torch.libs/libgomp-947d5fa1.so.1.0.0
2025-12-20 20:29:06 +00:00 · 2025-08-21 21:00:05 -06:00 · 2025-08-21 16:41:35 -06:00 · 2025-08-21 14:52:29 -04:00 · 2025-08-20 23:23:27 -06:00 · 2025-08-20 23:22:41 -06:00
160 changed files with 24003 additions and 13134 deletions
--- a/.github/workflows/db_migrations.yml
+++ b/.github/workflows/db_migrations.yml
@@ -17,10 +17,40 @@ on:
 jobs:
  test-migrations:
    runs-on: ubuntu-latest
+    services:
+      postgres:
+        image: postgres:17
+        env:
+          POSTGRES_USER: reflector
+          POSTGRES_PASSWORD: reflector
+          POSTGRES_DB: reflector
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd pg_isready -h 127.0.0.1 -p 5432
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+
+    env:
+      DATABASE_URL: postgresql://reflector:reflector@localhost:5432/reflector

    steps:
      - uses: actions/checkout@v4

+      - name: Install PostgreSQL client
+        run: sudo apt-get update && sudo apt-get install -y postgresql-client | cat
+
+      - name: Wait for Postgres
+        run: |
+          for i in {1..30}; do
+            if pg_isready -h localhost -p 5432; then
+              echo "Postgres is ready"
+              break
+            fi
+            echo "Waiting for Postgres... ($i)" && sleep 1
+          done
+
      - name: Install uv
        uses: astral-sh/setup-uv@v3
        with:
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -8,18 +8,30 @@ env:
  ECR_REPOSITORY: reflector

 jobs:
-  deploy:
-    runs-on: ubuntu-latest
+  build:
+    strategy:
+      matrix:
+        include:
+          - platform: linux/amd64
+            runner: linux-amd64
+            arch: amd64
+          - platform: linux/arm64
+            runner: linux-arm64
+            arch: arm64
+
+    runs-on: ${{ matrix.runner }}

    permissions:
-      deployments: write
      contents: read

+    outputs:
+      registry: ${{ steps.login-ecr.outputs.registry }}
+
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4

      - name: Configure AWS credentials
-        uses: aws-actions/configure-aws-credentials@0e613a0980cbf65ed5b322eb7a1e075d28913a83
+        uses: aws-actions/configure-aws-credentials@v4
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
@@ -27,21 +39,52 @@ jobs:

      - name: Login to Amazon ECR
        id: login-ecr
-        uses: aws-actions/amazon-ecr-login@62f4f872db3836360b72999f4b87f1ff13310f3a
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
+        uses: aws-actions/amazon-ecr-login@v2

      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v3

-      - name: Build and push
-        id: docker_build
-        uses: docker/build-push-action@v4
+      - name: Build and push ${{ matrix.arch }}
+        uses: docker/build-push-action@v5
        with:
          context: server
-          platforms: linux/amd64,linux/arm64
+          platforms: ${{ matrix.platform }}
          push: true
-          tags: ${{ steps.login-ecr.outputs.registry }}/${{ env.ECR_REPOSITORY }}:latest
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
+          tags: ${{ steps.login-ecr.outputs.registry }}/${{ env.ECR_REPOSITORY }}:latest-${{ matrix.arch }}
+          cache-from: type=gha,scope=${{ matrix.arch }}
+          cache-to: type=gha,mode=max,scope=${{ matrix.arch }}
+          github-token: ${{ secrets.GHA_CACHE_TOKEN }}
+          provenance: false
+
+  create-manifest:
+    runs-on: ubuntu-latest
+    needs: [build]
+
+    permissions:
+      deployments: write
+      contents: read
+
+    steps:
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ env.AWS_REGION }}
+
+      - name: Login to Amazon ECR
+        uses: aws-actions/amazon-ecr-login@v2
+
+      - name: Create and push multi-arch manifest
+        run: |
+          # Get the registry URL (since we can't easily access job outputs in matrix)
+          ECR_REGISTRY=$(aws ecr describe-registry --query 'registryId' --output text).dkr.ecr.${{ env.AWS_REGION }}.amazonaws.com
+
+          docker manifest create \
+            $ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:latest \
+            $ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:latest-amd64 \
+            $ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:latest-arm64
+
+          docker manifest push $ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:latest
+
+          echo "✅ Multi-arch manifest pushed: $ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:latest"
--- a/.github/workflows/pre-commit.yml
+++ b/.github/workflows/pre-commit.yml
@@ -0,0 +1,24 @@
+name: pre-commit
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  pre-commit:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v5
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 10
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: "pnpm"
+          cache-dependency-path: "www/pnpm-lock.yaml"
+      - name: Install dependencies
+        run: cd www && pnpm install --frozen-lockfile
+      - uses: pre-commit/action@v3.0.1
--- a/.github/workflows/test_server.yml
+++ b/.github/workflows/test_server.yml
@@ -19,29 +19,41 @@ jobs:
    steps:
      - uses: actions/checkout@v4
      - name: Install uv
-        uses: astral-sh/setup-uv@v3
+        uses: astral-sh/setup-uv@v6
        with:
          enable-cache: true
          working-directory: server
-
      - name: Tests
        run: |
          cd server
          uv run -m pytest -v tests

-  docker:
-    runs-on: ubuntu-latest
+  docker-amd64:
+    runs-on: linux-amd64
    steps:
      - uses: actions/checkout@v4
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-      - name: Build and push
-        id: docker_build
-        uses: docker/build-push-action@v4
+        uses: docker/setup-buildx-action@v3
+      - name: Build AMD64
+        uses: docker/build-push-action@v6
        with:
          context: server
-          platforms: linux/amd64,linux/arm64
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
+          platforms: linux/amd64
+          cache-from: type=gha,scope=amd64
+          cache-to: type=gha,mode=max,scope=amd64
+          github-token: ${{ secrets.GHA_CACHE_TOKEN }}
+
+  docker-arm64:
+    runs-on: linux-arm64
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      - name: Build ARM64
+        uses: docker/build-push-action@v6
+        with:
+          context: server
+          platforms: linux/arm64
+          cache-from: type=gha,scope=arm64
+          cache-to: type=gha,mode=max,scope=arm64
+          github-token: ${{ secrets.GHA_CACHE_TOKEN }}
--- a/.gitignore
+++ b/.gitignore
@@ -13,3 +13,5 @@ restart-dev.sh
 data/
 www/REFACTOR.md
 www/reload-frontend
+server/test.sqlite
+CLAUDE.local.md
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -3,10 +3,10 @@
 repos:
  - repo: local
    hooks:
-      - id: yarn-format
-        name: run yarn format
+      - id: format
+        name: run format
        language: system
-        entry: bash -c 'cd www && yarn format'
+        entry: bash -c 'cd www && pnpm format'
        pass_filenames: false
        files: ^www/

@@ -23,8 +23,7 @@ repos:
      - id: ruff
        args:
          - --fix
-          - --select
-          - I,F401
+          # Uses select rules from server/pyproject.toml
        files: ^server/
      - id: ruff-format
        files: ^server/
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,64 @@
 # Changelog

+## [0.7.2](https://github.com/Monadical-SAS/reflector/compare/v0.7.1...v0.7.2) (2025-08-21)
+
+
+### Bug Fixes
+
+* docker image not loading libgomp.so.1 for torch ([#560](https://github.com/Monadical-SAS/reflector/issues/560)) ([773fccd](https://github.com/Monadical-SAS/reflector/commit/773fccd93e887c3493abc2e4a4864dddce610177))
+* include shared rooms to search ([#558](https://github.com/Monadical-SAS/reflector/issues/558)) ([499eced](https://github.com/Monadical-SAS/reflector/commit/499eced3360b84fb3a90e1c8a3b554290d21adc2))
+
+## [0.7.1](https://github.com/Monadical-SAS/reflector/compare/v0.7.0...v0.7.1) (2025-08-21)
+
+
+### Bug Fixes
+
+* webvtt db null expectation mismatch ([#556](https://github.com/Monadical-SAS/reflector/issues/556)) ([e67ad1a](https://github.com/Monadical-SAS/reflector/commit/e67ad1a4a2054467bfeb1e0258fbac5868aaaf21))
+
+## [0.7.0](https://github.com/Monadical-SAS/reflector/compare/v0.6.1...v0.7.0) (2025-08-21)
+
+
+### Features
+
+* delete recording with transcript ([#547](https://github.com/Monadical-SAS/reflector/issues/547)) ([99cc984](https://github.com/Monadical-SAS/reflector/commit/99cc9840b3f5de01e0adfbfae93234042d706d13))
+* pipeline improvement with file processing, parakeet, silero-vad ([#540](https://github.com/Monadical-SAS/reflector/issues/540)) ([bcc29c9](https://github.com/Monadical-SAS/reflector/commit/bcc29c9e0050ae215f89d460e9d645aaf6a5e486))
+* postgresql migration and removal of sqlite in pytest ([#546](https://github.com/Monadical-SAS/reflector/issues/546)) ([cd1990f](https://github.com/Monadical-SAS/reflector/commit/cd1990f8f0fe1503ef5069512f33777a73a93d7f))
+* search backend ([#537](https://github.com/Monadical-SAS/reflector/issues/537)) ([5f9b892](https://github.com/Monadical-SAS/reflector/commit/5f9b89260c9ef7f3c921319719467df22830453f))
+* search frontend  ([#551](https://github.com/Monadical-SAS/reflector/issues/551)) ([3657242](https://github.com/Monadical-SAS/reflector/commit/365724271ca6e615e3425125a69ae2b46ce39285))
+
+
+### Bug Fixes
+
+* evaluation cli event wrap ([#536](https://github.com/Monadical-SAS/reflector/issues/536)) ([941c3db](https://github.com/Monadical-SAS/reflector/commit/941c3db0bdacc7b61fea412f3746cc5a7cb67836))
+* use structlog not logging ([#550](https://github.com/Monadical-SAS/reflector/issues/550)) ([27e2f81](https://github.com/Monadical-SAS/reflector/commit/27e2f81fda5232e53edc729d3e99c5ef03adbfe9))
+
+## [0.6.1](https://github.com/Monadical-SAS/reflector/compare/v0.6.0...v0.6.1) (2025-08-06)
+
+
+### Bug Fixes
+
+* delayed waveform loading ([#538](https://github.com/Monadical-SAS/reflector/issues/538)) ([ef64146](https://github.com/Monadical-SAS/reflector/commit/ef64146325d03f64dd9a1fe40234fb3e7e957ae2))
+
+## [0.6.0](https://github.com/Monadical-SAS/reflector/compare/v0.5.0...v0.6.0) (2025-08-05)
+
+
+### ⚠ BREAKING CHANGES
+
+* Configuration keys have changed. Update your .env file:
+    - TRANSCRIPT_MODAL_API_KEY → TRANSCRIPT_API_KEY
+    - LLM_MODAL_API_KEY → (removed, use TRANSCRIPT_API_KEY)
+    - Add DIARIZATION_API_KEY and TRANSLATE_API_KEY if using those services
+
+### Features
+
+* implement service-specific Modal API keys with auto processor pattern ([#528](https://github.com/Monadical-SAS/reflector/issues/528)) ([650befb](https://github.com/Monadical-SAS/reflector/commit/650befb291c47a1f49e94a01ab37d8fdfcd2b65d))
+* use llamaindex everywhere ([#525](https://github.com/Monadical-SAS/reflector/issues/525)) ([3141d17](https://github.com/Monadical-SAS/reflector/commit/3141d172bc4d3b3d533370c8e6e351ea762169bf))
+
+
+### Miscellaneous Chores
+
+* **main:** release 0.6.0 ([ecdbf00](https://github.com/Monadical-SAS/reflector/commit/ecdbf003ea2476c3e95fd231adaeb852f2943df0))
+
 ## [0.5.0](https://github.com/Monadical-SAS/reflector/compare/v0.4.0...v0.5.0) (2025-07-31)


--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -62,7 +62,7 @@ uv run python -m reflector.tools.process path/to/audio.wav
 **Setup:**
 ```bash
 # Install dependencies
-yarn install
+pnpm install

 # Copy configuration templates
 cp .env_template .env
@@ -72,19 +72,19 @@ cp config-template.ts config.ts
 **Development:**
 ```bash
 # Start development server
-yarn dev
+pnpm dev

 # Generate TypeScript API client from OpenAPI spec
-yarn openapi
+pnpm openapi

 # Lint code
-yarn lint
+pnpm lint

 # Format code
-yarn format
+pnpm format

 # Build for production
-yarn build
+pnpm build
 ```

 ### Docker Compose (Full Stack)
@@ -144,7 +144,9 @@ All endpoints prefixed `/v1/`:
 **Backend** (`server/.env`):
 - `DATABASE_URL` - Database connection string
 - `REDIS_URL` - Redis broker for Celery
- `MODAL_TOKEN_ID`, `MODAL_TOKEN_SECRET` - Modal.com GPU processing
+- `TRANSCRIPT_BACKEND=modal` + `TRANSCRIPT_MODAL_API_KEY` - Modal.com transcription
+- `DIARIZATION_BACKEND=modal` + `DIARIZATION_MODAL_API_KEY` - Modal.com diarization
+- `TRANSLATION_BACKEND=modal` + `TRANSLATION_MODAL_API_KEY` - Modal.com translation
 - `WHEREBY_API_KEY` - Video platform integration
 - `REFLECTOR_AUTH_BACKEND` - Authentication method (none, jwt)

--- a/IMPLEMENTATION_STATUS.md
+++ b/IMPLEMENTATION_STATUS.md
@@ -1,264 +0,0 @@
-# Daily.co Migration Implementation Status
-
-## Completed Components
-
-### 1. Platform Abstraction Layer (`server/reflector/video_platforms/`)
- **base.py**: Abstract interface defining all platform operations
- **whereby.py**: Whereby implementation wrapping existing functionality
- **daily.py**: Daily.co client implementation (ready for testing when credentials available)
- **mock.py**: Mock implementation for unit testing
- **registry.py**: Platform registration and discovery
- **factory.py**: Factory methods for creating platform clients
-
-### 2. Database Updates
- **Models**: Added `platform` field to Room and Meeting tables
- **Migration**: Created migration `20250801180012_add_platform_support.py`
- **Controllers**: Updated to handle platform field
-
-### 3. Configuration
- **Settings**: Added Daily.co configuration variables
- **Feature Flags**:
-  - `DAILY_MIGRATION_ENABLED`: Master switch for migration
-  - `DAILY_MIGRATION_ROOM_IDS`: List of specific rooms to migrate
-  - `DEFAULT_VIDEO_PLATFORM`: Default platform when migration enabled
-
-### 4. Backend API Updates
- **Room Creation**: Now assigns platform based on feature flags
- **Meeting Creation**: Uses platform abstraction instead of direct Whereby calls
- **Response Models**: Include platform field
- **Webhook Handler**: Added Daily.co webhook endpoint at `/v1/daily_webhook`
-
-### 5. Frontend Components (`www/app/[roomName]/components/`)
- **RoomContainer.tsx**: Platform-agnostic container that routes to appropriate component
- **WherebyRoom.tsx**: Extracted existing Whereby functionality with consent management
- **DailyRoom.tsx**: Daily.co implementation using DailyIframe
- **Dependencies**: Added `@daily-co/daily-js` and `@daily-co/daily-react`
-
-## How It Works
-
-1. **Platform Selection**:
-   - If `DAILY_MIGRATION_ENABLED=false` → Always use Whereby
-   - If enabled and room ID in `DAILY_MIGRATION_ROOM_IDS` → Use Daily
-   - Otherwise → Use `DEFAULT_VIDEO_PLATFORM`
-
-2. **Meeting Creation Flow**:
-   ```python
-   platform = get_platform_for_room(room.id)
-   client = create_platform_client(platform)
-   meeting_data = await client.create_meeting(...)
-   ```
-
-3. **Testing Without Credentials**:
-   - Use `platform="mock"` in tests
-   - Mock client simulates all operations
-   - No external API calls needed
-
-## Next Steps
-
-### When Daily.co Credentials Available:
-
-1. **Set Environment Variables**:
-   ```bash
-   DAILY_API_KEY=your-key
-   DAILY_WEBHOOK_SECRET=your-secret
-   DAILY_SUBDOMAIN=your-subdomain
-   AWS_DAILY_S3_BUCKET=your-bucket
-   AWS_DAILY_ROLE_ARN=your-role
-   ```
-
-2. **Run Database Migration**:
-   ```bash
-   cd server
-   uv run alembic upgrade head
-   ```
-
-3. **Test Platform Creation**:
-   ```python
-   from reflector.video_platforms.factory import create_platform_client
-   client = create_platform_client("daily")
-   # Test operations...
-   ```
-
-### 6. Testing & Validation (`server/tests/`)
- **test_video_platforms.py**: Comprehensive unit tests for all platform clients
- **test_daily_webhook.py**: Integration tests for Daily.co webhook handling
- **utils/video_platform_test_utils.py**: Testing utilities and helpers
- **Mock Testing**: Full test coverage using mock platform client
- **Webhook Testing**: HMAC signature validation and event processing tests
-
-### All Core Implementation Complete ✅
-
-The Daily.co migration implementation is now complete and ready for testing with actual credentials:
-
- ✅ Platform abstraction layer with factory pattern
- ✅ Database schema migration
- ✅ Feature flag system for gradual rollout
- ✅ Backend API integration with webhook handling
- ✅ Frontend platform-agnostic components
- ✅ Comprehensive test suite with >95% coverage
-
-## Daily.co Webhook Integration
-
-### Webhook Configuration
-
-Daily.co webhooks are configured via API (no dashboard interface). Use the Daily.co REST API to set up webhook endpoints:
-
-```bash
-# Configure webhook endpoint
-curl -X POST https://api.daily.co/v1/webhook-endpoints \
-  -H "Authorization: Bearer ${DAILY_API_KEY}" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "url": "https://yourdomain.com/v1/daily_webhook",
-    "events": [
-      "participant.joined",
-      "participant.left",
-      "recording.started",
-      "recording.ready-to-download",
-      "recording.error"
-    ]
-  }'
-```
-
-### Webhook Event Examples
-
-**Participant Joined:**
-```json
-{
-  "type": "participant.joined",
-  "id": "evt_participant_joined_1640995200",
-  "ts": 1640995200000,
-  "data": {
-    "room": {"name": "test-room-123-abc"},
-    "participant": {
-      "id": "participant-123",
-      "user_name": "John Doe",
-      "session_id": "session-456"
-    }
-  }
-}
-```
-
-**Recording Ready:**
-```json
-{
-  "type": "recording.ready-to-download",
-  "id": "evt_recording_ready_1640995200",
-  "ts": 1640995200000,
-  "data": {
-    "room": {"name": "test-room-123-abc"},
-    "recording": {
-      "id": "recording-789",
-      "status": "finished",
-      "download_url": "https://bucket.s3.amazonaws.com/recording.mp4",
-      "start_time": "2025-01-01T10:00:00Z",
-      "duration": 1800
-    }
-  }
-}
-```
-
-### Webhook Signature Verification
-
-Daily.co uses HMAC-SHA256 for webhook verification:
-
-```python
-import hmac
-import hashlib
-
-def verify_daily_webhook(body: bytes, signature: str, secret: str) -> bool:
-    expected = hmac.new(secret.encode(), body, hashlib.sha256).hexdigest()
-    return hmac.compare_digest(expected, signature)
-```
-
-Signature is sent in the `X-Daily-Signature` header.
-
-### Recording Processing Flow
-
-1. **Daily.co Meeting Ends** → Recording processed
-2. **Webhook Fired** → `recording.ready-to-download` event
-3. **Webhook Handler** → Extracts download URL and recording ID
-4. **Background Task** → `process_recording_from_url.delay()` queued
-5. **Download & Process** → Audio downloaded, validated, transcribed
-6. **ML Pipeline** → Same processing as Whereby recordings
-
-```python
-# New Celery task for Daily.co recordings
-@shared_task
-@asynctask
-async def process_recording_from_url(recording_url: str, meeting_id: str, recording_id: str):
-    # Downloads from Daily.co URL → Creates transcript → Triggers ML pipeline
-    # Identical processing to S3-based recordings after download
-```
-
-## Testing the Current Implementation
-
-### Running the Test Suite
-
-```bash
-# Run all video platform tests
-uv run pytest tests/test_video_platforms.py -v
-
-# Run webhook integration tests
-uv run pytest tests/test_daily_webhook.py -v
-
-# Run with coverage
-uv run pytest tests/test_video_platforms.py tests/test_daily_webhook.py --cov=reflector.video_platforms --cov=reflector.views.daily
-```
-
-### Manual Testing with Mock Platform
-
-```python
-from reflector.video_platforms.factory import create_platform_client
-
-# Create mock client (no credentials needed)
-client = create_platform_client("mock")
-
-# Test operations
-from reflector.db.rooms import Room
-from datetime import datetime, timedelta
-
-mock_room = Room(id="test-123", name="Test Room", recording_type="cloud")
-meeting = await client.create_meeting(
-    room_name_prefix="test",
-    end_date=datetime.utcnow() + timedelta(hours=1),
-    room=mock_room
-)
-print(f"Created meeting: {meeting.room_url}")
-```
-
-### Testing Daily.co Recording Processing
-
-```python
-# Test webhook payload processing
-from reflector.views.daily import daily_webhook
-from reflector.worker.process import process_recording_from_url
-
-# Simulate webhook event
-event_data = {
-    "type": "recording.ready-to-download",
-    "id": "evt_123",
-    "ts": 1640995200000,
-    "data": {
-        "room": {"name": "test-room-123"},
-        "recording": {
-            "id": "rec-456",
-            "download_url": "https://daily.co/recordings/test.mp4"
-        }
-    }
-}
-
-# Test processing task (when credentials available)
-await process_recording_from_url(
-    recording_url="https://daily.co/recordings/test.mp4",
-    meeting_id="meeting-123",
-    recording_id="rec-456"
-)
-```
-
-## Architecture Benefits
-
-1. **Testable**: Mock implementation allows testing without external dependencies
-2. **Extensible**: Easy to add new platforms (Zoom, Teams, etc.)
-3. **Gradual Migration**: Feature flags enable room-by-room migration
-4. **Rollback Ready**: Can disable Daily.co instantly via feature flag
--- a/PLAN.md
+++ b/PLAN.md
@@ -1,287 +0,0 @@
-# Daily.co Migration Plan - Feature Parity Approach
-
-## Overview
-
-This plan outlines a systematic migration from Whereby to Daily.co, focusing on **1:1 feature parity** without introducing new capabilities. The goal is to improve code quality, developer experience, and platform reliability while maintaining the exact same user experience and processing pipeline.
-
-## Migration Principles
-
-1. **No Breaking Changes**: Existing recordings and workflows must continue to work
-2. **Feature Parity First**: Match current functionality exactly before adding improvements
-3. **Gradual Rollout**: Use feature flags to control migration per room/user
-4. **Minimal Risk**: Keep changes isolated and reversible
-
-## Phase 1: Foundation
-
-### 1.1 Environment Setup
-**Owner**: Backend Developer
-
- [ ] Create Daily.co account and obtain API credentials (PENDING - User to provide)
- [x] Add environment variables to `.env` files:
-  ```bash
-  DAILY_API_KEY=your-api-key
-  DAILY_WEBHOOK_SECRET=your-webhook-secret
-  DAILY_SUBDOMAIN=your-subdomain
-  AWS_DAILY_ROLE_ARN=arn:aws:iam::xxx:role/daily-recording
-  ```
- [ ] Set up Daily.co webhook endpoint in dashboard (PENDING - Credentials needed)
- [ ] Configure S3 bucket permissions for Daily.co (PENDING - Credentials needed)
-
-### 1.2 Database Migration
-**Owner**: Backend Developer
-
- [x] Create Alembic migration:
-  ```python
-  # server/migrations/versions/20250801180012_add_platform_support.py
-  def upgrade():
-      op.add_column('rooms', sa.Column('platform', sa.String(), server_default='whereby'))
-      op.add_column('meetings', sa.Column('platform', sa.String(), server_default='whereby'))
-  ```
- [ ] Run migration on development database (USER TO RUN: `uv run alembic upgrade head`)
- [x] Update models to include platform field
-
-### 1.3 Feature Flag System
-**Owner**: Full-stack Developer
-
- [x] Implement feature flag in backend settings:
-  ```python
-  DAILY_MIGRATION_ENABLED = env.bool("DAILY_MIGRATION_ENABLED", False)
-  DAILY_MIGRATION_ROOM_IDS = env.list("DAILY_MIGRATION_ROOM_IDS", [])
-  ```
- [x] Add platform selection logic to room creation
- [ ] Create admin UI to toggle platform per room (FUTURE - Not in Phase 1)
-
-### 1.4 Daily.co API Client
-**Owner**: Backend Developer
-
- [x] Create `server/reflector/video_platforms/` with core functionality:
-  - `create_meeting()` - Match Whereby's meeting creation
-  - `get_room_sessions()` - Room status checking
-  - `delete_room()` - Cleanup functionality
- [x] Add comprehensive error handling
- [ ] Write unit tests for API client (Phase 4)
-
-## Phase 2: Backend Integration
-
-### 2.1 Webhook Handler
-**Owner**: Backend Developer
-
- [x] Create `server/reflector/views/daily.py` webhook endpoint
- [x] Implement HMAC signature verification
- [x] Handle events:
-  - `participant.joined`
-  - `participant.left`
-  - `recording.started`
-  - `recording.ready-to-download`
- [x] Map Daily.co events to existing database updates
- [x] Register webhook router in main app
- [ ] Add webhook tests with mocked events (Phase 4)
-
-### 2.2 Room Management Updates
-**Owner**: Backend Developer
-
- [x] Update `server/reflector/views/rooms.py`:
-  ```python
-  # Uses platform abstraction layer
-  platform = get_platform_for_room(room.id)
-  client = create_platform_client(platform)
-  meeting_data = await client.create_meeting(...)
-  ```
- [x] Ensure room URLs are stored correctly
- [x] Update meeting status checks to support both platforms
- [ ] Test room creation/deletion for both platforms (Phase 4)
-
-## Phase 3: Frontend Migration
-
-### 3.1 Daily.co React Setup
-**Owner**: Frontend Developer
-
- [x] Install Daily.co packages:
-  ```bash
-  yarn add @daily-co/daily-react @daily-co/daily-js
-  ```
- [x] Create platform-agnostic components structure
- [x] Set up TypeScript interfaces for meeting data
-
-### 3.2 Room Component Refactor
-**Owner**: Frontend Developer
-
- [x] Create platform-agnostic room component:
-  ```tsx
-  // www/app/[roomName]/components/RoomContainer.tsx
-  export default function RoomContainer({ params }) {
-    const platform = meeting.response.platform || "whereby";
-    if (platform === 'daily') {
-      return <DailyRoom meeting={meeting.response} />
-    }
-    return <WherebyRoom meeting={meeting.response} />
-  }
-  ```
- [x] Implement `DailyRoom` component with:
-  - Call initialization using DailyIframe
-  - Recording consent flow
-  - Leave meeting handling
- [x] Extract `WherebyRoom` component maintaining existing functionality
- [x] Simplified focus management (Daily.co handles this internally)
-
-### 3.3 Consent Dialog Integration
-**Owner**: Frontend Developer
-
- [x] Adapt consent dialog for Daily.co (uses same API endpoints)
- [x] Ensure recording status is properly tracked
- [x] Maintain consistent consent UI across both platforms
- [ ] Test consent flow with Daily.co recordings (Phase 4)
-
-## Phase 4: Testing & Validation
-
-### 4.1 Unit Testing ✅
-**Owner**: Backend Developer
-
- [x] Create comprehensive unit tests for all platform clients
- [x] Test mock platform client with full coverage
- [x] Test platform factory and registry functionality
- [x] Test webhook signature verification for all platforms
- [x] Test meeting lifecycle operations (create, delete, sessions)
-
-### 4.2 Integration Testing ✅
-**Owner**: Backend Developer
-
- [x] Create webhook integration tests with mocked HTTP client
- [x] Test Daily.co webhook event processing
- [x] Test participant join/leave event handling
- [x] Test recording start/ready event processing
- [x] Test webhook signature validation with HMAC
- [x] Test error handling for malformed events
-
-### 4.3 Test Utilities ✅
-**Owner**: Backend Developer
-
- [x] Create video platform test helper utilities
- [x] Create webhook event generators for testing
- [x] Create platform-agnostic test scenarios
- [x] Implement mock data factories for consistent testing
-
-### 4.4 Ready for Live Testing
-**Owner**: QA + Development Team
-
- [ ] Test complete flow with actual Daily.co credentials:
-  - Room creation
-  - Join meeting
-  - Recording consent
-  - Recording to S3
-  - Webhook processing
-  - Transcript generation
- [ ] Verify S3 paths are compatible
- [ ] Check recording format (MP4) matches
- [ ] Ensure processing pipeline works unchanged
-
-## Phase 5: Gradual Rollout
-
-### 5.1 Internal Testing
-**Owner**: Development Team
-
- [ ] Enable Daily.co for internal test rooms
- [ ] Monitor logs and error rates
- [ ] Fix any issues discovered
- [ ] Verify recordings process correctly
-
-### 5.2 Beta Rollout
-**Owner**: DevOps + Product
-
- [ ] Select beta users/rooms
- [ ] Enable Daily.co via feature flag
- [ ] Monitor metrics:
-  - Error rates
-  - Recording success
-  - User feedback
- [ ] Create rollback plan
-
-### 5.3 Full Migration
-**Owner**: DevOps + Product
-
- [ ] Gradually increase Daily.co usage
- [ ] Monitor all metrics
- [ ] Plan Whereby sunset timeline
- [ ] Update documentation
-
-## Success Criteria
-
-### Technical Metrics
- [x] Comprehensive test coverage (>95% for platform abstraction)
- [x] Mock testing confirms API integration patterns work
- [x] Webhook processing tested with realistic event payloads
- [x] Error handling validated for all failure scenarios
- [ ] Live API error rate < 0.1% (pending credentials)
- [ ] Live webhook delivery rate > 99.9% (pending credentials)
- [ ] Recording success rate matches Whereby (pending credentials)
-
-### User Experience
- [x] Platform-agnostic components maintain existing UX
- [x] Recording consent flow preserved across platforms
- [x] Participant tracking architecture unchanged
- [ ] Live call quality validation (pending credentials)
- [ ] Live user acceptance testing (pending credentials)
-
-### Code Quality ✅
- [x] Removed 70+ lines of focus management code in WherebyRoom extraction
- [x] Improved TypeScript coverage with platform interfaces
- [x] Better error handling with platform abstraction
- [x] Cleaner React component structure with platform routing
-
-## Rollback Plan
-
-If issues arise during migration:
-
-1. **Immediate**: Disable Daily.co feature flag
-2. **Short-term**: Revert frontend components via git
-3. **Database**: Platform field defaults to 'whereby'
-4. **Full rollback**: Remove Daily.co code (isolated in separate files)
-
-## Post-Migration Opportunities
-
-Once feature parity is achieved and stable:
-
-1. **Raw-tracks recording** for better diarization
-2. **Real-time transcription** via Daily.co API
-3. **Advanced analytics** and participant insights
-4. **Custom UI** improvements
-5. **Performance optimizations**
-
-## Phase Dependencies
-
- ✅ Backend Integration requires Foundation to be complete
- ✅ Frontend Migration can start after Backend API client is ready
- ✅ Testing requires both Backend and Frontend to be complete
- ⏳ Rollout begins after successful testing (pending Daily.co credentials)
-
-## Risk Matrix
-
-| Risk | Probability | Impact | Mitigation |
-|------|-------------|---------|------------|
-| API differences | Low | Medium | Abstraction layer |
-| Recording format issues | Low | High | Extensive testing |
-| User confusion | Low | Low | Gradual rollout |
-| Performance degradation | Low | Medium | Monitoring |
-
-## Communication Plan
-
-1. **Week 1**: Announce migration plan to team
-2. **Week 2**: Update on development progress
-3. **Beta Launch**: Email to beta users
-4. **Full Launch**: User notification (if UI changes)
-5. **Post-Launch**: Success metrics report
-
---
-
-## Implementation Status: COMPLETE ✅
-
-All development phases are complete and ready for live testing:
-
-✅ **Phase 1**: Foundation (database, config, feature flags)
-✅ **Phase 2**: Backend Integration (API clients, webhooks)
-✅ **Phase 3**: Frontend Migration (platform components)
-✅ **Phase 4**: Testing & Validation (comprehensive test suite)
-
-**Next Steps**: Obtain Daily.co credentials and run live integration testing before gradual rollout.
-
-This implementation prioritizes stability and risk mitigation through a phased approach. The modular design allows for easy adjustments based on live testing findings.
--- a/README.md
+++ b/README.md
@@ -79,7 +79,7 @@ Start with `cd www`.
 **Installation**

 ```bash
-yarn install
+pnpm install
 cp .env_template .env
 cp config-template.ts config.ts
 ```
@@ -89,7 +89,7 @@ Then, fill in the environment variables in `.env` and the configuration in `conf
 **Run in development mode**

 ```bash
-yarn dev
+pnpm dev
 ```

 Then (after completing server setup and starting it) open [http://localhost:3000](http://localhost:3000) to view it in the browser.
@@ -99,7 +99,7 @@ Then (after completing server setup and starting it) open [http://localhost:3000
 To generate the TypeScript files from the openapi.json file, make sure the python server is running, then run:

 ```bash
-yarn openapi
+pnpm openapi
 ```

 ### Backend
--- a/REFACTOR_WHEREBY_FINDING.md
+++ b/REFACTOR_WHEREBY_FINDING.md
@@ -1,586 +0,0 @@
-# Whereby to Daily.co Migration Feasibility Analysis
-
-## Executive Summary
-
-After analysis of the current Whereby integration and Daily.co's capabilities, migrating to Daily.co is technically feasible. The migration can be done in phases:
-
-1. **Phase 1**: Feature parity with current implementation (standard cloud recording)
-2. **Phase 2**: Enhanced capabilities with raw-tracks recording for improved diarization
-
-### Current Implementation Analysis
-
-Based on code review:
- **Webhook handling**: The current webhook handler (`server/reflector/views/whereby.py`) only tracks `num_clients`, not individual participants
- **Focus management**: The frontend has 70+ lines managing focus between Whereby embed and consent dialog
- **Participant tracking**: No participant names or IDs are captured in the current implementation
- **Recording type**: Cloud recording to S3 in MP4 format with mixed audio
-
-### Migration Approach
-
-**Phase 1**: 1:1 feature replacement maintaining current functionality:
- Standard cloud recording (same as current Whereby implementation)
- Same recording workflow: Video platform → S3 → Reflector processing
- No changes to existing diarization or transcription pipeline
-
-**Phase 2**: Enhanced capabilities (future implementation):
- Raw-tracks recording for speaker-separated audio
- Improved diarization with participant-to-audio mapping
- Per-participant transcription accuracy
-
-## Current Whereby Integration Analysis
-
-### Backend Integration
-
-#### Core API Module (`server/reflector/whereby.py`)
- **Meeting Creation**: Creates rooms with S3 recording configuration
- **Session Monitoring**: Tracks meeting status via room sessions API
- **Logo Upload**: Handles branding for meetings
- **Key Functions**:
-  ```python
-  create_meeting(room_name, logo_s3_url) -> dict
-  monitor_room_session(meeting_link) -> dict
-  upload_logo(file_stream, content_type) -> str
-  ```
-
-#### Webhook Handler (`server/reflector/views/whereby.py`)
- **Endpoint**: `/v1/whereby_webhook`
- **Security**: HMAC signature validation
- **Events Handled**:
-  - `room.participant.joined`
-  - `room.participant.left`
- **Pain Point**: Delay between actual join/leave and webhook delivery
-
-#### Room Management (`server/reflector/views/rooms.py`)
- Creates meetings via Whereby API
- Stores meeting data in database
- Manages recording lifecycle
-
-### Frontend Integration
-
-#### Main Room Component (`www/app/[roomName]/page.tsx`)
- Uses `@whereby.com/browser-sdk` (v3.3.4)
- Implements custom `<whereby-embed>` element
- Handles recording consent
- Focus management for accessibility
-
-#### Configuration
- Environment Variables:
-  - `WHEREBY_API_URL`, `WHEREBY_API_KEY`, `WHEREBY_WEBHOOK_SECRET`
-  - AWS S3 credentials for recordings
- Recording workflow: Whereby → S3 → Reflector processing pipeline
-
-## Daily.co Capabilities Analysis
-
-### REST API Features
-
-#### Room Management
-```
-POST /rooms - Create room with configuration
-GET /rooms/:name/presence - Real-time participant data
-POST /rooms/:name/recordings/start - Start recording
-```
-
-#### Recording Options
-```json
-{
-  "enable_recording": "raw-tracks"  // Key feature for diarization
-}
-```
-
-#### Webhook Events
- `participant.joined` / `participant.left`
- `waiting-participant.joined` / `waiting-participant.left`
- `recording.started` / `recording.ready-to-download`
- `recording.error`
-
-### React SDK (@daily-co/daily-react)
-
-#### Modern Hook-based Architecture
-```jsx
-// Participant tracking
-const participantIds = useParticipantIds({ filter: 'remote' });
-const [username, videoState] = useParticipantProperty(id, ['user_name', 'tracks.video.state']);
-
-// Recording management
-const { isRecording, startRecording, stopRecording } = useRecording();
-
-// Real-time participant data
-const participants = useParticipants();
-```
-
-## Feature Comparison
-
-| Feature | Whereby | Daily.co |
-|---------|---------|----------|
-| **Room Creation** | REST API | REST API |
-| **Recording Types** | Cloud (MP4) | Cloud (MP4), Local, Raw-tracks |
-| **S3 Integration** | Direct upload | Direct upload with IAM roles |
-| **Frontend Integration** | Custom element | React hooks or iframe |
-| **Webhooks** | HMAC verified | HMAC verified |
-| **Participant Data** | Via webhooks | Via webhooks + Presence API |
-| **Recording Trigger** | Automatic/manual | Automatic/manual |
-
-## Migration Plan
-
-### Phase 1: Backend API Client
-
-#### 1.1 Create Daily.co API Client (`server/reflector/daily.py`)
-
-```python
-from datetime import datetime
-import httpx
-from reflector.db.rooms import Room
-from reflector.settings import settings
-
-class DailyClient:
-    def __init__(self):
-        self.base_url = "https://api.daily.co/v1"
-        self.headers = {
-            "Authorization": f"Bearer {settings.DAILY_API_KEY}",
-            "Content-Type": "application/json"
-        }
-        self.timeout = 10
-
-    async def create_meeting(self, room_name_prefix: str, end_date: datetime, room: Room) -> dict:
-        """Create a Daily.co room matching current Whereby functionality."""
-        data = {
-            "name": f"{room_name_prefix}-{datetime.now().strftime('%Y%m%d%H%M%S')}",
-            "privacy": "private" if room.is_locked else "public",
-            "properties": {
-                "enable_recording": "raw-tracks", #"cloud",
-                "enable_chat": True,
-                "enable_screenshare": True,
-                "start_video_off": False,
-                "start_audio_off": False,
-                "exp": int(end_date.timestamp()),
-                "enable_recording_ui": False,  # We handle consent ourselves
-            }
-        }
-
-        # if room.recording_type == "cloud":
-        data["properties"]["recording_bucket"] = {
-            "bucket_name": settings.AWS_S3_BUCKET,
-            "bucket_region": settings.AWS_REGION,
-            "assume_role_arn": settings.AWS_DAILY_ROLE_ARN,
-            "path": f"recordings/{data['name']}"
-        }
-
-        async with httpx.AsyncClient() as client:
-            response = await client.post(
-                f"{self.base_url}/rooms",
-                headers=self.headers,
-                json=data,
-                timeout=self.timeout
-            )
-            response.raise_for_status()
-            room_data = response.json()
-
-            # Return in Whereby-compatible format
-            return {
-                "roomUrl": room_data["url"],
-                "hostRoomUrl": room_data["url"] + "?t=" + room_data["config"]["token"],
-                "roomName": room_data["name"],
-                "meetingId": room_data["id"]
-            }
-
-    async def get_room_sessions(self, room_name: str) -> dict:
-        """Get room session data (similar to Whereby's insights)."""
-        async with httpx.AsyncClient() as client:
-            response = await client.get(
-                f"{self.base_url}/rooms/{room_name}",
-                headers=self.headers,
-                timeout=self.timeout
-            )
-            response.raise_for_status()
-            return response.json()
-```
-
-#### 1.2 Update Webhook Handler (`server/reflector/views/daily.py`)
-
-```python
-import hmac
-import json
-from datetime import datetime
-from hashlib import sha256
-from fastapi import APIRouter, HTTPException, Request
-from pydantic import BaseModel
-from reflector.db.meetings import meetings_controller
-from reflector.settings import settings
-
-router = APIRouter()
-
-class DailyWebhookEvent(BaseModel):
-    type: str
-    id: str
-    ts: int
-    data: dict
-
-def verify_daily_webhook(body: bytes, signature: str) -> bool:
-    """Verify Daily.co webhook signature."""
-    expected = hmac.new(
-        settings.DAILY_WEBHOOK_SECRET.encode(),
-        body,
-        sha256
-    ).hexdigest()
-    return hmac.compare_digest(expected, signature)
-
-@router.post("/daily")
-async def daily_webhook(event: DailyWebhookEvent, request: Request):
-    # Verify webhook signature
-    body = await request.body()
-    signature = request.headers.get("X-Daily-Signature", "")
-
-    if not verify_daily_webhook(body, signature):
-        raise HTTPException(status_code=401, detail="Invalid webhook signature")
-
-    # Handle participant events
-    if event.type == "participant.joined":
-        meeting = await meetings_controller.get_by_room_name(event.data["room_name"])
-        if meeting:
-            # Update participant info immediately
-            await meetings_controller.add_participant(
-                meeting.id,
-                participant_id=event.data["participant"]["user_id"],
-                name=event.data["participant"]["user_name"],
-                joined_at=datetime.fromtimestamp(event.ts / 1000)
-            )
-
-    elif event.type == "participant.left":
-        meeting = await meetings_controller.get_by_room_name(event.data["room_name"])
-        if meeting:
-            await meetings_controller.remove_participant(
-                meeting.id,
-                participant_id=event.data["participant"]["user_id"],
-                left_at=datetime.fromtimestamp(event.ts / 1000)
-            )
-
-    elif event.type == "recording.ready-to-download":
-        # Process cloud recording (same as Whereby)
-        meeting = await meetings_controller.get_by_room_name(event.data["room_name"])
-        if meeting:
-            # Queue standard processing task
-            from reflector.worker.tasks import process_recording
-            process_recording.delay(
-                meeting_id=meeting.id,
-                recording_url=event.data["download_link"],
-                recording_id=event.data["recording_id"]
-            )
-
-    return {"status": "ok"}
-```
-
-### Phase 2: Frontend Components
-
-#### 2.1 Replace Whereby SDK with Daily React
-
-First, update dependencies:
-```bash
-# Remove Whereby
-yarn remove @whereby.com/browser-sdk
-
-# Add Daily.co
-yarn add @daily-co/daily-react @daily-co/daily-js
-```
-
-#### 2.2 New Room Component (`www/app/[roomName]/page.tsx`)
-
-```tsx
-"use client";
-
-import { useCallback, useEffect, useRef, useState } from "react";
-import {
-  DailyProvider,
-  useDaily,
-  useParticipantIds,
-  useRecording,
-  useDailyEvent,
-  useLocalParticipant,
-} from "@daily-co/daily-react";
-import { Box, Button, Text, VStack, HStack, Spinner } from "@chakra-ui/react";
-import { toaster } from "../components/ui/toaster";
-import useRoomMeeting from "./useRoomMeeting";
-import { useRouter } from "next/navigation";
-import { notFound } from "next/navigation";
-import useSessionStatus from "../lib/useSessionStatus";
-import { useRecordingConsent } from "../recordingConsentContext";
-import DailyIframe from "@daily-co/daily-js";
-
-// Daily.co Call Interface Component
-function CallInterface() {
-  const daily = useDaily();
-  const { isRecording, startRecording, stopRecording } = useRecording();
-  const localParticipant = useLocalParticipant();
-  const participantIds = useParticipantIds({ filter: "remote" });
-
-  // Real-time participant tracking
-  useDailyEvent("participant-joined", useCallback((event) => {
-    console.log(`${event.participant.user_name} joined the call`);
-    // No need for webhooks - we have immediate access!
-  }, []));
-
-  useDailyEvent("participant-left", useCallback((event) => {
-    console.log(`${event.participant.user_name} left the call`);
-  }, []));
-
-  return (
-    <Box position="relative" width="100vw" height="100vh">
-      {/* Daily.co automatically handles the video/audio UI */}
-      <Box
-        as="iframe"
-        src={daily?.iframe()?.src}
-        width="100%"
-        height="100%"
-        allow="camera; microphone; fullscreen; speaker; display-capture"
-        style={{ border: "none" }}
-      />
-
-      {/* Recording status indicator */}
-      {isRecording && (
-        <Box
-          position="absolute"
-          top={4}
-          right={4}
-          bg="red.500"
-          color="white"
-          px={3}
-          py={1}
-          borderRadius="md"
-          fontSize="sm"
-        >
-          Recording
-        </Box>
-      )}
-
-      {/* Participant count with real-time data */}
-      <Box position="absolute" bottom={4} left={4} bg="gray.800" color="white" px={3} py={1} borderRadius="md">
-        Participants: {participantIds.length + 1}
-      </Box>
-    </Box>
-  );
-}
-
-// Main Room Component with Daily.co Integration
-export default function Room({ params }: { params: { roomName: string } }) {
-  const roomName = params.roomName;
-  const meeting = useRoomMeeting(roomName);
-  const router = useRouter();
-  const { isLoading, isAuthenticated } = useSessionStatus();
-  const [dailyUrl, setDailyUrl] = useState<string | null>(null);
-  const [callFrame, setCallFrame] = useState<DailyIframe | null>(null);
-
-  // Initialize Daily.co call
-  useEffect(() => {
-    if (!meeting?.response?.room_url) return;
-
-    const frame = DailyIframe.createCallObject({
-      showLeaveButton: true,
-      showFullscreenButton: true,
-    });
-
-    frame.on("left-meeting", () => {
-      router.push("/browse");
-    });
-
-    setCallFrame(frame);
-    setDailyUrl(meeting.response.room_url);
-
-    return () => {
-      frame.destroy();
-    };
-  }, [meeting?.response?.room_url, router]);
-
-  if (isLoading) {
-    return (
-      <Box display="flex" justifyContent="center" alignItems="center" height="100vh">
-        <Spinner color="blue.500" size="xl" />
-      </Box>
-    );
-  }
-
-  if (!dailyUrl || !callFrame) {
-    return null;
-  }
-
-  return (
-    <DailyProvider callObject={callFrame} url={dailyUrl}>
-      <CallInterface />
-      <ConsentDialog meetingId={meeting?.response?.id} />
-    </DailyProvider>
-  );
-}
-
-### Phase 3: Testing & Validation
-
-For Phase 1 (feature parity), the existing processing pipeline remains unchanged:
-
-1. Daily.co records meeting to S3 (same as Whereby)
-2. Webhook notifies when recording is ready
-3. Existing pipeline downloads and processes the MP4 file
-4. Current diarization and transcription tools continue to work
-
-Key validation points:
- Recording format matches (MP4 with mixed audio)
- S3 paths are compatible
- Processing pipeline requires no changes
- Transcript quality remains the same
-
-## Future Enhancement: Raw-Tracks Recording (Phase 2)
-
-### Raw-Tracks Processing for Enhanced Diarization
-
-Daily.co's raw-tracks recording provides individual audio streams per participant, enabling:
-
-```python
-@shared_task
-def process_daily_raw_tracks(meeting_id: str, recording_id: str, tracks: list):
-    """Process Daily.co raw-tracks with perfect speaker attribution."""
-
-    for track in tracks:
-        participant_id = track["participant_id"]
-        participant_name = track["participant_name"]
-        track_url = track["download_url"]
-
-        # Download individual participant audio
-        response = download_track(track_url)
-
-        # Process with known speaker identity
-        transcript = transcribe_audio(
-            audio_data=response.content,
-            speaker_id=participant_id,
-            speaker_name=participant_name
-        )
-
-        # Store with accurate speaker mapping
-        save_transcript_segment(
-            meeting_id=meeting_id,
-            speaker_id=participant_id,
-            text=transcript.text,
-            timestamps=transcript.timestamps
-        )
-```
-
-### Benefits of Raw-Tracks (Future)
-
-1. **Deterministic Speaker Attribution**: Each audio track is already speaker-separated
-2. **Improved Transcription Accuracy**: Clean audio without cross-talk
-3. **Parallel Processing**: Process multiple speakers simultaneously
-4. **Better Metrics**: Accurate talk-time per participant
-
-### Phase 4: Database & Configuration
-
-#### 4.1 Environment Variable Updates
-
-Update `.env` files:
-
-```bash
-# Remove Whereby variables
-# WHEREBY_API_URL=https://api.whereby.dev/v1
-# WHEREBY_API_KEY=your-whereby-key
-# WHEREBY_WEBHOOK_SECRET=your-whereby-secret
-# AWS_WHEREBY_S3_BUCKET=whereby-recordings
-# AWS_WHEREBY_ACCESS_KEY_ID=whereby-key
-# AWS_WHEREBY_ACCESS_KEY_SECRET=whereby-secret
-
-# Add Daily.co variables
-DAILY_API_KEY=your-daily-api-key
-DAILY_WEBHOOK_SECRET=your-daily-webhook-secret
-AWS_DAILY_S3_BUCKET=daily-recordings
-AWS_DAILY_ROLE_ARN=arn:aws:iam::123456789:role/daily-recording-role
-AWS_REGION=us-west-2
-```
-
-#### 4.2 Database Migration
-
-```sql
-- Alembic migration to support Daily.co
-- server/alembic/versions/xxx_migrate_to_daily.py
-
-def upgrade():
-    # Add platform field to support gradual migration
-    op.add_column('rooms', sa.Column('platform', sa.String(), server_default='whereby'))
-    op.add_column('meetings', sa.Column('platform', sa.String(), server_default='whereby'))
-
-    # No other schema changes needed for feature parity
-
-def downgrade():
-    op.drop_column('meetings', 'platform')
-    op.drop_column('rooms', 'platform')
-```
-
-#### 4.3 Settings Update (`server/reflector/settings.py`)
-
-```python
-class Settings(BaseSettings):
-    # Remove Whereby settings
-    # WHEREBY_API_URL: str = "https://api.whereby.dev/v1"
-    # WHEREBY_API_KEY: str
-    # WHEREBY_WEBHOOK_SECRET: str
-    # AWS_WHEREBY_S3_BUCKET: str
-    # AWS_WHEREBY_ACCESS_KEY_ID: str
-    # AWS_WHEREBY_ACCESS_KEY_SECRET: str
-
-    # Add Daily.co settings
-    DAILY_API_KEY: str
-    DAILY_WEBHOOK_SECRET: str
-    AWS_DAILY_S3_BUCKET: str
-    AWS_DAILY_ROLE_ARN: str
-    AWS_REGION: str = "us-west-2"
-
-    # Daily.co room URL pattern
-    DAILY_ROOM_URL_PATTERN: str = "https://{subdomain}.daily.co/{room_name}"
-    DAILY_SUBDOMAIN: str = "reflector"  # Your Daily.co subdomain
-```
-
-## Technical Differences
-
-### Phase 1 Implementation
-1. **Frontend**: Replace `<whereby-embed>` custom element with Daily.co React components or iframe
-2. **Backend**: Create Daily.co API client matching Whereby's functionality
-3. **Webhooks**: Map Daily.co events to existing database operations
-4. **Recording**: Maintain same MP4 format and S3 storage
-
-### Phase 2 Capabilities (Future)
-1. **Raw-tracks recording**: Individual audio streams per participant
-2. **Presence API**: Real-time participant data without webhook delays
-3. **Transcription API**: Built-in transcription services
-4. **Advanced recording options**: Multiple formats and layouts
-
-## Risks and Mitigation
-
-### Risk 1: API Differences
- **Mitigation**: Create abstraction layer to minimize changes
- Comprehensive testing of all endpoints
-
-### Risk 2: Recording Format Changes
- **Mitigation**: Build adapter for raw-tracks processing
- Maintain backward compatibility during transition
-
-### Risk 3: User Experience Changes
- **Mitigation**: A/B testing with gradual rollout
- Feature parity checklist before full migration
-
-## Recommendation
-
-Migration to Daily.co is technically feasible and can be implemented in phases:
-
-### Phase 1: Feature Parity
- Replace Whereby with Daily.co maintaining exact same functionality
- Use standard cloud recording (MP4 to S3)
- No changes to processing pipeline
-
-### Phase 2: Enhanced Capabilities (Future)
- Enable raw-tracks recording for improved diarization
- Implement participant-level audio processing
- Add real-time features using Presence API
-
-## Next Steps
-
-1. Set up Daily.co account and obtain API credentials
-2. Implement feature flag system for gradual migration
-3. Create Daily.co API client matching Whereby functionality
-4. Update frontend to support both platforms
-5. Test thoroughly before rollout
-
---
-
-*Analysis based on current codebase review and API documentation comparison.*
--- a/compose.yml
+++ b/compose.yml
@@ -39,11 +39,12 @@ services:
    image: node:18
    ports:
      - "3000:3000"
-    command: sh -c "yarn install && yarn dev"
+    command: sh -c "corepack enable && pnpm install && pnpm dev"
    restart: unless-stopped
    working_dir: /app
    volumes:
      - ./www:/app/
+      - /app/node_modules
    env_file:
      - ./www/.env.local

--- a/server/.gitignore
+++ b/server/.gitignore
@@ -176,7 +176,8 @@ artefacts/
 audio_*.wav

 # ignore local database
-reflector.sqlite3
+*.sqlite3
+*.db
 data/

 dump.rdb
--- a/server/Dockerfile
+++ b/server/Dockerfile
@@ -1,7 +1,8 @@
 FROM python:3.12-slim

 ENV PYTHONUNBUFFERED=1 \
-    UV_LINK_MODE=copy
+    UV_LINK_MODE=copy \
+    UV_NO_CACHE=1

 # builder install base dependencies
 WORKDIR /tmp
@@ -13,8 +14,8 @@ ENV PATH="/root/.local/bin/:$PATH"
 # install application dependencies
 RUN mkdir -p /app
 WORKDIR /app
-COPY pyproject.toml uv.lock /app/
-RUN touch README.md && env uv sync --compile-bytecode --locked
+COPY pyproject.toml uv.lock README.md /app/
+RUN uv sync --compile-bytecode --locked

 # pre-download nltk packages
 RUN uv run python -c "import nltk; nltk.download('punkt_tab'); nltk.download('averaged_perceptron_tagger_eng')"
@@ -26,4 +27,15 @@ COPY migrations /app/migrations
 COPY reflector /app/reflector
 WORKDIR /app

+# Create symlink for libgomp if it doesn't exist (for ARM64 compatibility)
+RUN if [ "$(uname -m)" = "aarch64" ] && [ ! -f /usr/lib/libgomp.so.1 ]; then \
+    LIBGOMP_PATH=$(find /app/.venv/lib -path "*/torch.libs/libgomp*.so.*" 2>/dev/null | head -n1); \
+    if [ -n "$LIBGOMP_PATH" ]; then \
+    ln -sf "$LIBGOMP_PATH" /usr/lib/libgomp.so.1; \
+    fi \
+    fi
+
+# Pre-check just to make sure the image will not fail
+RUN uv run python -c "import silero_vad.model"
+
 CMD ["./runserver.sh"]
--- a/server/README.md
+++ b/server/README.md
@@ -40,3 +40,5 @@ uv run python -c "from reflector.pipelines.main_live_pipeline import task_pipeli
 ```bash
 uv run python -c "from reflector.pipelines.main_live_pipeline import pipeline_post; pipeline_post(transcript_id='TRANSCRIPT_ID')"
 ```
+
+.
--- a/server/env.example
+++ b/server/env.example
@@ -24,7 +24,6 @@ AUTH_JWT_AUDIENCE=
 ## Using serverless modal.com (require reflector-gpu-modal deployed)
 #TRANSCRIPT_BACKEND=modal
 #TRANSCRIPT_URL=https://xxxxx--reflector-transcriber-web.modal.run
-#TRANSLATE_URL=https://xxxxx--reflector-translator-web.modal.run
 #TRANSCRIPT_MODAL_API_KEY=xxxxx

 TRANSCRIPT_BACKEND=modal
@@ -32,11 +31,13 @@ TRANSCRIPT_URL=https://monadical-sas--reflector-transcriber-web.modal.run
 TRANSCRIPT_MODAL_API_KEY=

 ## =======================================================
-## Transcription backend
+## Translation backend
 ##
 ## Only available in modal atm
 ## =======================================================
+TRANSLATION_BACKEND=modal
 TRANSLATE_URL=https://monadical-sas--reflector-translator-web.modal.run
+#TRANSLATION_MODAL_API_KEY=xxxxx

 ## =======================================================
 ## LLM backend
@@ -59,7 +60,9 @@ LLM_API_KEY=sk-
 ## To allow diarization, you need to expose expose the files to be dowloded by the pipeline
 ## =======================================================
 DIARIZATION_ENABLED=false
+DIARIZATION_BACKEND=modal
 DIARIZATION_URL=https://monadical-sas--reflector-diarizer-web.modal.run
+#DIARIZATION_MODAL_API_KEY=xxxxx


 ## =======================================================
--- a/server/gpu/modal_deployments/README.md
+++ b/server/gpu/modal_deployments/README.md
@@ -4,7 +4,8 @@ This repository hold an API for the GPU implementation of the Reflector API serv
 and use [Modal.com](https://modal.com)

 - `reflector_diarizer.py` - Diarization API
- `reflector_transcriber.py` - Transcription API
+- `reflector_transcriber.py` - Transcription API (Whisper)
+- `reflector_transcriber_parakeet.py` - Transcription API (NVIDIA Parakeet)
 - `reflector_translator.py` - Translation API

 ## Modal.com deployment
@@ -19,21 +20,29 @@ $ modal deploy reflector_transcriber.py
 ...
 └── 🔨 Created web => https://xxxx--reflector-transcriber-web.modal.run

+$ modal deploy reflector_transcriber_parakeet.py
+...
+└── 🔨 Created web => https://xxxx--reflector-transcriber-parakeet-web.modal.run
+
 $ modal deploy reflector_llm.py
 ...
 └── 🔨 Created web => https://xxxx--reflector-llm-web.modal.run
 ```

-Then in your reflector api configuration `.env`, you can set theses keys:
+Then in your reflector api configuration `.env`, you can set these keys:

 ```
 TRANSCRIPT_BACKEND=modal
 TRANSCRIPT_URL=https://xxxx--reflector-transcriber-web.modal.run
 TRANSCRIPT_MODAL_API_KEY=REFLECTOR_APIKEY

-LLM_BACKEND=modal
-LLM_URL=https://xxxx--reflector-llm-web.modal.run
-LLM_MODAL_API_KEY=REFLECTOR_APIKEY
+DIARIZATION_BACKEND=modal
+DIARIZATION_URL=https://xxxx--reflector-diarizer-web.modal.run
+DIARIZATION_MODAL_API_KEY=REFLECTOR_APIKEY
+
+TRANSLATION_BACKEND=modal
+TRANSLATION_URL=https://xxxx--reflector-translator-web.modal.run
+TRANSLATION_MODAL_API_KEY=REFLECTOR_APIKEY
 ```

 ## API
@@ -64,6 +73,86 @@ Authorization: bearer <REFLECTOR_APIKEY>

 ### Transcription

+#### Parakeet Transcriber (`reflector_transcriber_parakeet.py`)
+
+NVIDIA Parakeet is a state-of-the-art ASR model optimized for real-time transcription with superior word-level timestamps.
+
+**GPU Configuration:**
+- **A10G GPU** - Used for `/v1/audio/transcriptions` endpoint (small files, live transcription)
+  - Higher concurrency (max_inputs=10)
+  - Optimized for multiple small audio files
+  - Supports batch processing for efficiency
+
+- **L40S GPU** - Used for `/v1/audio/transcriptions-from-url` endpoint (large files)
+  - Lower concurrency but more powerful processing
+  - Optimized for single large audio files
+  - VAD-based chunking for long-form audio
+
+##### `/v1/audio/transcriptions` - Small file transcription
+
+**request** (multipart/form-data)
+- `file` or `files[]` - audio file(s) to transcribe
+- `model` - model name (default: `nvidia/parakeet-tdt-0.6b-v2`)
+- `language` - language code (default: `en`)
+- `batch` - whether to use batch processing for multiple files (default: `true`)
+
+**response**
+```json
+{
+    "text": "transcribed text",
+    "words": [
+        {"word": "hello", "start": 0.0, "end": 0.5},
+        {"word": "world", "start": 0.5, "end": 1.0}
+    ],
+    "filename": "audio.mp3"
+}
+```
+
+For multiple files with batch=true:
+```json
+{
+    "results": [
+        {
+            "filename": "audio1.mp3",
+            "text": "transcribed text",
+            "words": [...]
+        },
+        {
+            "filename": "audio2.mp3",
+            "text": "transcribed text",
+            "words": [...]
+        }
+    ]
+}
+```
+
+##### `/v1/audio/transcriptions-from-url` - Large file transcription
+
+**request** (application/json)
+```json
+{
+    "audio_file_url": "https://example.com/audio.mp3",
+    "model": "nvidia/parakeet-tdt-0.6b-v2",
+    "language": "en",
+    "timestamp_offset": 0.0
+}
+```
+
+**response**
+```json
+{
+    "text": "transcribed text from large file",
+    "words": [
+        {"word": "hello", "start": 0.0, "end": 0.5},
+        {"word": "world", "start": 0.5, "end": 1.0}
+    ]
+}
+```
+
+**Supported file types:** mp3, mp4, mpeg, mpga, m4a, wav, webm
+
+#### Whisper Transcriber (`reflector_transcriber.py`)
+
 `POST /transcribe`

 **request** (multipart/form-data)
--- a/server/gpu/modal_deployments/reflector_diarizer.py
+++ b/server/gpu/modal_deployments/reflector_diarizer.py
@@ -4,14 +4,80 @@ Reflector GPU backend - diarizer
 """

 import os
+import uuid
+from typing import Mapping, NewType
+from urllib.parse import urlparse

-import modal.gpu
-from modal import App, Image, Secret, asgi_app, enter, method
-from pydantic import BaseModel
+import modal

 PYANNOTE_MODEL_NAME: str = "pyannote/speaker-diarization-3.1"
 MODEL_DIR = "/root/diarization_models"
-app = App(name="reflector-diarizer")
+UPLOADS_PATH = "/uploads"
+SUPPORTED_FILE_EXTENSIONS = ["mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm"]
+
+DiarizerUniqFilename = NewType("DiarizerUniqFilename", str)
+AudioFileExtension = NewType("AudioFileExtension", str)
+
+app = modal.App(name="reflector-diarizer")
+
+# Volume for temporary file uploads
+upload_volume = modal.Volume.from_name("diarizer-uploads", create_if_missing=True)
+
+
+def detect_audio_format(url: str, headers: Mapping[str, str]) -> AudioFileExtension:
+    parsed_url = urlparse(url)
+    url_path = parsed_url.path
+
+    for ext in SUPPORTED_FILE_EXTENSIONS:
+        if url_path.lower().endswith(f".{ext}"):
+            return AudioFileExtension(ext)
+
+    content_type = headers.get("content-type", "").lower()
+    if "audio/mpeg" in content_type or "audio/mp3" in content_type:
+        return AudioFileExtension("mp3")
+    if "audio/wav" in content_type:
+        return AudioFileExtension("wav")
+    if "audio/mp4" in content_type:
+        return AudioFileExtension("mp4")
+
+    raise ValueError(
+        f"Unsupported audio format for URL: {url}. "
+        f"Supported extensions: {', '.join(SUPPORTED_FILE_EXTENSIONS)}"
+    )
+
+
+def download_audio_to_volume(
+    audio_file_url: str,
+) -> tuple[DiarizerUniqFilename, AudioFileExtension]:
+    import requests
+    from fastapi import HTTPException
+
+    print(f"Checking audio file at: {audio_file_url}")
+    response = requests.head(audio_file_url, allow_redirects=True)
+    if response.status_code == 404:
+        raise HTTPException(status_code=404, detail="Audio file not found")
+
+    print(f"Downloading audio file from: {audio_file_url}")
+    response = requests.get(audio_file_url, allow_redirects=True)
+
+    if response.status_code != 200:
+        print(f"Download failed with status {response.status_code}: {response.text}")
+        raise HTTPException(
+            status_code=response.status_code,
+            detail=f"Failed to download audio file: {response.status_code}",
+        )
+
+    audio_suffix = detect_audio_format(audio_file_url, response.headers)
+    unique_filename = DiarizerUniqFilename(f"{uuid.uuid4()}.{audio_suffix}")
+    file_path = f"{UPLOADS_PATH}/{unique_filename}"
+
+    print(f"Writing file to: {file_path} (size: {len(response.content)} bytes)")
+    with open(file_path, "wb") as f:
+        f.write(response.content)
+
+    upload_volume.commit()
+    print(f"File saved as: {unique_filename}")
+    return unique_filename, audio_suffix


 def migrate_cache_llm():
@@ -39,7 +105,7 @@ def download_pyannote_audio():


 diarizer_image = (
-    Image.debian_slim(python_version="3.10.8")
+    modal.Image.debian_slim(python_version="3.10.8")
    .pip_install(
        "pyannote.audio==3.1.0",
        "requests",
@@ -55,7 +121,8 @@ diarizer_image = (
        "hf-transfer",
    )
    .run_function(
-        download_pyannote_audio, secrets=[Secret.from_name("my-huggingface-secret")]
+        download_pyannote_audio,
+        secrets=[modal.Secret.from_name("hf_token")],
    )
    .run_function(migrate_cache_llm)
    .env(
@@ -70,53 +137,60 @@ diarizer_image = (


@app.cls(
-    gpu=modal.gpu.A100(size="40GB"),
+    gpu="A100",
    timeout=60 * 30,
-    scaledown_window=60,
-    allow_concurrent_inputs=1,
    image=diarizer_image,
+    volumes={UPLOADS_PATH: upload_volume},
+    enable_memory_snapshot=True,
+    experimental_options={"enable_gpu_snapshot": True},
+    secrets=[
+        modal.Secret.from_name("hf_token"),
+    ],
 )
+@modal.concurrent(max_inputs=1)
 class Diarizer:
-    @enter()
+    @modal.enter(snap=True)
    def enter(self):
        import torch
        from pyannote.audio import Pipeline

        self.use_gpu = torch.cuda.is_available()
        self.device = "cuda" if self.use_gpu else "cpu"
+        print(f"Using device: {self.device}")
        self.diarization_pipeline = Pipeline.from_pretrained(
-            PYANNOTE_MODEL_NAME, cache_dir=MODEL_DIR
+            PYANNOTE_MODEL_NAME,
+            cache_dir=MODEL_DIR,
+            use_auth_token=os.environ["HF_TOKEN"],
        )
        self.diarization_pipeline.to(torch.device(self.device))

-    @method()
-    def diarize(self, audio_data: str, audio_suffix: str, timestamp: float):
-        import tempfile
-
+    @modal.method()
+    def diarize(self, filename: str, timestamp: float = 0.0):
        import torchaudio

-        with tempfile.NamedTemporaryFile("wb+", suffix=f".{audio_suffix}") as fp:
-            fp.write(audio_data)
+        upload_volume.reload()

-            print("Diarizing audio")
-            waveform, sample_rate = torchaudio.load(fp.name)
-            diarization = self.diarization_pipeline(
-                {"waveform": waveform, "sample_rate": sample_rate}
+        file_path = f"{UPLOADS_PATH}/{filename}"
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        print(f"Diarizing audio from: {file_path}")
+        waveform, sample_rate = torchaudio.load(file_path)
+        diarization = self.diarization_pipeline(
+            {"waveform": waveform, "sample_rate": sample_rate}
+        )
+
+        words = []
+        for diarization_segment, _, speaker in diarization.itertracks(yield_label=True):
+            words.append(
+                {
+                    "start": round(timestamp + diarization_segment.start, 3),
+                    "end": round(timestamp + diarization_segment.end, 3),
+                    "speaker": int(speaker[-2:]),
+                }
            )
-
-            words = []
-            for diarization_segment, _, speaker in diarization.itertracks(
-                yield_label=True
-            ):
-                words.append(
-                    {
-                        "start": round(timestamp + diarization_segment.start, 3),
-                        "end": round(timestamp + diarization_segment.end, 3),
-                        "speaker": int(speaker[-2:]),
-                    }
-                )
-            print("Diarization complete")
-            return {"diarization": words}
+        print("Diarization complete")
+        return {"diarization": words}


 # -------------------------------------------------------------------
@@ -127,17 +201,18 @@ class Diarizer:
@app.function(
    timeout=60 * 10,
    scaledown_window=60 * 3,
-    allow_concurrent_inputs=40,
    secrets=[
-        Secret.from_name("reflector-gpu"),
+        modal.Secret.from_name("reflector-gpu"),
    ],
+    volumes={UPLOADS_PATH: upload_volume},
    image=diarizer_image,
 )
-@asgi_app()
+@modal.concurrent(max_inputs=40)
+@modal.asgi_app()
 def web():
-    import requests
    from fastapi import Depends, FastAPI, HTTPException, status
    from fastapi.security import OAuth2PasswordBearer
+    from pydantic import BaseModel

    diarizerstub = Diarizer()

@@ -153,35 +228,26 @@ def web():
                headers={"WWW-Authenticate": "Bearer"},
            )

-    def validate_audio_file(audio_file_url: str):
-        # Check if the audio file exists
-        response = requests.head(audio_file_url, allow_redirects=True)
-        if response.status_code == 404:
-            raise HTTPException(
-                status_code=response.status_code,
-                detail="The audio file does not exist.",
-            )
-
    class DiarizationResponse(BaseModel):
        result: dict

-    @app.post(
-        "/diarize", dependencies=[Depends(apikey_auth), Depends(validate_audio_file)]
-    )
-    def diarize(
-        audio_file_url: str, timestamp: float = 0.0
-    ) -> HTTPException | DiarizationResponse:
-        # Currently the uploaded files are in mp3 format
-        audio_suffix = "mp3"
+    @app.post("/diarize", dependencies=[Depends(apikey_auth)])
+    def diarize(audio_file_url: str, timestamp: float = 0.0) -> DiarizationResponse:
+        unique_filename, audio_suffix = download_audio_to_volume(audio_file_url)

-        print("Downloading audio file")
-        response = requests.get(audio_file_url, allow_redirects=True)
-        print("Audio file downloaded successfully")
-
-        func = diarizerstub.diarize.spawn(
-            audio_data=response.content, audio_suffix=audio_suffix, timestamp=timestamp
-        )
-        result = func.get()
-        return result
+        try:
+            func = diarizerstub.diarize.spawn(
+                filename=unique_filename, timestamp=timestamp
+            )
+            result = func.get()
+            return result
+        finally:
+            try:
+                file_path = f"{UPLOADS_PATH}/{unique_filename}"
+                print(f"Deleting file: {file_path}")
+                os.remove(file_path)
+                upload_volume.commit()
+            except Exception as e:
+                print(f"Error cleaning up {unique_filename}: {e}")

    return app
--- a/server/gpu/modal_deployments/reflector_transcriber_parakeet.py
+++ b/server/gpu/modal_deployments/reflector_transcriber_parakeet.py
@@ -0,0 +1,622 @@
+import logging
+import os
+import sys
+import threading
+import uuid
+from typing import Mapping, NewType
+from urllib.parse import urlparse
+
+import modal
+
+MODEL_NAME = "nvidia/parakeet-tdt-0.6b-v2"
+SUPPORTED_FILE_EXTENSIONS = ["mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm"]
+SAMPLERATE = 16000
+UPLOADS_PATH = "/uploads"
+CACHE_PATH = "/cache"
+VAD_CONFIG = {
+    "max_segment_duration": 30.0,
+    "batch_max_files": 10,
+    "batch_max_duration": 5.0,
+    "min_segment_duration": 0.02,
+    "silence_padding": 0.5,
+    "window_size": 512,
+}
+
+ParakeetUniqFilename = NewType("ParakeetUniqFilename", str)
+AudioFileExtension = NewType("AudioFileExtension", str)
+
+app = modal.App("reflector-transcriber-parakeet")
+
+# Volume for caching model weights
+model_cache = modal.Volume.from_name("parakeet-model-cache", create_if_missing=True)
+# Volume for temporary file uploads
+upload_volume = modal.Volume.from_name("parakeet-uploads", create_if_missing=True)
+
+image = (
+    modal.Image.from_registry(
+        "nvidia/cuda:12.8.0-cudnn-devel-ubuntu22.04", add_python="3.12"
+    )
+    .env(
+        {
+            "HF_HUB_ENABLE_HF_TRANSFER": "1",
+            "HF_HOME": "/cache",
+            "DEBIAN_FRONTEND": "noninteractive",
+            "CXX": "g++",
+            "CC": "g++",
+        }
+    )
+    .apt_install("ffmpeg")
+    .pip_install(
+        "hf_transfer==0.1.9",
+        "huggingface_hub[hf-xet]==0.31.2",
+        "nemo_toolkit[asr]==2.3.0",
+        "cuda-python==12.8.0",
+        "fastapi==0.115.12",
+        "numpy<2",
+        "librosa==0.10.1",
+        "requests",
+        "silero-vad==5.1.0",
+        "torch",
+    )
+    .entrypoint([])  # silence chatty logs by container on start
+)
+
+
+def detect_audio_format(url: str, headers: Mapping[str, str]) -> AudioFileExtension:
+    parsed_url = urlparse(url)
+    url_path = parsed_url.path
+
+    for ext in SUPPORTED_FILE_EXTENSIONS:
+        if url_path.lower().endswith(f".{ext}"):
+            return AudioFileExtension(ext)
+
+    content_type = headers.get("content-type", "").lower()
+    if "audio/mpeg" in content_type or "audio/mp3" in content_type:
+        return AudioFileExtension("mp3")
+    if "audio/wav" in content_type:
+        return AudioFileExtension("wav")
+    if "audio/mp4" in content_type:
+        return AudioFileExtension("mp4")
+
+    raise ValueError(
+        f"Unsupported audio format for URL: {url}. "
+        f"Supported extensions: {', '.join(SUPPORTED_FILE_EXTENSIONS)}"
+    )
+
+
+def download_audio_to_volume(
+    audio_file_url: str,
+) -> tuple[ParakeetUniqFilename, AudioFileExtension]:
+    import requests
+    from fastapi import HTTPException
+
+    response = requests.head(audio_file_url, allow_redirects=True)
+    if response.status_code == 404:
+        raise HTTPException(status_code=404, detail="Audio file not found")
+
+    response = requests.get(audio_file_url, allow_redirects=True)
+    response.raise_for_status()
+
+    audio_suffix = detect_audio_format(audio_file_url, response.headers)
+    unique_filename = ParakeetUniqFilename(f"{uuid.uuid4()}.{audio_suffix}")
+    file_path = f"{UPLOADS_PATH}/{unique_filename}"
+
+    with open(file_path, "wb") as f:
+        f.write(response.content)
+
+    upload_volume.commit()
+    return unique_filename, audio_suffix
+
+
+def pad_audio(audio_array, sample_rate: int = SAMPLERATE):
+    """Add 0.5 seconds of silence if audio is less than 500ms.
+
+    This is a workaround for a Parakeet bug where very short audio (<500ms) causes:
+    ValueError: `char_offsets`: [] and `processed_tokens`: [157, 834, 834, 841]
+    have to be of the same length
+
+    See: https://github.com/NVIDIA/NeMo/issues/8451
+    """
+    import numpy as np
+
+    audio_duration = len(audio_array) / sample_rate
+    if audio_duration < 0.5:
+        silence_samples = int(sample_rate * 0.5)
+        silence = np.zeros(silence_samples, dtype=np.float32)
+        return np.concatenate([audio_array, silence])
+    return audio_array
+
+
+@app.cls(
+    gpu="A10G",
+    timeout=600,
+    scaledown_window=300,
+    image=image,
+    volumes={CACHE_PATH: model_cache, UPLOADS_PATH: upload_volume},
+    enable_memory_snapshot=True,
+    experimental_options={"enable_gpu_snapshot": True},
+)
+@modal.concurrent(max_inputs=10)
+class TranscriberParakeetLive:
+    @modal.enter(snap=True)
+    def enter(self):
+        import nemo.collections.asr as nemo_asr
+
+        logging.getLogger("nemo_logger").setLevel(logging.CRITICAL)
+
+        self.lock = threading.Lock()
+        self.model = nemo_asr.models.ASRModel.from_pretrained(model_name=MODEL_NAME)
+        device = next(self.model.parameters()).device
+        print(f"Model is on device: {device}")
+
+    @modal.method()
+    def transcribe_segment(
+        self,
+        filename: str,
+    ):
+        import librosa
+
+        upload_volume.reload()
+
+        file_path = f"{UPLOADS_PATH}/{filename}"
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        audio_array, sample_rate = librosa.load(file_path, sr=SAMPLERATE, mono=True)
+        padded_audio = pad_audio(audio_array, sample_rate)
+
+        with self.lock:
+            with NoStdStreams():
+                (output,) = self.model.transcribe([padded_audio], timestamps=True)
+
+        text = output.text.strip()
+        words = [
+            {
+                "word": word_info["word"],
+                "start": round(word_info["start"], 2),
+                "end": round(word_info["end"], 2),
+            }
+            for word_info in output.timestamp["word"]
+        ]
+
+        return {"text": text, "words": words}
+
+    @modal.method()
+    def transcribe_batch(
+        self,
+        filenames: list[str],
+    ):
+        import librosa
+
+        upload_volume.reload()
+
+        results = []
+        audio_arrays = []
+
+        # Load all audio files with padding
+        for filename in filenames:
+            file_path = f"{UPLOADS_PATH}/{filename}"
+            if not os.path.exists(file_path):
+                raise FileNotFoundError(f"Batch file not found: {file_path}")
+
+            audio_array, sample_rate = librosa.load(file_path, sr=SAMPLERATE, mono=True)
+            padded_audio = pad_audio(audio_array, sample_rate)
+            audio_arrays.append(padded_audio)
+
+        with self.lock:
+            with NoStdStreams():
+                outputs = self.model.transcribe(audio_arrays, timestamps=True)
+
+        # Process results for each file
+        for i, (filename, output) in enumerate(zip(filenames, outputs)):
+            text = output.text.strip()
+
+            words = [
+                {
+                    "word": word_info["word"],
+                    "start": round(word_info["start"], 2),
+                    "end": round(word_info["end"], 2),
+                }
+                for word_info in output.timestamp["word"]
+            ]
+
+            results.append(
+                {
+                    "filename": filename,
+                    "text": text,
+                    "words": words,
+                }
+            )
+
+        return results
+
+
+# L40S class for file transcription (bigger files)
+@app.cls(
+    gpu="L40S",
+    timeout=900,
+    image=image,
+    volumes={CACHE_PATH: model_cache, UPLOADS_PATH: upload_volume},
+    enable_memory_snapshot=True,
+    experimental_options={"enable_gpu_snapshot": True},
+)
+class TranscriberParakeetFile:
+    @modal.enter(snap=True)
+    def enter(self):
+        import nemo.collections.asr as nemo_asr
+        import torch
+        from silero_vad import load_silero_vad
+
+        logging.getLogger("nemo_logger").setLevel(logging.CRITICAL)
+
+        self.model = nemo_asr.models.ASRModel.from_pretrained(model_name=MODEL_NAME)
+        device = next(self.model.parameters()).device
+        print(f"Model is on device: {device}")
+
+        torch.set_num_threads(1)
+        self.vad_model = load_silero_vad(onnx=False)
+        print("Silero VAD initialized")
+
+    @modal.method()
+    def transcribe_segment(
+        self,
+        filename: str,
+        timestamp_offset: float = 0.0,
+    ):
+        import librosa
+        import numpy as np
+        from silero_vad import VADIterator
+
+        def load_and_convert_audio(file_path):
+            audio_array, sample_rate = librosa.load(file_path, sr=SAMPLERATE, mono=True)
+            return audio_array
+
+        def vad_segment_generator(audio_array):
+            """Generate speech segments using VAD with start/end sample indices"""
+            vad_iterator = VADIterator(self.vad_model, sampling_rate=SAMPLERATE)
+            window_size = VAD_CONFIG["window_size"]
+            start = None
+
+            for i in range(0, len(audio_array), window_size):
+                chunk = audio_array[i : i + window_size]
+                if len(chunk) < window_size:
+                    chunk = np.pad(
+                        chunk, (0, window_size - len(chunk)), mode="constant"
+                    )
+
+                speech_dict = vad_iterator(chunk)
+                if not speech_dict:
+                    continue
+
+                if "start" in speech_dict:
+                    start = speech_dict["start"]
+                    continue
+
+                if "end" in speech_dict and start is not None:
+                    end = speech_dict["end"]
+                    start_time = start / float(SAMPLERATE)
+                    end_time = end / float(SAMPLERATE)
+
+                    # Extract the actual audio segment
+                    audio_segment = audio_array[start:end]
+
+                    yield (start_time, end_time, audio_segment)
+                    start = None
+
+            vad_iterator.reset_states()
+
+        def vad_segment_filter(segments):
+            """Filter VAD segments by duration and chunk large segments"""
+            min_dur = VAD_CONFIG["min_segment_duration"]
+            max_dur = VAD_CONFIG["max_segment_duration"]
+
+            for start_time, end_time, audio_segment in segments:
+                segment_duration = end_time - start_time
+
+                # Skip very small segments
+                if segment_duration < min_dur:
+                    continue
+
+                # If segment is within max duration, yield as-is
+                if segment_duration <= max_dur:
+                    yield (start_time, end_time, audio_segment)
+                    continue
+
+                # Chunk large segments into smaller pieces
+                chunk_samples = int(max_dur * SAMPLERATE)
+                current_start = start_time
+
+                for chunk_offset in range(0, len(audio_segment), chunk_samples):
+                    chunk_audio = audio_segment[
+                        chunk_offset : chunk_offset + chunk_samples
+                    ]
+                    if len(chunk_audio) == 0:
+                        break
+
+                    chunk_duration = len(chunk_audio) / float(SAMPLERATE)
+                    chunk_end = current_start + chunk_duration
+
+                    # Only yield chunks that meet minimum duration
+                    if chunk_duration >= min_dur:
+                        yield (current_start, chunk_end, chunk_audio)
+
+                    current_start = chunk_end
+
+        def batch_segments(segments, max_files=10, max_duration=5.0):
+            batch = []
+            batch_duration = 0.0
+
+            for start_time, end_time, audio_segment in segments:
+                segment_duration = end_time - start_time
+
+                if segment_duration < VAD_CONFIG["silence_padding"]:
+                    silence_samples = int(
+                        (VAD_CONFIG["silence_padding"] - segment_duration) * SAMPLERATE
+                    )
+                    padding = np.zeros(silence_samples, dtype=np.float32)
+                    audio_segment = np.concatenate([audio_segment, padding])
+                    segment_duration = VAD_CONFIG["silence_padding"]
+
+                batch.append((start_time, end_time, audio_segment))
+                batch_duration += segment_duration
+
+                if len(batch) >= max_files or batch_duration >= max_duration:
+                    yield batch
+                    batch = []
+                    batch_duration = 0.0
+
+            if batch:
+                yield batch
+
+        def transcribe_batch(model, audio_segments):
+            with NoStdStreams():
+                outputs = model.transcribe(audio_segments, timestamps=True)
+            return outputs
+
+        def emit_results(
+            results,
+            segments_info,
+            batch_index,
+            total_batches,
+        ):
+            """Yield transcribed text and word timings from model output, adjusting timestamps to absolute positions."""
+            for i, (output, (start_time, end_time, _)) in enumerate(
+                zip(results, segments_info)
+            ):
+                text = output.text.strip()
+                words = [
+                    {
+                        "word": word_info["word"],
+                        "start": round(
+                            word_info["start"] + start_time + timestamp_offset, 2
+                        ),
+                        "end": round(
+                            word_info["end"] + start_time + timestamp_offset, 2
+                        ),
+                    }
+                    for word_info in output.timestamp["word"]
+                ]
+
+                yield text, words
+
+        upload_volume.reload()
+
+        file_path = f"{UPLOADS_PATH}/{filename}"
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        audio_array = load_and_convert_audio(file_path)
+        total_duration = len(audio_array) / float(SAMPLERATE)
+        processed_duration = 0.0
+
+        all_text_parts = []
+        all_words = []
+
+        raw_segments = vad_segment_generator(audio_array)
+        filtered_segments = vad_segment_filter(raw_segments)
+        batches = batch_segments(
+            filtered_segments,
+            VAD_CONFIG["batch_max_files"],
+            VAD_CONFIG["batch_max_duration"],
+        )
+
+        batch_index = 0
+        total_batches = max(
+            1, int(total_duration / VAD_CONFIG["batch_max_duration"]) + 1
+        )
+
+        for batch in batches:
+            batch_index += 1
+            audio_segments = [seg[2] for seg in batch]
+            results = transcribe_batch(self.model, audio_segments)
+
+            for text, words in emit_results(
+                results,
+                batch,
+                batch_index,
+                total_batches,
+            ):
+                if not text:
+                    continue
+                all_text_parts.append(text)
+                all_words.extend(words)
+
+            processed_duration += sum(len(seg[2]) / float(SAMPLERATE) for seg in batch)
+
+        combined_text = " ".join(all_text_parts)
+        return {"text": combined_text, "words": all_words}
+
+
+@app.function(
+    scaledown_window=60,
+    timeout=600,
+    secrets=[
+        modal.Secret.from_name("reflector-gpu"),
+    ],
+    volumes={CACHE_PATH: model_cache, UPLOADS_PATH: upload_volume},
+    image=image,
+)
+@modal.concurrent(max_inputs=40)
+@modal.asgi_app()
+def web():
+    import os
+    import uuid
+
+    from fastapi import (
+        Body,
+        Depends,
+        FastAPI,
+        Form,
+        HTTPException,
+        UploadFile,
+        status,
+    )
+    from fastapi.security import OAuth2PasswordBearer
+    from pydantic import BaseModel
+
+    transcriber_live = TranscriberParakeetLive()
+    transcriber_file = TranscriberParakeetFile()
+
+    app = FastAPI()
+
+    oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+    def apikey_auth(apikey: str = Depends(oauth2_scheme)):
+        if apikey == os.environ["REFLECTOR_GPU_APIKEY"]:
+            return
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid API key",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    class TranscriptResponse(BaseModel):
+        result: dict
+
+    @app.post("/v1/audio/transcriptions", dependencies=[Depends(apikey_auth)])
+    def transcribe(
+        file: UploadFile = None,
+        files: list[UploadFile] | None = None,
+        model: str = Form(MODEL_NAME),
+        language: str = Form("en"),
+        batch: bool = Form(False),
+    ):
+        # Parakeet only supports English
+        if language != "en":
+            raise HTTPException(
+                status_code=400,
+                detail=f"Parakeet model only supports English. Got language='{language}'",
+            )
+        # Handle both single file and multiple files
+        if not file and not files:
+            raise HTTPException(
+                status_code=400, detail="Either 'file' or 'files' parameter is required"
+            )
+        if batch and not files:
+            raise HTTPException(
+                status_code=400, detail="Batch transcription requires 'files'"
+            )
+
+        upload_files = [file] if file else files
+
+        # Upload files to volume
+        uploaded_filenames = []
+        for upload_file in upload_files:
+            audio_suffix = upload_file.filename.split(".")[-1]
+            assert audio_suffix in SUPPORTED_FILE_EXTENSIONS
+
+            # Generate unique filename
+            unique_filename = f"{uuid.uuid4()}.{audio_suffix}"
+            file_path = f"{UPLOADS_PATH}/{unique_filename}"
+
+            print(f"Writing file to: {file_path}")
+            with open(file_path, "wb") as f:
+                content = upload_file.file.read()
+                f.write(content)
+
+            uploaded_filenames.append(unique_filename)
+
+        upload_volume.commit()
+
+        try:
+            # Use A10G live transcriber for per-file transcription
+            if batch and len(upload_files) > 1:
+                # Use batch transcription
+                func = transcriber_live.transcribe_batch.spawn(
+                    filenames=uploaded_filenames,
+                )
+                results = func.get()
+                return {"results": results}
+
+            # Per-file transcription
+            results = []
+            for filename in uploaded_filenames:
+                func = transcriber_live.transcribe_segment.spawn(
+                    filename=filename,
+                )
+                result = func.get()
+                result["filename"] = filename
+                results.append(result)
+
+            return {"results": results} if len(results) > 1 else results[0]
+
+        finally:
+            for filename in uploaded_filenames:
+                try:
+                    file_path = f"{UPLOADS_PATH}/{filename}"
+                    print(f"Deleting file: {file_path}")
+                    os.remove(file_path)
+                except Exception as e:
+                    print(f"Error deleting {filename}: {e}")
+
+            upload_volume.commit()
+
+    @app.post("/v1/audio/transcriptions-from-url", dependencies=[Depends(apikey_auth)])
+    def transcribe_from_url(
+        audio_file_url: str = Body(
+            ..., description="URL of the audio file to transcribe"
+        ),
+        model: str = Body(MODEL_NAME),
+        language: str = Body("en", description="Language code (only 'en' supported)"),
+        timestamp_offset: float = Body(0.0),
+    ):
+        # Parakeet only supports English
+        if language != "en":
+            raise HTTPException(
+                status_code=400,
+                detail=f"Parakeet model only supports English. Got language='{language}'",
+            )
+        unique_filename, audio_suffix = download_audio_to_volume(audio_file_url)
+
+        try:
+            func = transcriber_file.transcribe_segment.spawn(
+                filename=unique_filename,
+                timestamp_offset=timestamp_offset,
+            )
+            result = func.get()
+            return result
+        finally:
+            try:
+                file_path = f"{UPLOADS_PATH}/{unique_filename}"
+                print(f"Deleting file: {file_path}")
+                os.remove(file_path)
+                upload_volume.commit()
+            except Exception as e:
+                print(f"Error cleaning up {unique_filename}: {e}")
+
+    return app
+
+
+class NoStdStreams:
+    def __init__(self):
+        self.devnull = open(os.devnull, "w")
+
+    def __enter__(self):
+        self._stdout, self._stderr = sys.stdout, sys.stderr
+        self._stdout.flush()
+        self._stderr.flush()
+        sys.stdout, sys.stderr = self.devnull, self.devnull
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        sys.stdout, sys.stderr = self._stdout, self._stderr
+        self.devnull.close()
--- a/server/migrations/README
+++ b/server/migrations/README
@@ -1 +1,3 @@
-Generic single-database configuration.
+Generic single-database configuration.
+
+Both data migrations and schema migrations must be in migrations.
--- a/server/migrations/versions/0ab2d7ffaa16_add_long_summary_to_search_vector.py
+++ b/server/migrations/versions/0ab2d7ffaa16_add_long_summary_to_search_vector.py
@@ -0,0 +1,64 @@
+"""add_long_summary_to_search_vector
+
+Revision ID: 0ab2d7ffaa16
+Revises: b1c33bd09963
+Create Date: 2025-08-15 13:27:52.680211
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "0ab2d7ffaa16"
+down_revision: Union[str, None] = "b1c33bd09963"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # Drop the existing search vector column and index
+    op.drop_index("idx_transcript_search_vector_en", table_name="transcript")
+    op.drop_column("transcript", "search_vector_en")
+
+    # Recreate the search vector column with long_summary included
+    op.execute("""
+        ALTER TABLE transcript ADD COLUMN search_vector_en tsvector
+        GENERATED ALWAYS AS (
+            setweight(to_tsvector('english', coalesce(title, '')), 'A') ||
+            setweight(to_tsvector('english', coalesce(long_summary, '')), 'B') ||
+            setweight(to_tsvector('english', coalesce(webvtt, '')), 'C')
+        ) STORED
+    """)
+
+    # Recreate the GIN index for the search vector
+    op.create_index(
+        "idx_transcript_search_vector_en",
+        "transcript",
+        ["search_vector_en"],
+        postgresql_using="gin",
+    )
+
+
+def downgrade() -> None:
+    # Drop the updated search vector column and index
+    op.drop_index("idx_transcript_search_vector_en", table_name="transcript")
+    op.drop_column("transcript", "search_vector_en")
+
+    # Recreate the original search vector column without long_summary
+    op.execute("""
+        ALTER TABLE transcript ADD COLUMN search_vector_en tsvector
+        GENERATED ALWAYS AS (
+            setweight(to_tsvector('english', coalesce(title, '')), 'A') ||
+            setweight(to_tsvector('english', coalesce(webvtt, '')), 'B')
+        ) STORED
+    """)
+
+    # Recreate the GIN index for the search vector
+    op.create_index(
+        "idx_transcript_search_vector_en",
+        "transcript",
+        ["search_vector_en"],
+        postgresql_using="gin",
+    )
--- a/server/migrations/versions/0bc0f3ff0111_add_webvtt_field_to_transcript.py
+++ b/server/migrations/versions/0bc0f3ff0111_add_webvtt_field_to_transcript.py
@@ -0,0 +1,25 @@
+"""add_webvtt_field_to_transcript
+
+Revision ID: 0bc0f3ff0111
+Revises: b7df9609542c
+Create Date: 2025-08-05 19:36:41.740957
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "0bc0f3ff0111"
+down_revision: Union[str, None] = "b7df9609542c"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.add_column("transcript", sa.Column("webvtt", sa.Text(), nullable=True))
+
+
+def downgrade() -> None:
+    op.drop_column("transcript", "webvtt")
--- a/server/migrations/versions/116b2f287eab_add_full_text_search.py
+++ b/server/migrations/versions/116b2f287eab_add_full_text_search.py
@@ -0,0 +1,46 @@
+"""add_full_text_search
+
+Revision ID: 116b2f287eab
+Revises: 0bc0f3ff0111
+Create Date: 2025-08-07 11:27:38.473517
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+
+revision: str = "116b2f287eab"
+down_revision: Union[str, None] = "0bc0f3ff0111"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+    if conn.dialect.name != "postgresql":
+        return
+
+    op.execute("""
+        ALTER TABLE transcript ADD COLUMN search_vector_en tsvector
+        GENERATED ALWAYS AS (
+            setweight(to_tsvector('english', coalesce(title, '')), 'A') ||
+            setweight(to_tsvector('english', coalesce(webvtt, '')), 'B')
+        ) STORED
+    """)
+
+    op.create_index(
+        "idx_transcript_search_vector_en",
+        "transcript",
+        ["search_vector_en"],
+        postgresql_using="gin",
+    )
+
+
+def downgrade() -> None:
+    conn = op.get_bind()
+    if conn.dialect.name != "postgresql":
+        return
+
+    op.drop_index("idx_transcript_search_vector_en", table_name="transcript")
+    op.drop_column("transcript", "search_vector_en")
--- a/server/migrations/versions/62dea3db63a5_add_room_options.py
+++ b/server/migrations/versions/62dea3db63a5_add_room_options.py
@@ -32,7 +32,7 @@ def upgrade() -> None:
        sa.Column("user_id", sa.String(), nullable=True),
        sa.Column("room_id", sa.String(), nullable=True),
        sa.Column(
-            "is_locked", sa.Boolean(), server_default=sa.text("0"), nullable=False
+            "is_locked", sa.Boolean(), server_default=sa.text("false"), nullable=False
        ),
        sa.Column("room_mode", sa.String(), server_default="normal", nullable=False),
        sa.Column(
@@ -53,12 +53,15 @@ def upgrade() -> None:
        sa.Column("user_id", sa.String(), nullable=False),
        sa.Column("created_at", sa.DateTime(), nullable=False),
        sa.Column(
-            "zulip_auto_post", sa.Boolean(), server_default=sa.text("0"), nullable=False
+            "zulip_auto_post",
+            sa.Boolean(),
+            server_default=sa.text("false"),
+            nullable=False,
        ),
        sa.Column("zulip_stream", sa.String(), nullable=True),
        sa.Column("zulip_topic", sa.String(), nullable=True),
        sa.Column(
-            "is_locked", sa.Boolean(), server_default=sa.text("0"), nullable=False
+            "is_locked", sa.Boolean(), server_default=sa.text("false"), nullable=False
        ),
        sa.Column("room_mode", sa.String(), server_default="normal", nullable=False),
        sa.Column(
--- a/server/migrations/versions/74b2b0236931_add_transcript_source_kind.py
+++ b/server/migrations/versions/74b2b0236931_add_transcript_source_kind.py
@@ -20,11 +20,14 @@ depends_on: Union[str, Sequence[str], None] = None

 def upgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
+    sourcekind_enum = sa.Enum("room", "live", "file", name="sourcekind")
+    sourcekind_enum.create(op.get_bind())
+
    op.add_column(
        "transcript",
        sa.Column(
            "source_kind",
-            sa.Enum("ROOM", "LIVE", "FILE", name="sourcekind"),
+            sourcekind_enum,
            nullable=True,
        ),
    )
@@ -43,6 +46,8 @@ def upgrade() -> None:
 def downgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
    op.drop_column("transcript", "source_kind")
+    sourcekind_enum = sa.Enum(name="sourcekind")
+    sourcekind_enum.drop(op.get_bind())


 # ### end Alembic commands ###
--- a/server/migrations/versions/7e47155afd51_dailyco_platform.py
+++ b/server/migrations/versions/7e47155afd51_dailyco_platform.py
@@ -1,54 +0,0 @@
-"""dailyco platform
-
-Revision ID: 7e47155afd51
-Revises: b7df9609542c
-Create Date: 2025-08-04 11:14:19.663115
-
-"""
-
-from typing import Sequence, Union
-
-import sqlalchemy as sa
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "7e47155afd51"
-down_revision: Union[str, None] = "b7df9609542c"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table("meeting", schema=None) as batch_op:
-        batch_op.add_column(
-            sa.Column("platform", sa.String(), server_default="whereby", nullable=False)
-        )
-        batch_op.drop_index(
-            batch_op.f("idx_one_active_meeting_per_room"),
-            sqlite_where=sa.text("is_active = 1"),
-        )
-
-    with op.batch_alter_table("room", schema=None) as batch_op:
-        batch_op.add_column(
-            sa.Column("platform", sa.String(), server_default="whereby", nullable=False)
-        )
-
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table("room", schema=None) as batch_op:
-        batch_op.drop_column("platform")
-
-    with op.batch_alter_table("meeting", schema=None) as batch_op:
-        batch_op.create_index(
-            batch_op.f("idx_one_active_meeting_per_room"),
-            ["room_id"],
-            unique=1,
-            sqlite_where=sa.text("is_active = 1"),
-        )
-        batch_op.drop_column("platform")
-
-    # ### end Alembic commands ###
--- a/server/migrations/versions/8120ebc75366_populate_webvtt_from_topics.py
+++ b/server/migrations/versions/8120ebc75366_populate_webvtt_from_topics.py
@@ -0,0 +1,106 @@
+"""populate_webvtt_from_topics
+
+Revision ID: 8120ebc75366
+Revises: 116b2f287eab
+Create Date: 2025-08-11 19:11:01.316947
+
+"""
+
+import json
+from typing import Sequence, Union
+
+from alembic import op
+from sqlalchemy import text
+
+# revision identifiers, used by Alembic.
+revision: str = "8120ebc75366"
+down_revision: Union[str, None] = "116b2f287eab"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def topics_to_webvtt(topics):
+    """Convert topics list to WebVTT format string."""
+    if not topics:
+        return None
+
+    lines = ["WEBVTT", ""]
+
+    for topic in topics:
+        start_time = format_timestamp(topic.get("start"))
+        end_time = format_timestamp(topic.get("end"))
+        text = topic.get("text", "").strip()
+
+        if start_time and end_time and text:
+            lines.append(f"{start_time} --> {end_time}")
+            lines.append(text)
+            lines.append("")
+
+    return "\n".join(lines).strip()
+
+
+def format_timestamp(seconds):
+    """Format seconds to WebVTT timestamp format (HH:MM:SS.mmm)."""
+    if seconds is None:
+        return None
+
+    hours = int(seconds // 3600)
+    minutes = int((seconds % 3600) // 60)
+    secs = seconds % 60
+
+    return f"{hours:02d}:{minutes:02d}:{secs:06.3f}"
+
+
+def upgrade() -> None:
+    """Populate WebVTT field for all transcripts with topics."""
+
+    # Get connection
+    connection = op.get_bind()
+
+    # Query all transcripts with topics
+    result = connection.execute(
+        text("SELECT id, topics FROM transcript WHERE topics IS NOT NULL")
+    )
+
+    rows = result.fetchall()
+    print(f"Found {len(rows)} transcripts with topics")
+
+    updated_count = 0
+    error_count = 0
+
+    for row in rows:
+        transcript_id = row[0]
+        topics_data = row[1]
+
+        if not topics_data:
+            continue
+
+        try:
+            # Parse JSON if it's a string
+            if isinstance(topics_data, str):
+                topics_data = json.loads(topics_data)
+
+            # Convert topics to WebVTT format
+            webvtt_content = topics_to_webvtt(topics_data)
+
+            if webvtt_content:
+                # Update the webvtt field
+                connection.execute(
+                    text("UPDATE transcript SET webvtt = :webvtt WHERE id = :id"),
+                    {"webvtt": webvtt_content, "id": transcript_id},
+                )
+                updated_count += 1
+                print(f"✓ Updated transcript {transcript_id}")
+
+        except Exception as e:
+            error_count += 1
+            print(f"✗ Error updating transcript {transcript_id}: {e}")
+
+    print(f"\nMigration complete!")
+    print(f"  Updated: {updated_count}")
+    print(f"  Errors: {error_count}")
+
+
+def downgrade() -> None:
+    """Clear WebVTT field for all transcripts."""
+    op.execute(text("UPDATE transcript SET webvtt = NULL"))
--- a/server/migrations/versions/99365b0cd87b_add_title_short_and_long_summary_and_.py
+++ b/server/migrations/versions/99365b0cd87b_add_title_short_and_long_summary_and_.py
@@ -22,7 +22,7 @@ def upgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
    op.execute(
        "UPDATE transcript SET events = "
-        'REPLACE(events, \'"event": "SUMMARY"\', \'"event": "LONG_SUMMARY"\');'
+        'REPLACE(events::text, \'"event": "SUMMARY"\', \'"event": "LONG_SUMMARY"\')::json;'
    )
    op.alter_column("transcript", "summary", new_column_name="long_summary")
    op.add_column("transcript", sa.Column("title", sa.String(), nullable=True))
@@ -34,7 +34,7 @@ def downgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
    op.execute(
        "UPDATE transcript SET events = "
-        'REPLACE(events, \'"event": "LONG_SUMMARY"\', \'"event": "SUMMARY"\');'
+        'REPLACE(events::text, \'"event": "LONG_SUMMARY"\', \'"event": "SUMMARY"\')::json;'
    )
    with op.batch_alter_table("transcript", schema=None) as batch_op:
        batch_op.alter_column("long_summary", nullable=True, new_column_name="summary")
--- a/server/migrations/versions/9f5c78d352d6_datetime_timezone.py
+++ b/server/migrations/versions/9f5c78d352d6_datetime_timezone.py
@@ -0,0 +1,121 @@
+"""datetime timezone
+
+Revision ID: 9f5c78d352d6
+Revises: 8120ebc75366
+Create Date: 2025-08-13 19:18:27.113593
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = "9f5c78d352d6"
+down_revision: Union[str, None] = "8120ebc75366"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("meeting", schema=None) as batch_op:
+        batch_op.alter_column(
+            "start_date",
+            existing_type=postgresql.TIMESTAMP(),
+            type_=sa.DateTime(timezone=True),
+            existing_nullable=True,
+        )
+        batch_op.alter_column(
+            "end_date",
+            existing_type=postgresql.TIMESTAMP(),
+            type_=sa.DateTime(timezone=True),
+            existing_nullable=True,
+        )
+
+    with op.batch_alter_table("meeting_consent", schema=None) as batch_op:
+        batch_op.alter_column(
+            "consent_timestamp",
+            existing_type=postgresql.TIMESTAMP(),
+            type_=sa.DateTime(timezone=True),
+            existing_nullable=False,
+        )
+
+    with op.batch_alter_table("recording", schema=None) as batch_op:
+        batch_op.alter_column(
+            "recorded_at",
+            existing_type=postgresql.TIMESTAMP(),
+            type_=sa.DateTime(timezone=True),
+            existing_nullable=False,
+        )
+
+    with op.batch_alter_table("room", schema=None) as batch_op:
+        batch_op.alter_column(
+            "created_at",
+            existing_type=postgresql.TIMESTAMP(),
+            type_=sa.DateTime(timezone=True),
+            existing_nullable=False,
+        )
+
+    with op.batch_alter_table("transcript", schema=None) as batch_op:
+        batch_op.alter_column(
+            "created_at",
+            existing_type=postgresql.TIMESTAMP(),
+            type_=sa.DateTime(timezone=True),
+            existing_nullable=True,
+        )
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("transcript", schema=None) as batch_op:
+        batch_op.alter_column(
+            "created_at",
+            existing_type=sa.DateTime(timezone=True),
+            type_=postgresql.TIMESTAMP(),
+            existing_nullable=True,
+        )
+
+    with op.batch_alter_table("room", schema=None) as batch_op:
+        batch_op.alter_column(
+            "created_at",
+            existing_type=sa.DateTime(timezone=True),
+            type_=postgresql.TIMESTAMP(),
+            existing_nullable=False,
+        )
+
+    with op.batch_alter_table("recording", schema=None) as batch_op:
+        batch_op.alter_column(
+            "recorded_at",
+            existing_type=sa.DateTime(timezone=True),
+            type_=postgresql.TIMESTAMP(),
+            existing_nullable=False,
+        )
+
+    with op.batch_alter_table("meeting_consent", schema=None) as batch_op:
+        batch_op.alter_column(
+            "consent_timestamp",
+            existing_type=sa.DateTime(timezone=True),
+            type_=postgresql.TIMESTAMP(),
+            existing_nullable=False,
+        )
+
+    with op.batch_alter_table("meeting", schema=None) as batch_op:
+        batch_op.alter_column(
+            "end_date",
+            existing_type=sa.DateTime(timezone=True),
+            type_=postgresql.TIMESTAMP(),
+            existing_nullable=True,
+        )
+        batch_op.alter_column(
+            "start_date",
+            existing_type=sa.DateTime(timezone=True),
+            type_=postgresql.TIMESTAMP(),
+            existing_nullable=True,
+        )
+
+    # ### end Alembic commands ###
--- a/server/migrations/versions/a7122bc0b2ca_add_shared_rooms.py
+++ b/server/migrations/versions/a7122bc0b2ca_add_shared_rooms.py
@@ -25,7 +25,7 @@ def upgrade() -> None:
        sa.Column(
            "is_shared",
            sa.Boolean(),
-            server_default=sa.text("0"),
+            server_default=sa.text("false"),
            nullable=False,
        ),
    )
--- a/server/migrations/versions/b0e5f7876032_add_meeting_is_active.py
+++ b/server/migrations/versions/b0e5f7876032_add_meeting_is_active.py
@@ -23,7 +23,10 @@ def upgrade() -> None:
    with op.batch_alter_table("meeting", schema=None) as batch_op:
        batch_op.add_column(
            sa.Column(
-                "is_active", sa.Boolean(), server_default=sa.text("1"), nullable=False
+                "is_active",
+                sa.Boolean(),
+                server_default=sa.text("true"),
+                nullable=False,
            )
        )

--- a/server/migrations/versions/b1c33bd09963_add_search_optimization_indexes.py
+++ b/server/migrations/versions/b1c33bd09963_add_search_optimization_indexes.py
@@ -0,0 +1,41 @@
+"""add_search_optimization_indexes
+
+Revision ID: b1c33bd09963
+Revises: 9f5c78d352d6
+Create Date: 2025-08-14 17:26:02.117408
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "b1c33bd09963"
+down_revision: Union[str, None] = "9f5c78d352d6"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # Add indexes for actual search filtering patterns used in frontend
+    # Based on /browse page filters: room_id and source_kind
+
+    # Index for room_id + created_at (for room-specific searches with date ordering)
+    op.create_index(
+        "idx_transcript_room_id_created_at",
+        "transcript",
+        ["room_id", "created_at"],
+        if_not_exists=True,
+    )
+
+    # Index for source_kind alone (actively used filter in frontend)
+    op.create_index(
+        "idx_transcript_source_kind", "transcript", ["source_kind"], if_not_exists=True
+    )
+
+
+def downgrade() -> None:
+    # Remove the indexes in reverse order
+    op.drop_index("idx_transcript_source_kind", "transcript", if_exists=True)
+    op.drop_index("idx_transcript_room_id_created_at", "transcript", if_exists=True)
--- a/server/migrations/versions/b9348748bbbc_reviewed.py
+++ b/server/migrations/versions/b9348748bbbc_reviewed.py
@@ -23,7 +23,7 @@ def upgrade() -> None:
    op.add_column(
        "transcript",
        sa.Column(
-            "reviewed", sa.Boolean(), server_default=sa.text("0"), nullable=False
+            "reviewed", sa.Boolean(), server_default=sa.text("false"), nullable=False
        ),
    )
    # ### end Alembic commands ###
--- a/server/pyproject.toml
+++ b/server/pyproject.toml
@@ -32,14 +32,14 @@ dependencies = [
    "redis>=5.0.1",
    "python-jose[cryptography]>=3.3.0",
    "python-multipart>=0.0.6",
-    "faster-whisper>=0.10.0",
    "transformers>=4.36.2",
-    "black==24.1.1",
    "jsonschema>=4.23.0",
    "openai>=1.59.7",
    "psycopg2-binary>=2.9.10",
    "llama-index>=0.12.52",
    "llama-index-llms-openai-like>=0.4.0",
+    "pytest-env>=1.1.5",
+    "webvtt-py>=0.5.0",
 ]

 [dependency-groups]
@@ -56,6 +56,9 @@ tests = [
    "httpx-ws>=0.4.1",
    "pytest-httpx>=0.23.1",
    "pytest-celery>=0.0.0",
+    "pytest-recording>=0.13.4",
+    "pytest-docker>=3.2.3",
+    "asgi-lifespan>=2.1.0",
 ]
 aws = ["aioboto3>=11.2.0"]
 evaluation = [
@@ -64,6 +67,15 @@ evaluation = [
    "tqdm>=4.66.0",
    "pydantic>=2.1.1",
 ]
+local = [
+    "pyannote-audio>=3.3.2",
+    "faster-whisper>=0.10.0",
+]
+silero-vad = [
+    "silero-vad>=5.1.2",
+    "torch>=2.8.0",
+    "torchaudio>=2.8.0",
+]

 [tool.uv]
 default-groups = [
@@ -71,6 +83,21 @@ default-groups = [
    "tests",
    "aws",
    "evaluation",
+    "local",
+    "silero-vad"
+]
+
+[[tool.uv.index]]
+name = "pytorch-cpu"
+url = "https://download.pytorch.org/whl/cpu"
+explicit = true
+
+[tool.uv.sources]
+torch = [
+  { index = "pytorch-cpu" },
+]
+torchaudio = [
+  { index = "pytorch-cpu" },
 ]

 [build-system]
@@ -83,10 +110,28 @@ packages = ["reflector"]
 [tool.coverage.run]
 source = ["reflector"]

+[tool.pytest_env]
+ENVIRONMENT = "pytest"
+DATABASE_URL = "postgresql://test_user:test_password@localhost:15432/reflector_test"
+
 [tool.pytest.ini_options]
 addopts = "-ra -q --disable-pytest-warnings --cov --cov-report html -v"
 testpaths = ["tests"]
 asyncio_mode = "auto"
+markers = [
+    "gpu_modal: mark test to run only with GPU Modal endpoints (deselect with '-m \"not gpu_modal\"')",
+]
+
+[tool.ruff.lint]
+select = [
+    "I",       # isort - import sorting
+    "F401",    # unused imports
+    "PLC0415", # import-outside-top-level - detect inline imports
+]

 [tool.ruff.lint.per-file-ignores]
 "reflector/processors/summary/summary_builder.py" = ["E501"]
+"gpu/**.py" = ["PLC0415"]
+"reflector/tools/**.py" = ["PLC0415"]
+"migrations/versions/**.py" = ["PLC0415"]
+"tests/**.py" = ["PLC0415"]
--- a/server/reflector/app.py
+++ b/server/reflector/app.py
@@ -12,7 +12,6 @@ from reflector.events import subscribers_shutdown, subscribers_startup
 from reflector.logger import logger
 from reflector.metrics import metrics_init
 from reflector.settings import settings
-from reflector.views.daily import router as daily_router
 from reflector.views.meetings import router as meetings_router
 from reflector.views.rooms import router as rooms_router
 from reflector.views.rtc_offer import router as rtc_offer_router
@@ -87,7 +86,6 @@ app.include_router(transcripts_process_router, prefix="/v1")
 app.include_router(user_router, prefix="/v1")
 app.include_router(zulip_router, prefix="/v1")
 app.include_router(whereby_router, prefix="/v1")
-app.include_router(daily_router, prefix="/v1")
 add_pagination(app)

 # prepare celery
--- a/server/reflector/db/init.py
+++ b/server/reflector/db/init.py
@@ -1,12 +1,28 @@
+import contextvars
+from typing import Optional
+
 import databases
 import sqlalchemy

 from reflector.events import subscribers_shutdown, subscribers_startup
 from reflector.settings import settings

-database = databases.Database(settings.DATABASE_URL)
 metadata = sqlalchemy.MetaData()

+_database_context: contextvars.ContextVar[Optional[databases.Database]] = (
+    contextvars.ContextVar("database", default=None)
+)
+
+
+def get_database() -> databases.Database:
+    """Get database instance for current asyncio context"""
+    db = _database_context.get()
+    if db is None:
+        db = databases.Database(settings.DATABASE_URL)
+        _database_context.set(db)
+    return db
+
+
 # import models
 import reflector.db.meetings  # noqa
 import reflector.db.recordings  # noqa
@@ -14,16 +30,18 @@ import reflector.db.rooms  # noqa
 import reflector.db.transcripts  # noqa

 kwargs = {}
-if "sqlite" in settings.DATABASE_URL:
-    kwargs["connect_args"] = {"check_same_thread": False}
+if "postgres" not in settings.DATABASE_URL:
+    raise Exception("Only postgres database is supported in reflector")
 engine = sqlalchemy.create_engine(settings.DATABASE_URL, **kwargs)


@subscribers_startup.append
 async def database_connect(_):
+    database = get_database()
    await database.connect()


@subscribers_shutdown.append
 async def database_disconnect(_):
+    database = get_database()
    await database.disconnect()
--- a/server/reflector/db/meetings.py
+++ b/server/reflector/db/meetings.py
@@ -5,7 +5,7 @@ import sqlalchemy as sa
 from fastapi import HTTPException
 from pydantic import BaseModel, Field

-from reflector.db import database, metadata
+from reflector.db import get_database, metadata
 from reflector.db.rooms import Room
 from reflector.utils import generate_uuid4

@@ -16,8 +16,8 @@ meetings = sa.Table(
    sa.Column("room_name", sa.String),
    sa.Column("room_url", sa.String),
    sa.Column("host_room_url", sa.String),
-    sa.Column("start_date", sa.DateTime),
-    sa.Column("end_date", sa.DateTime),
+    sa.Column("start_date", sa.DateTime(timezone=True)),
+    sa.Column("end_date", sa.DateTime(timezone=True)),
    sa.Column("user_id", sa.String),
    sa.Column("room_id", sa.String),
    sa.Column("is_locked", sa.Boolean, nullable=False, server_default=sa.false()),
@@ -41,13 +41,13 @@ meetings = sa.Table(
        nullable=False,
        server_default=sa.true(),
    ),
-    sa.Column(
-        "platform",
-        sa.String,
-        nullable=False,
-        server_default="whereby",
-    ),
    sa.Index("idx_meeting_room_id", "room_id"),
+    sa.Index(
+        "idx_one_active_meeting_per_room",
+        "room_id",
+        unique=True,
+        postgresql_where=sa.text("is_active = true"),
+    ),
 )

 meeting_consent = sa.Table(
@@ -57,7 +57,7 @@ meeting_consent = sa.Table(
    sa.Column("meeting_id", sa.String, sa.ForeignKey("meeting.id"), nullable=False),
    sa.Column("user_id", sa.String),
    sa.Column("consent_given", sa.Boolean, nullable=False),
-    sa.Column("consent_timestamp", sa.DateTime, nullable=False),
+    sa.Column("consent_timestamp", sa.DateTime(timezone=True), nullable=False),
 )


@@ -85,7 +85,6 @@ class Meeting(BaseModel):
        "none", "prompt", "automatic", "automatic-2nd-participant"
    ] = "automatic-2nd-participant"
    num_clients: int = 0
-    platform: Literal["whereby", "daily"] = "whereby"


 class MeetingController:
@@ -116,10 +115,9 @@ class MeetingController:
            room_mode=room.room_mode,
            recording_type=room.recording_type,
            recording_trigger=room.recording_trigger,
-            platform=room.platform,
        )
        query = meetings.insert().values(**meeting.model_dump())
-        await database.execute(query)
+        await get_database().execute(query)
        return meeting

    async def get_all_active(self) -> list[Meeting]:
@@ -127,7 +125,7 @@ class MeetingController:
        Get active meetings.
        """
        query = meetings.select().where(meetings.c.is_active)
-        return await database.fetch_all(query)
+        return await get_database().fetch_all(query)

    async def get_by_room_name(
        self,
@@ -137,7 +135,7 @@ class MeetingController:
        Get a meeting by room name.
        """
        query = meetings.select().where(meetings.c.room_name == room_name)
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
        if not result:
            return None

@@ -159,7 +157,7 @@ class MeetingController:
            )
            .order_by(end_date.desc())
        )
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
        if not result:
            return None

@@ -170,7 +168,7 @@ class MeetingController:
        Get a meeting by id
        """
        query = meetings.select().where(meetings.c.id == meeting_id)
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
        if not result:
            return None
        return Meeting(**result)
@@ -182,7 +180,7 @@ class MeetingController:
        If not found, it will raise a 404 error.
        """
        query = meetings.select().where(meetings.c.id == meeting_id)
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
        if not result:
            raise HTTPException(status_code=404, detail="Meeting not found")

@@ -194,7 +192,7 @@ class MeetingController:

    async def update_meeting(self, meeting_id: str, **kwargs):
        query = meetings.update().where(meetings.c.id == meeting_id).values(**kwargs)
-        await database.execute(query)
+        await get_database().execute(query)


 class MeetingConsentController:
@@ -202,7 +200,7 @@ class MeetingConsentController:
        query = meeting_consent.select().where(
            meeting_consent.c.meeting_id == meeting_id
        )
-        results = await database.fetch_all(query)
+        results = await get_database().fetch_all(query)
        return [MeetingConsent(**result) for result in results]

    async def get_by_meeting_and_user(
@@ -213,7 +211,7 @@ class MeetingConsentController:
            meeting_consent.c.meeting_id == meeting_id,
            meeting_consent.c.user_id == user_id,
        )
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
        if result is None:
            return None
        return MeetingConsent(**result) if result else None
@@ -235,14 +233,14 @@ class MeetingConsentController:
                        consent_timestamp=consent.consent_timestamp,
                    )
                )
-                await database.execute(query)
+                await get_database().execute(query)

                existing.consent_given = consent.consent_given
                existing.consent_timestamp = consent.consent_timestamp
                return existing

        query = meeting_consent.insert().values(**consent.model_dump())
-        await database.execute(query)
+        await get_database().execute(query)
        return consent

    async def has_any_denial(self, meeting_id: str) -> bool:
@@ -251,7 +249,7 @@ class MeetingConsentController:
            meeting_consent.c.meeting_id == meeting_id,
            meeting_consent.c.consent_given.is_(False),
        )
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
        return result is not None


--- a/server/reflector/db/recordings.py
+++ b/server/reflector/db/recordings.py
@@ -4,7 +4,7 @@ from typing import Literal
 import sqlalchemy as sa
 from pydantic import BaseModel, Field

-from reflector.db import database, metadata
+from reflector.db import get_database, metadata
 from reflector.utils import generate_uuid4

 recordings = sa.Table(
@@ -13,7 +13,7 @@ recordings = sa.Table(
    sa.Column("id", sa.String, primary_key=True),
    sa.Column("bucket_name", sa.String, nullable=False),
    sa.Column("object_key", sa.String, nullable=False),
-    sa.Column("recorded_at", sa.DateTime, nullable=False),
+    sa.Column("recorded_at", sa.DateTime(timezone=True), nullable=False),
    sa.Column(
        "status",
        sa.String,
@@ -37,12 +37,12 @@ class Recording(BaseModel):
 class RecordingController:
    async def create(self, recording: Recording):
        query = recordings.insert().values(**recording.model_dump())
-        await database.execute(query)
+        await get_database().execute(query)
        return recording

    async def get_by_id(self, id: str) -> Recording:
        query = recordings.select().where(recordings.c.id == id)
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
        return Recording(**result) if result else None

    async def get_by_object_key(self, bucket_name: str, object_key: str) -> Recording:
@@ -50,8 +50,12 @@ class RecordingController:
            recordings.c.bucket_name == bucket_name,
            recordings.c.object_key == object_key,
        )
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
        return Recording(**result) if result else None

+    async def remove_by_id(self, id: str) -> None:
+        query = recordings.delete().where(recordings.c.id == id)
+        await get_database().execute(query)
+

 recordings_controller = RecordingController()
--- a/server/reflector/db/rooms.py
+++ b/server/reflector/db/rooms.py
@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timezone
 from sqlite3 import IntegrityError
 from typing import Literal

@@ -7,7 +7,7 @@ from fastapi import HTTPException
 from pydantic import BaseModel, Field
 from sqlalchemy.sql import false, or_

-from reflector.db import database, metadata
+from reflector.db import get_database, metadata
 from reflector.utils import generate_uuid4

 rooms = sqlalchemy.Table(
@@ -16,7 +16,7 @@ rooms = sqlalchemy.Table(
    sqlalchemy.Column("id", sqlalchemy.String, primary_key=True),
    sqlalchemy.Column("name", sqlalchemy.String, nullable=False, unique=True),
    sqlalchemy.Column("user_id", sqlalchemy.String, nullable=False),
-    sqlalchemy.Column("created_at", sqlalchemy.DateTime, nullable=False),
+    sqlalchemy.Column("created_at", sqlalchemy.DateTime(timezone=True), nullable=False),
    sqlalchemy.Column(
        "zulip_auto_post", sqlalchemy.Boolean, nullable=False, server_default=false()
    ),
@@ -40,9 +40,6 @@ rooms = sqlalchemy.Table(
    sqlalchemy.Column(
        "is_shared", sqlalchemy.Boolean, nullable=False, server_default=false()
    ),
-    sqlalchemy.Column(
-        "platform", sqlalchemy.String, nullable=False, server_default="whereby"
-    ),
    sqlalchemy.Index("idx_room_is_shared", "is_shared"),
 )

@@ -51,7 +48,7 @@ class Room(BaseModel):
    id: str = Field(default_factory=generate_uuid4)
    name: str
    user_id: str
-    created_at: datetime = Field(default_factory=datetime.utcnow)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
    zulip_auto_post: bool = False
    zulip_stream: str = ""
    zulip_topic: str = ""
@@ -62,7 +59,6 @@ class Room(BaseModel):
        "none", "prompt", "automatic", "automatic-2nd-participant"
    ] = "automatic-2nd-participant"
    is_shared: bool = False
-    platform: Literal["whereby", "daily"] = "whereby"


 class RoomController:
@@ -96,7 +92,7 @@ class RoomController:
        if return_query:
            return query

-        results = await database.fetch_all(query)
+        results = await get_database().fetch_all(query)
        return results

    async def add(
@@ -111,7 +107,6 @@ class RoomController:
        recording_type: str,
        recording_trigger: str,
        is_shared: bool,
-        platform: str = "whereby",
    ):
        """
        Add a new room
@@ -127,11 +122,10 @@ class RoomController:
            recording_type=recording_type,
            recording_trigger=recording_trigger,
            is_shared=is_shared,
-            platform=platform,
        )
        query = rooms.insert().values(**room.model_dump())
        try:
-            await database.execute(query)
+            await get_database().execute(query)
        except IntegrityError:
            raise HTTPException(status_code=400, detail="Room name is not unique")
        return room
@@ -142,7 +136,7 @@ class RoomController:
        """
        query = rooms.update().where(rooms.c.id == room.id).values(**values)
        try:
-            await database.execute(query)
+            await get_database().execute(query)
        except IntegrityError:
            raise HTTPException(status_code=400, detail="Room name is not unique")

@@ -157,7 +151,7 @@ class RoomController:
        query = rooms.select().where(rooms.c.id == room_id)
        if "user_id" in kwargs:
            query = query.where(rooms.c.user_id == kwargs["user_id"])
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
        if not result:
            return None
        return Room(**result)
@@ -169,7 +163,7 @@ class RoomController:
        query = rooms.select().where(rooms.c.name == room_name)
        if "user_id" in kwargs:
            query = query.where(rooms.c.user_id == kwargs["user_id"])
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
        if not result:
            return None
        return Room(**result)
@@ -181,7 +175,7 @@ class RoomController:
        If not found, it will raise a 404 error.
        """
        query = rooms.select().where(rooms.c.id == meeting_id)
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
        if not result:
            raise HTTPException(status_code=404, detail="Room not found")

@@ -203,7 +197,7 @@ class RoomController:
        if user_id is not None and room.user_id != user_id:
            return
        query = rooms.delete().where(rooms.c.id == room_id)
-        await database.execute(query)
+        await get_database().execute(query)


 rooms_controller = RoomController()
--- a/server/reflector/db/search.py
+++ b/server/reflector/db/search.py
@@ -0,0 +1,448 @@
+"""Search functionality for transcripts and other entities."""
+
+import itertools
+from dataclasses import dataclass
+from datetime import datetime
+from io import StringIO
+from typing import Annotated, Any, Dict, Iterator
+
+import sqlalchemy
+import webvtt
+from fastapi import HTTPException
+from pydantic import (
+    BaseModel,
+    Field,
+    NonNegativeFloat,
+    NonNegativeInt,
+    ValidationError,
+    constr,
+    field_serializer,
+)
+
+from reflector.db import get_database
+from reflector.db.rooms import rooms
+from reflector.db.transcripts import SourceKind, transcripts
+from reflector.db.utils import is_postgresql
+from reflector.logger import logger
+
+DEFAULT_SEARCH_LIMIT = 20
+SNIPPET_CONTEXT_LENGTH = 50  # Characters before/after match to include
+DEFAULT_SNIPPET_MAX_LENGTH = NonNegativeInt(150)
+DEFAULT_MAX_SNIPPETS = NonNegativeInt(3)
+LONG_SUMMARY_MAX_SNIPPETS = 2
+
+SearchQueryBase = constr(min_length=0, strip_whitespace=True)
+SearchLimitBase = Annotated[int, Field(ge=1, le=100)]
+SearchOffsetBase = Annotated[int, Field(ge=0)]
+SearchTotalBase = Annotated[int, Field(ge=0)]
+
+SearchQuery = Annotated[SearchQueryBase, Field(description="Search query text")]
+SearchLimit = Annotated[SearchLimitBase, Field(description="Results per page")]
+SearchOffset = Annotated[
+    SearchOffsetBase, Field(description="Number of results to skip")
+]
+SearchTotal = Annotated[
+    SearchTotalBase, Field(description="Total number of search results")
+]
+
+WEBVTT_SPEC_HEADER = "WEBVTT"
+
+WebVTTContent = Annotated[
+    str,
+    Field(min_length=len(WEBVTT_SPEC_HEADER), description="WebVTT content"),
+]
+
+
+class WebVTTProcessor:
+    """Stateless processor for WebVTT content operations."""
+
+    @staticmethod
+    def parse(raw_content: str) -> WebVTTContent:
+        """Parse WebVTT content and return it as a string."""
+        if not raw_content.startswith(WEBVTT_SPEC_HEADER):
+            raise ValueError(f"Invalid WebVTT content, no header {WEBVTT_SPEC_HEADER}")
+        return raw_content
+
+    @staticmethod
+    def extract_text(webvtt_content: WebVTTContent) -> str:
+        """Extract plain text from WebVTT content using webvtt library."""
+        try:
+            buffer = StringIO(webvtt_content)
+            vtt = webvtt.read_buffer(buffer)
+            return " ".join(caption.text for caption in vtt if caption.text)
+        except webvtt.errors.MalformedFileError as e:
+            logger.warning(f"Malformed WebVTT content: {e}")
+            return ""
+        except (UnicodeDecodeError, ValueError) as e:
+            logger.warning(f"Failed to decode WebVTT content: {e}")
+            return ""
+        except AttributeError as e:
+            logger.error(
+                f"WebVTT parsing error - unexpected format: {e}", exc_info=True
+            )
+            return ""
+        except Exception as e:
+            logger.error(f"Unexpected error parsing WebVTT: {e}", exc_info=True)
+            return ""
+
+    @staticmethod
+    def generate_snippets(
+        webvtt_content: WebVTTContent,
+        query: str,
+        max_snippets: NonNegativeInt = DEFAULT_MAX_SNIPPETS,
+    ) -> list[str]:
+        """Generate snippets from WebVTT content."""
+        return SnippetGenerator.generate(
+            WebVTTProcessor.extract_text(webvtt_content),
+            query,
+            max_snippets=max_snippets,
+        )
+
+
+@dataclass(frozen=True)
+class SnippetCandidate:
+    """Represents a candidate snippet with its position."""
+
+    _text: str
+    start: NonNegativeInt
+    _original_text_length: int
+
+    @property
+    def end(self) -> NonNegativeInt:
+        """Calculate end position from start and raw text length."""
+        return self.start + len(self._text)
+
+    def text(self) -> str:
+        """Get display text with ellipses added if needed."""
+        result = self._text.strip()
+        if self.start > 0:
+            result = "..." + result
+        if self.end < self._original_text_length:
+            result = result + "..."
+        return result
+
+
+class SearchParameters(BaseModel):
+    """Validated search parameters for full-text search."""
+
+    query_text: SearchQuery
+    limit: SearchLimit = DEFAULT_SEARCH_LIMIT
+    offset: SearchOffset = 0
+    user_id: str | None = None
+    room_id: str | None = None
+    source_kind: SourceKind | None = None
+
+
+class SearchResultDB(BaseModel):
+    """Intermediate model for validating raw database results."""
+
+    id: str = Field(..., min_length=1)
+    created_at: datetime
+    status: str = Field(..., min_length=1)
+    duration: float | None = Field(None, ge=0)
+    user_id: str | None = None
+    title: str | None = None
+    source_kind: SourceKind
+    room_id: str | None = None
+    rank: float = Field(..., ge=0, le=1)
+
+
+class SearchResult(BaseModel):
+    """Public search result model with computed fields."""
+
+    id: str = Field(..., min_length=1)
+    title: str | None = None
+    user_id: str | None = None
+    room_id: str | None = None
+    room_name: str | None = None
+    source_kind: SourceKind
+    created_at: datetime
+    status: str = Field(..., min_length=1)
+    rank: float = Field(..., ge=0, le=1)
+    duration: NonNegativeFloat | None = Field(..., description="Duration in seconds")
+    search_snippets: list[str] = Field(
+        description="Text snippets around search matches"
+    )
+    total_match_count: NonNegativeInt = Field(
+        default=0, description="Total number of matches found in the transcript"
+    )
+
+    @field_serializer("created_at", when_used="json")
+    def serialize_datetime(self, dt: datetime) -> str:
+        if dt.tzinfo is None:
+            return dt.isoformat() + "Z"
+        return dt.isoformat()
+
+
+class SnippetGenerator:
+    """Stateless generator for text snippets and match operations."""
+
+    @staticmethod
+    def find_all_matches(text: str, query: str) -> Iterator[int]:
+        """Generate all match positions for a query in text."""
+        if not text:
+            logger.warning("Empty text for search query in find_all_matches")
+            return
+        if not query:
+            logger.warning("Empty query for search text in find_all_matches")
+            return
+
+        text_lower = text.lower()
+        query_lower = query.lower()
+        start = 0
+        prev_start = start
+        while (pos := text_lower.find(query_lower, start)) != -1:
+            yield pos
+            start = pos + len(query_lower)
+            if start <= prev_start:
+                raise ValueError("panic! find_all_matches is not incremental")
+            prev_start = start
+
+    @staticmethod
+    def count_matches(text: str, query: str) -> NonNegativeInt:
+        """Count total number of matches for a query in text."""
+        ZERO = NonNegativeInt(0)
+        if not text:
+            logger.warning("Empty text for search query in count_matches")
+            return ZERO
+        if not query:
+            logger.warning("Empty query for search text in count_matches")
+            return ZERO
+        return NonNegativeInt(
+            sum(1 for _ in SnippetGenerator.find_all_matches(text, query))
+        )
+
+    @staticmethod
+    def create_snippet(
+        text: str, match_pos: int, max_length: int = DEFAULT_SNIPPET_MAX_LENGTH
+    ) -> SnippetCandidate:
+        """Create a snippet from a match position."""
+        snippet_start = NonNegativeInt(max(0, match_pos - SNIPPET_CONTEXT_LENGTH))
+        snippet_end = min(len(text), match_pos + max_length - SNIPPET_CONTEXT_LENGTH)
+
+        snippet_text = text[snippet_start:snippet_end]
+
+        return SnippetCandidate(
+            _text=snippet_text, start=snippet_start, _original_text_length=len(text)
+        )
+
+    @staticmethod
+    def filter_non_overlapping(
+        candidates: Iterator[SnippetCandidate],
+    ) -> Iterator[str]:
+        """Filter out overlapping snippets and return only display text."""
+        last_end = 0
+        for candidate in candidates:
+            display_text = candidate.text()
+            # it means that next overlapping snippets simply don't get included
+            # it's fine as simplistic logic and users probably won't care much because they already have their search results just fin
+            if candidate.start >= last_end and display_text:
+                yield display_text
+                last_end = candidate.end
+
+    @staticmethod
+    def generate(
+        text: str,
+        query: str,
+        max_length: NonNegativeInt = DEFAULT_SNIPPET_MAX_LENGTH,
+        max_snippets: NonNegativeInt = DEFAULT_MAX_SNIPPETS,
+    ) -> list[str]:
+        """Generate snippets from text."""
+        if not text or not query:
+            logger.warning("Empty text or query for generate_snippets")
+            return []
+
+        candidates = (
+            SnippetGenerator.create_snippet(text, pos, max_length)
+            for pos in SnippetGenerator.find_all_matches(text, query)
+        )
+        filtered = SnippetGenerator.filter_non_overlapping(candidates)
+        snippets = list(itertools.islice(filtered, max_snippets))
+
+        # Fallback to first word search if no full matches
+        # it's another assumption: proper snippet logic generation is quite complicated and tied to db logic, so simplification is used here
+        if not snippets and " " in query:
+            first_word = query.split()[0]
+            return SnippetGenerator.generate(text, first_word, max_length, max_snippets)
+
+        return snippets
+
+    @staticmethod
+    def from_summary(
+        summary: str,
+        query: str,
+        max_snippets: NonNegativeInt = LONG_SUMMARY_MAX_SNIPPETS,
+    ) -> list[str]:
+        """Generate snippets from summary text."""
+        return SnippetGenerator.generate(summary, query, max_snippets=max_snippets)
+
+    @staticmethod
+    def combine_sources(
+        summary: str | None,
+        webvtt: WebVTTContent | None,
+        query: str,
+        max_total: NonNegativeInt = DEFAULT_MAX_SNIPPETS,
+    ) -> tuple[list[str], NonNegativeInt]:
+        """Combine snippets from multiple sources and return total match count.
+
+        Returns (snippets, total_match_count) tuple.
+
+        snippets can be empty for real in case of e.g. title match
+        """
+        webvtt_matches = 0
+        summary_matches = 0
+
+        if webvtt:
+            webvtt_text = WebVTTProcessor.extract_text(webvtt)
+            webvtt_matches = SnippetGenerator.count_matches(webvtt_text, query)
+
+        if summary:
+            summary_matches = SnippetGenerator.count_matches(summary, query)
+
+        total_matches = NonNegativeInt(webvtt_matches + summary_matches)
+
+        summary_snippets = (
+            SnippetGenerator.from_summary(summary, query) if summary else []
+        )
+
+        if len(summary_snippets) >= max_total:
+            return summary_snippets[:max_total], total_matches
+
+        remaining = max_total - len(summary_snippets)
+        webvtt_snippets = (
+            WebVTTProcessor.generate_snippets(webvtt, query, remaining)
+            if webvtt
+            else []
+        )
+
+        return summary_snippets + webvtt_snippets, total_matches
+
+
+class SearchController:
+    """Controller for search operations across different entities."""
+
+    @classmethod
+    async def search_transcripts(
+        cls, params: SearchParameters
+    ) -> tuple[list[SearchResult], int]:
+        """
+        Full-text search for transcripts using PostgreSQL tsvector.
+        Returns (results, total_count).
+        """
+
+        if not is_postgresql():
+            logger.warning(
+                "Full-text search requires PostgreSQL. Returning empty results."
+            )
+            return [], 0
+
+        base_columns = [
+            transcripts.c.id,
+            transcripts.c.title,
+            transcripts.c.created_at,
+            transcripts.c.duration,
+            transcripts.c.status,
+            transcripts.c.user_id,
+            transcripts.c.room_id,
+            transcripts.c.source_kind,
+            transcripts.c.webvtt,
+            transcripts.c.long_summary,
+            sqlalchemy.case(
+                (
+                    transcripts.c.room_id.isnot(None) & rooms.c.id.is_(None),
+                    "Deleted Room",
+                ),
+                else_=rooms.c.name,
+            ).label("room_name"),
+        ]
+
+        if params.query_text:
+            search_query = sqlalchemy.func.websearch_to_tsquery(
+                "english", params.query_text
+            )
+            rank_column = sqlalchemy.func.ts_rank(
+                transcripts.c.search_vector_en,
+                search_query,
+                32,  # normalization flag: rank/(rank+1) for 0-1 range
+            ).label("rank")
+        else:
+            rank_column = sqlalchemy.cast(1.0, sqlalchemy.Float).label("rank")
+
+        columns = base_columns + [rank_column]
+        base_query = sqlalchemy.select(columns).select_from(
+            transcripts.join(rooms, transcripts.c.room_id == rooms.c.id, isouter=True)
+        )
+
+        if params.query_text:
+            base_query = base_query.where(
+                transcripts.c.search_vector_en.op("@@")(search_query)
+            )
+
+        if params.user_id:
+            base_query = base_query.where(
+                sqlalchemy.or_(
+                    transcripts.c.user_id == params.user_id, rooms.c.is_shared
+                )
+            )
+        else:
+            base_query = base_query.where(rooms.c.is_shared)
+        if params.room_id:
+            base_query = base_query.where(transcripts.c.room_id == params.room_id)
+        if params.source_kind:
+            base_query = base_query.where(
+                transcripts.c.source_kind == params.source_kind
+            )
+
+        if params.query_text:
+            order_by = sqlalchemy.desc(sqlalchemy.text("rank"))
+        else:
+            order_by = sqlalchemy.desc(transcripts.c.created_at)
+
+        query = base_query.order_by(order_by).limit(params.limit).offset(params.offset)
+
+        rs = await get_database().fetch_all(query)
+
+        count_query = sqlalchemy.select([sqlalchemy.func.count()]).select_from(
+            base_query.alias("search_results")
+        )
+        total = await get_database().fetch_val(count_query)
+
+        def _process_result(r) -> SearchResult:
+            r_dict: Dict[str, Any] = dict(r)
+            webvtt_raw: str | None = r_dict.pop("webvtt", None)
+            if webvtt_raw:
+                webvtt = WebVTTProcessor.parse(webvtt_raw)
+            else:
+                webvtt = None
+            long_summary: str | None = r_dict.pop("long_summary", None)
+            room_name: str | None = r_dict.pop("room_name", None)
+            db_result = SearchResultDB.model_validate(r_dict)
+
+            snippets, total_match_count = SnippetGenerator.combine_sources(
+                long_summary, webvtt, params.query_text, DEFAULT_MAX_SNIPPETS
+            )
+
+            return SearchResult(
+                **db_result.model_dump(),
+                room_name=room_name,
+                search_snippets=snippets,
+                total_match_count=total_match_count,
+            )
+
+        try:
+            results = [_process_result(r) for r in rs]
+        except ValidationError as e:
+            logger.error(f"Invalid search result data: {e}", exc_info=True)
+            raise HTTPException(
+                status_code=500, detail="Internal search result data consistency error"
+            )
+        except Exception as e:
+            logger.error(f"Error processing search results: {e}", exc_info=True)
+            raise
+
+        return results, total
+
+
+search_controller = SearchController()
+webvtt_processor = WebVTTProcessor()
+snippet_generator = SnippetGenerator()
--- a/server/reflector/db/transcripts.py
+++ b/server/reflector/db/transcripts.py
@@ -3,7 +3,7 @@ import json
 import os
 import shutil
 from contextlib import asynccontextmanager
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any, Literal

@@ -11,13 +11,19 @@ import sqlalchemy
 from fastapi import HTTPException
 from pydantic import BaseModel, ConfigDict, Field, field_serializer
 from sqlalchemy import Enum
+from sqlalchemy.dialects.postgresql import TSVECTOR
 from sqlalchemy.sql import false, or_

-from reflector.db import database, metadata
+from reflector.db import get_database, metadata
+from reflector.db.recordings import recordings_controller
+from reflector.db.rooms import rooms
+from reflector.db.utils import is_postgresql
+from reflector.logger import logger
 from reflector.processors.types import Word as ProcessorWord
 from reflector.settings import settings
-from reflector.storage import get_transcripts_storage
+from reflector.storage import get_recordings_storage, get_transcripts_storage
 from reflector.utils import generate_uuid4
+from reflector.utils.webvtt import topics_to_webvtt


 class SourceKind(enum.StrEnum):
@@ -34,7 +40,7 @@ transcripts = sqlalchemy.Table(
    sqlalchemy.Column("status", sqlalchemy.String),
    sqlalchemy.Column("locked", sqlalchemy.Boolean),
    sqlalchemy.Column("duration", sqlalchemy.Float),
-    sqlalchemy.Column("created_at", sqlalchemy.DateTime),
+    sqlalchemy.Column("created_at", sqlalchemy.DateTime(timezone=True)),
    sqlalchemy.Column("title", sqlalchemy.String),
    sqlalchemy.Column("short_summary", sqlalchemy.String),
    sqlalchemy.Column("long_summary", sqlalchemy.String),
@@ -76,13 +82,40 @@ transcripts = sqlalchemy.Table(
    # same field could've been in recording/meeting, and it's maybe even ok to dupe it at need
    sqlalchemy.Column("audio_deleted", sqlalchemy.Boolean),
    sqlalchemy.Column("room_id", sqlalchemy.String),
+    sqlalchemy.Column("webvtt", sqlalchemy.Text),
    sqlalchemy.Index("idx_transcript_recording_id", "recording_id"),
    sqlalchemy.Index("idx_transcript_user_id", "user_id"),
    sqlalchemy.Index("idx_transcript_created_at", "created_at"),
    sqlalchemy.Index("idx_transcript_user_id_recording_id", "user_id", "recording_id"),
    sqlalchemy.Index("idx_transcript_room_id", "room_id"),
+    sqlalchemy.Index("idx_transcript_source_kind", "source_kind"),
+    sqlalchemy.Index("idx_transcript_room_id_created_at", "room_id", "created_at"),
 )

+# Add PostgreSQL-specific full-text search column
+# This matches the migration in migrations/versions/116b2f287eab_add_full_text_search.py
+if is_postgresql():
+    transcripts.append_column(
+        sqlalchemy.Column(
+            "search_vector_en",
+            TSVECTOR,
+            sqlalchemy.Computed(
+                "setweight(to_tsvector('english', coalesce(title, '')), 'A') || "
+                "setweight(to_tsvector('english', coalesce(long_summary, '')), 'B') || "
+                "setweight(to_tsvector('english', coalesce(webvtt, '')), 'C')",
+                persisted=True,
+            ),
+        )
+    )
+    # Add GIN index for the search vector
+    transcripts.append_constraint(
+        sqlalchemy.Index(
+            "idx_transcript_search_vector_en",
+            "search_vector_en",
+            postgresql_using="gin",
+        )
+    )
+

 def generate_transcript_name() -> str:
    now = datetime.now(timezone.utc)
@@ -147,14 +180,18 @@ class TranscriptParticipant(BaseModel):


 class Transcript(BaseModel):
+    """Full transcript model with all fields."""
+
    id: str = Field(default_factory=generate_uuid4)
    user_id: str | None = None
    name: str = Field(default_factory=generate_transcript_name)
    status: str = "idle"
-    locked: bool = False
    duration: float = 0
    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
    title: str | None = None
+    source_kind: SourceKind
+    room_id: str | None = None
+    locked: bool = False
    short_summary: str | None = None
    long_summary: str | None = None
    topics: list[TranscriptTopic] = []
@@ -168,9 +205,8 @@ class Transcript(BaseModel):
    meeting_id: str | None = None
    recording_id: str | None = None
    zulip_message_id: int | None = None
-    source_kind: SourceKind
    audio_deleted: bool | None = None
-    room_id: str | None = None
+    webvtt: str | None = None

    @field_serializer("created_at", when_used="json")
    def serialize_datetime(self, dt: datetime) -> str:
@@ -271,10 +307,12 @@ class Transcript(BaseModel):
        # we need to create an url to be used for diarization
        # we can't use the audio_mp3_filename because it's not accessible
        # from the diarization processor
-        from datetime import timedelta

-        from reflector.app import app
-        from reflector.views.transcripts import create_access_token
+        # TODO don't import app in db
+        from reflector.app import app  # noqa: PLC0415
+
+        # TODO a util + don''t import views in db
+        from reflector.views.transcripts import create_access_token  # noqa: PLC0415

        path = app.url_path_for(
            "transcript_get_audio_mp3",
@@ -335,7 +373,6 @@ class TranscriptController:
        - `room_id`: filter transcripts by room ID
        - `search_term`: filter transcripts by search term
        """
-        from reflector.db.rooms import rooms

        query = transcripts.select().join(
            rooms, transcripts.c.room_id == rooms.c.id, isouter=True
@@ -386,7 +423,7 @@ class TranscriptController:
        if return_query:
            return query

-        results = await database.fetch_all(query)
+        results = await get_database().fetch_all(query)
        return results

    async def get_by_id(self, transcript_id: str, **kwargs) -> Transcript | None:
@@ -396,7 +433,7 @@ class TranscriptController:
        query = transcripts.select().where(transcripts.c.id == transcript_id)
        if "user_id" in kwargs:
            query = query.where(transcripts.c.user_id == kwargs["user_id"])
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
        if not result:
            return None
        return Transcript(**result)
@@ -410,7 +447,7 @@ class TranscriptController:
        query = transcripts.select().where(transcripts.c.recording_id == recording_id)
        if "user_id" in kwargs:
            query = query.where(transcripts.c.user_id == kwargs["user_id"])
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
        if not result:
            return None
        return Transcript(**result)
@@ -428,7 +465,7 @@ class TranscriptController:
            if order_by.startswith("-"):
                field = field.desc()
            query = query.order_by(field)
-        results = await database.fetch_all(query)
+        results = await get_database().fetch_all(query)
        return [Transcript(**result) for result in results]

    async def get_by_id_for_http(
@@ -446,7 +483,7 @@ class TranscriptController:
        to determine if the user can access the transcript.
        """
        query = transcripts.select().where(transcripts.c.id == transcript_id)
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
        if not result:
            raise HTTPException(status_code=404, detail="Transcript not found")

@@ -499,23 +536,52 @@ class TranscriptController:
            room_id=room_id,
        )
        query = transcripts.insert().values(**transcript.model_dump())
-        await database.execute(query)
+        await get_database().execute(query)
        return transcript

-    async def update(self, transcript: Transcript, values: dict, mutate=True):
+    # TODO investigate why mutate= is used. it's used in one place currently, maybe because of ORM field updates.
+    # using mutate=True is discouraged
+    async def update(
+        self, transcript: Transcript, values: dict, mutate=False
+    ) -> Transcript:
        """
-        Update a transcript fields with key/values in values
+        Update a transcript fields with key/values in values.
+        Returns a copy of the transcript with updated values.
        """
+        values = TranscriptController._handle_topics_update(values)
+
        query = (
            transcripts.update()
            .where(transcripts.c.id == transcript.id)
            .values(**values)
        )
-        await database.execute(query)
+        await get_database().execute(query)
        if mutate:
            for key, value in values.items():
                setattr(transcript, key, value)

+        updated_transcript = transcript.model_copy(update=values)
+        return updated_transcript
+
+    @staticmethod
+    def _handle_topics_update(values: dict) -> dict:
+        """Auto-update WebVTT when topics are updated."""
+
+        if values.get("webvtt") is not None:
+            logger.warn("trying to update read-only webvtt column")
+            pass
+
+        topics_data = values.get("topics")
+        if topics_data is None:
+            return values
+
+        return {
+            **values,
+            "webvtt": topics_to_webvtt(
+                [TranscriptTopic(**topic_dict) for topic_dict in topics_data]
+            ),
+        }
+
    async def remove_by_id(
        self,
        transcript_id: str,
@@ -529,23 +595,55 @@ class TranscriptController:
            return
        if user_id is not None and transcript.user_id != user_id:
            return
+        if transcript.audio_location == "storage" and not transcript.audio_deleted:
+            try:
+                await get_transcripts_storage().delete_file(
+                    transcript.storage_audio_path
+                )
+            except Exception as e:
+                logger.warning(
+                    "Failed to delete transcript audio from storage",
+                    exc_info=e,
+                    transcript_id=transcript.id,
+                )
        transcript.unlink()
+        if transcript.recording_id:
+            try:
+                recording = await recordings_controller.get_by_id(
+                    transcript.recording_id
+                )
+                if recording:
+                    try:
+                        await get_recordings_storage().delete_file(recording.object_key)
+                    except Exception as e:
+                        logger.warning(
+                            "Failed to delete recording object from S3",
+                            exc_info=e,
+                            recording_id=transcript.recording_id,
+                        )
+                    await recordings_controller.remove_by_id(transcript.recording_id)
+            except Exception as e:
+                logger.warning(
+                    "Failed to delete recording row",
+                    exc_info=e,
+                    recording_id=transcript.recording_id,
+                )
        query = transcripts.delete().where(transcripts.c.id == transcript_id)
-        await database.execute(query)
+        await get_database().execute(query)

    async def remove_by_recording_id(self, recording_id: str):
        """
        Remove a transcript by recording_id
        """
        query = transcripts.delete().where(transcripts.c.recording_id == recording_id)
-        await database.execute(query)
+        await get_database().execute(query)

    @asynccontextmanager
    async def transaction(self):
        """
        A context manager for database transaction
        """
-        async with database.transaction(isolation="serializable"):
+        async with get_database().transaction(isolation="serializable"):
            yield

    async def append_event(
@@ -558,11 +656,7 @@ class TranscriptController:
        Append an event to a transcript
        """
        resp = transcript.add_event(event=event, data=data)
-        await self.update(
-            transcript,
-            {"events": transcript.events_dump()},
-            mutate=False,
-        )
+        await self.update(transcript, {"events": transcript.events_dump()})
        return resp

    async def upsert_topic(
@@ -574,11 +668,7 @@ class TranscriptController:
        Upsert topics to a transcript
        """
        transcript.upsert_topic(topic)
-        await self.update(
-            transcript,
-            {"topics": transcript.topics_dump()},
-            mutate=False,
-        )
+        await self.update(transcript, {"topics": transcript.topics_dump()})

    async def move_mp3_to_storage(self, transcript: Transcript):
        """
@@ -603,7 +693,8 @@ class TranscriptController:
            )

            # indicate on the transcript that the audio is now on storage
-            await self.update(transcript, {"audio_location": "storage"})
+            # mutates transcript argument
+            await self.update(transcript, {"audio_location": "storage"}, mutate=True)

        # unlink the local file
        transcript.audio_mp3_filename.unlink(missing_ok=True)
@@ -627,11 +718,7 @@ class TranscriptController:
        Add/update a participant to a transcript
        """
        result = transcript.upsert_participant(participant)
-        await self.update(
-            transcript,
-            {"participants": transcript.participants_dump()},
-            mutate=False,
-        )
+        await self.update(transcript, {"participants": transcript.participants_dump()})
        return result

    async def delete_participant(
@@ -643,11 +730,7 @@ class TranscriptController:
        Delete a participant from a transcript
        """
        transcript.delete_participant(participant_id)
-        await self.update(
-            transcript,
-            {"participants": transcript.participants_dump()},
-            mutate=False,
-        )
+        await self.update(transcript, {"participants": transcript.participants_dump()})


 transcripts_controller = TranscriptController()
--- a/server/reflector/db/utils.py
+++ b/server/reflector/db/utils.py
@@ -0,0 +1,9 @@
+"""Database utility functions."""
+
+from reflector.db import get_database
+
+
+def is_postgresql() -> bool:
+    return get_database().url.scheme and get_database().url.scheme.startswith(
+        "postgresql"
+    )
--- a/server/reflector/pipelines/main_file_pipeline.py
+++ b/server/reflector/pipelines/main_file_pipeline.py
@@ -0,0 +1,375 @@
+"""
+File-based processing pipeline
+==============================
+
+Optimized pipeline for processing complete audio/video files.
+Uses parallel processing for transcription, diarization, and waveform generation.
+"""
+
+import asyncio
+from pathlib import Path
+
+import av
+import structlog
+from celery import shared_task
+
+from reflector.db.transcripts import (
+    Transcript,
+    transcripts_controller,
+)
+from reflector.logger import logger
+from reflector.pipelines.main_live_pipeline import PipelineMainBase, asynctask
+from reflector.processors import (
+    AudioFileWriterProcessor,
+    TranscriptFinalSummaryProcessor,
+    TranscriptFinalTitleProcessor,
+    TranscriptTopicDetectorProcessor,
+)
+from reflector.processors.audio_waveform_processor import AudioWaveformProcessor
+from reflector.processors.file_diarization import FileDiarizationInput
+from reflector.processors.file_diarization_auto import FileDiarizationAutoProcessor
+from reflector.processors.file_transcript import FileTranscriptInput
+from reflector.processors.file_transcript_auto import FileTranscriptAutoProcessor
+from reflector.processors.transcript_diarization_assembler import (
+    TranscriptDiarizationAssemblerInput,
+    TranscriptDiarizationAssemblerProcessor,
+)
+from reflector.processors.types import (
+    DiarizationSegment,
+    TitleSummary,
+)
+from reflector.processors.types import (
+    Transcript as TranscriptType,
+)
+from reflector.settings import settings
+from reflector.storage import get_transcripts_storage
+
+
+class EmptyPipeline:
+    """Empty pipeline for processors that need a pipeline reference"""
+
+    def __init__(self, logger: structlog.BoundLogger):
+        self.logger = logger
+
+    def get_pref(self, k, d=None):
+        return d
+
+    async def emit(self, event):
+        pass
+
+
+class PipelineMainFile(PipelineMainBase):
+    """
+    Optimized file processing pipeline.
+    Processes complete audio/video files with parallel execution.
+    """
+
+    logger: structlog.BoundLogger = None
+    empty_pipeline = None
+
+    def __init__(self, transcript_id: str):
+        super().__init__(transcript_id=transcript_id)
+        self.logger = logger.bind(transcript_id=self.transcript_id)
+        self.empty_pipeline = EmptyPipeline(logger=self.logger)
+
+    def _handle_gather_exceptions(self, results: list, operation: str) -> None:
+        """Handle exceptions from asyncio.gather with return_exceptions=True"""
+        for i, result in enumerate(results):
+            if not isinstance(result, Exception):
+                continue
+            self.logger.error(
+                f"Error in {operation} (task {i}): {result}",
+                transcript_id=self.transcript_id,
+                exc_info=result,
+            )
+
+    async def process(self, file_path: Path):
+        """Main entry point for file processing"""
+        self.logger.info(f"Starting file pipeline for {file_path}")
+
+        transcript = await self.get_transcript()
+
+        # Extract audio and write to transcript location
+        audio_path = await self.extract_and_write_audio(file_path, transcript)
+
+        # Upload for processing
+        audio_url = await self.upload_audio(audio_path, transcript)
+
+        # Run parallel processing
+        await self.run_parallel_processing(
+            audio_path,
+            audio_url,
+            transcript.source_language,
+            transcript.target_language,
+        )
+
+        self.logger.info("File pipeline complete")
+
+    async def extract_and_write_audio(
+        self, file_path: Path, transcript: Transcript
+    ) -> Path:
+        """Extract audio from video if needed and write to transcript location as MP3"""
+        self.logger.info(f"Processing audio file: {file_path}")
+
+        # Check if it's already audio-only
+        container = av.open(str(file_path))
+        has_video = len(container.streams.video) > 0
+        container.close()
+
+        # Use AudioFileWriterProcessor to write MP3 to transcript location
+        mp3_writer = AudioFileWriterProcessor(
+            path=transcript.audio_mp3_filename,
+            on_duration=self.on_duration,
+        )
+
+        # Process audio frames and write to transcript location
+        input_container = av.open(str(file_path))
+        for frame in input_container.decode(audio=0):
+            await mp3_writer.push(frame)
+
+        await mp3_writer.flush()
+        input_container.close()
+
+        if has_video:
+            self.logger.info(
+                f"Extracted audio from video and saved to {transcript.audio_mp3_filename}"
+            )
+        else:
+            self.logger.info(
+                f"Converted audio file and saved to {transcript.audio_mp3_filename}"
+            )
+
+        return transcript.audio_mp3_filename
+
+    async def upload_audio(self, audio_path: Path, transcript: Transcript) -> str:
+        """Upload audio to storage for processing"""
+        storage = get_transcripts_storage()
+
+        if not storage:
+            raise Exception(
+                "Storage backend required for file processing. Configure TRANSCRIPT_STORAGE_* settings."
+            )
+
+        self.logger.info("Uploading audio to storage")
+
+        with open(audio_path, "rb") as f:
+            audio_data = f.read()
+
+        storage_path = f"file_pipeline/{transcript.id}/audio.mp3"
+        await storage.put_file(storage_path, audio_data)
+
+        audio_url = await storage.get_file_url(storage_path)
+
+        self.logger.info(f"Audio uploaded to {audio_url}")
+        return audio_url
+
+    async def run_parallel_processing(
+        self,
+        audio_path: Path,
+        audio_url: str,
+        source_language: str,
+        target_language: str,
+    ):
+        """Coordinate parallel processing of transcription, diarization, and waveform"""
+        self.logger.info(
+            "Starting parallel processing", transcript_id=self.transcript_id
+        )
+
+        # Phase 1: Parallel processing of independent tasks
+        transcription_task = self.transcribe_file(audio_url, source_language)
+        diarization_task = self.diarize_file(audio_url)
+        waveform_task = self.generate_waveform(audio_path)
+
+        results = await asyncio.gather(
+            transcription_task, diarization_task, waveform_task, return_exceptions=True
+        )
+
+        transcript_result = results[0]
+        diarization_result = results[1]
+
+        # Handle errors - raise any exception that occurred
+        self._handle_gather_exceptions(results, "parallel processing")
+        for result in results:
+            if isinstance(result, Exception):
+                raise result
+
+        # Phase 2: Assemble transcript with diarization
+        self.logger.info(
+            "Assembling transcript with diarization", transcript_id=self.transcript_id
+        )
+        processor = TranscriptDiarizationAssemblerProcessor()
+        input_data = TranscriptDiarizationAssemblerInput(
+            transcript=transcript_result, diarization=diarization_result or []
+        )
+
+        # Store result for retrieval
+        diarized_transcript: Transcript | None = None
+
+        async def capture_result(transcript):
+            nonlocal diarized_transcript
+            diarized_transcript = transcript
+
+        processor.on(capture_result)
+        await processor.push(input_data)
+        await processor.flush()
+
+        if not diarized_transcript:
+            raise ValueError("No diarized transcript captured")
+
+        # Phase 3: Generate topics from diarized transcript
+        self.logger.info("Generating topics", transcript_id=self.transcript_id)
+        topics = await self.detect_topics(diarized_transcript, target_language)
+
+        # Phase 4: Generate title and summaries in parallel
+        self.logger.info(
+            "Generating title and summaries", transcript_id=self.transcript_id
+        )
+        results = await asyncio.gather(
+            self.generate_title(topics),
+            self.generate_summaries(topics),
+            return_exceptions=True,
+        )
+
+        self._handle_gather_exceptions(results, "title and summary generation")
+
+    async def transcribe_file(self, audio_url: str, language: str) -> TranscriptType:
+        """Transcribe complete file"""
+        processor = FileTranscriptAutoProcessor()
+        input_data = FileTranscriptInput(audio_url=audio_url, language=language)
+
+        # Store result for retrieval
+        result: TranscriptType | None = None
+
+        async def capture_result(transcript):
+            nonlocal result
+            result = transcript
+
+        processor.on(capture_result)
+        await processor.push(input_data)
+        await processor.flush()
+
+        if not result:
+            raise ValueError("No transcript captured")
+
+        return result
+
+    async def diarize_file(self, audio_url: str) -> list[DiarizationSegment] | None:
+        """Get diarization for file"""
+        if not settings.DIARIZATION_BACKEND:
+            self.logger.info("Diarization disabled")
+            return None
+
+        processor = FileDiarizationAutoProcessor()
+        input_data = FileDiarizationInput(audio_url=audio_url)
+
+        # Store result for retrieval
+        result = None
+
+        async def capture_result(diarization_output):
+            nonlocal result
+            result = diarization_output.diarization
+
+        try:
+            processor.on(capture_result)
+            await processor.push(input_data)
+            await processor.flush()
+            return result
+        except Exception as e:
+            self.logger.error(f"Diarization failed: {e}")
+            return None
+
+    async def generate_waveform(self, audio_path: Path):
+        """Generate and save waveform"""
+        transcript = await self.get_transcript()
+
+        processor = AudioWaveformProcessor(
+            audio_path=audio_path,
+            waveform_path=transcript.audio_waveform_filename,
+            on_waveform=self.on_waveform,
+        )
+        processor.set_pipeline(self.empty_pipeline)
+
+        await processor.flush()
+
+    async def detect_topics(
+        self, transcript: TranscriptType, target_language: str
+    ) -> list[TitleSummary]:
+        """Detect topics from complete transcript"""
+        chunk_size = 300
+        topics: list[TitleSummary] = []
+
+        async def on_topic(topic: TitleSummary):
+            topics.append(topic)
+            return await self.on_topic(topic)
+
+        topic_detector = TranscriptTopicDetectorProcessor(callback=on_topic)
+        topic_detector.set_pipeline(self.empty_pipeline)
+
+        for i in range(0, len(transcript.words), chunk_size):
+            chunk_words = transcript.words[i : i + chunk_size]
+            if not chunk_words:
+                continue
+
+            chunk_transcript = TranscriptType(
+                words=chunk_words, translation=transcript.translation
+            )
+
+            await topic_detector.push(chunk_transcript)
+
+        await topic_detector.flush()
+        return topics
+
+    async def generate_title(self, topics: list[TitleSummary]):
+        """Generate title from topics"""
+        if not topics:
+            self.logger.warning("No topics for title generation")
+            return
+
+        processor = TranscriptFinalTitleProcessor(callback=self.on_title)
+        processor.set_pipeline(self.empty_pipeline)
+
+        for topic in topics:
+            await processor.push(topic)
+
+        await processor.flush()
+
+    async def generate_summaries(self, topics: list[TitleSummary]):
+        """Generate long and short summaries from topics"""
+        if not topics:
+            self.logger.warning("No topics for summary generation")
+            return
+
+        transcript = await self.get_transcript()
+        processor = TranscriptFinalSummaryProcessor(
+            transcript=transcript,
+            callback=self.on_long_summary,
+            on_short_summary=self.on_short_summary,
+        )
+        processor.set_pipeline(self.empty_pipeline)
+
+        for topic in topics:
+            await processor.push(topic)
+
+        await processor.flush()
+
+
+@shared_task
+@asynctask
+async def task_pipeline_file_process(*, transcript_id: str):
+    """Celery task for file pipeline processing"""
+
+    transcript = await transcripts_controller.get_by_id(transcript_id)
+    if not transcript:
+        raise Exception(f"Transcript {transcript_id} not found")
+
+    # Find the file to process
+    audio_file = next(transcript.data_path.glob("upload.*"), None)
+    if not audio_file:
+        audio_file = next(transcript.data_path.glob("audio.*"), None)
+
+    if not audio_file:
+        raise Exception("No audio file found to process")
+
+    # Run file pipeline
+    pipeline = PipelineMainFile(transcript_id=transcript_id)
+    await pipeline.process(audio_file)
--- a/server/reflector/pipelines/main_live_pipeline.py
+++ b/server/reflector/pipelines/main_live_pipeline.py
@@ -14,12 +14,15 @@ It is directly linked to our data model.
 import asyncio
 import functools
 from contextlib import asynccontextmanager
+from typing import Generic

+import av
 import boto3
 from celery import chord, current_task, group, shared_task
 from pydantic import BaseModel
 from structlog import BoundLogger as Logger

+from reflector.db import get_database
 from reflector.db.meetings import meeting_consent_controller, meetings_controller
 from reflector.db.recordings import recordings_controller
 from reflector.db.rooms import rooms_controller
@@ -35,7 +38,7 @@ from reflector.db.transcripts import (
    transcripts_controller,
 )
 from reflector.logger import logger
-from reflector.pipelines.runner import PipelineRunner
+from reflector.pipelines.runner import PipelineMessage, PipelineRunner
 from reflector.processors import (
    AudioChunkerProcessor,
    AudioDiarizationAutoProcessor,
@@ -47,7 +50,7 @@ from reflector.processors import (
    TranscriptFinalTitleProcessor,
    TranscriptLinerProcessor,
    TranscriptTopicDetectorProcessor,
-    TranscriptTranslatorProcessor,
+    TranscriptTranslatorAutoProcessor,
 )
 from reflector.processors.audio_waveform_processor import AudioWaveformProcessor
 from reflector.processors.types import AudioDiarizationInput
@@ -69,8 +72,7 @@ def asynctask(f):
    @functools.wraps(f)
    def wrapper(*args, **kwargs):
        async def run_with_db():
-            from reflector.db import database
-
+            database = get_database()
            await database.connect()
            try:
                return await f(*args, **kwargs)
@@ -144,16 +146,19 @@ class StrValue(BaseModel):
    value: str


-class PipelineMainBase(PipelineRunner):
-    transcript_id: str
-    ws_room_id: str | None = None
-    ws_manager: WebsocketManager | None = None
-
-    def prepare(self):
-        # prepare websocket
+class PipelineMainBase(PipelineRunner[PipelineMessage], Generic[PipelineMessage]):
+    def __init__(self, transcript_id: str):
+        super().__init__()
        self._lock = asyncio.Lock()
+        self.transcript_id = transcript_id
        self.ws_room_id = f"ts:{self.transcript_id}"
-        self.ws_manager = get_ws_manager()
+        self._ws_manager = None
+
+    @property
+    def ws_manager(self) -> WebsocketManager:
+        if self._ws_manager is None:
+            self._ws_manager = get_ws_manager()
+        return self._ws_manager

    async def get_transcript(self) -> Transcript:
        # fetch the transcript
@@ -164,7 +169,11 @@ class PipelineMainBase(PipelineRunner):
            raise Exception("Transcript not found")
        return result

-    def get_transcript_topics(self, transcript: Transcript) -> list[TranscriptTopic]:
+    @staticmethod
+    def wrap_transcript_topics(
+        topics: list[TranscriptTopic],
+    ) -> list[TitleSummaryWithIdProcessorType]:
+        # transformation to a pipe-supported format
        return [
            TitleSummaryWithIdProcessorType(
                id=topic.id,
@@ -174,7 +183,7 @@ class PipelineMainBase(PipelineRunner):
                duration=topic.duration,
                transcript=TranscriptProcessorType(words=topic.words),
            )
-            for topic in transcript.topics
+            for topic in topics
        ]

    @asynccontextmanager
@@ -349,7 +358,6 @@ class PipelineMainLive(PipelineMainBase):
    async def create(self) -> Pipeline:
        # create a context for the whole rtc transaction
        # add a customised logger to the context
-        self.prepare()
        transcript = await self.get_transcript()

        processors = [
@@ -361,7 +369,7 @@ class PipelineMainLive(PipelineMainBase):
            AudioMergeProcessor(),
            AudioTranscriptAutoProcessor.as_threaded(),
            TranscriptLinerProcessor(),
-            TranscriptTranslatorProcessor.as_threaded(callback=self.on_transcript),
+            TranscriptTranslatorAutoProcessor.as_threaded(callback=self.on_transcript),
            TranscriptTopicDetectorProcessor.as_threaded(callback=self.on_topic),
        ]
        pipeline = Pipeline(*processors)
@@ -370,6 +378,7 @@ class PipelineMainLive(PipelineMainBase):
        pipeline.set_pref("audio:target_language", transcript.target_language)
        pipeline.logger.bind(transcript_id=transcript.id)
        pipeline.logger.info("Pipeline main live created")
+        pipeline.describe()

        return pipeline

@@ -380,7 +389,7 @@ class PipelineMainLive(PipelineMainBase):
        pipeline_post(transcript_id=self.transcript_id)


-class PipelineMainDiarization(PipelineMainBase):
+class PipelineMainDiarization(PipelineMainBase[AudioDiarizationInput]):
    """
    Diarize the audio and update topics
    """
@@ -388,7 +397,6 @@ class PipelineMainDiarization(PipelineMainBase):
    async def create(self) -> Pipeline:
        # create a context for the whole rtc transaction
        # add a customised logger to the context
-        self.prepare()
        pipeline = Pipeline(
            AudioDiarizationAutoProcessor(callback=self.on_topic),
        )
@@ -404,11 +412,10 @@ class PipelineMainDiarization(PipelineMainBase):
            pipeline.logger.info("Audio is local, skipping diarization")
            return

-        topics = self.get_transcript_topics(transcript)
        audio_url = await transcript.get_audio_url()
        audio_diarization_input = AudioDiarizationInput(
            audio_url=audio_url,
-            topics=topics,
+            topics=self.wrap_transcript_topics(transcript.topics),
        )

        # as tempting to use pipeline.push, prefer to use the runner
@@ -421,7 +428,7 @@ class PipelineMainDiarization(PipelineMainBase):
        return pipeline


-class PipelineMainFromTopics(PipelineMainBase):
+class PipelineMainFromTopics(PipelineMainBase[TitleSummaryWithIdProcessorType]):
    """
    Pseudo class for generating a pipeline from topics
    """
@@ -430,8 +437,6 @@ class PipelineMainFromTopics(PipelineMainBase):
        raise NotImplementedError

    async def create(self) -> Pipeline:
-        self.prepare()
-
        # get transcript
        self._transcript = transcript = await self.get_transcript()

@@ -443,7 +448,7 @@ class PipelineMainFromTopics(PipelineMainBase):
        pipeline.logger.info(f"{self.__class__.__name__} pipeline created")

        # push topics
-        topics = self.get_transcript_topics(transcript)
+        topics = PipelineMainBase.wrap_transcript_topics(transcript.topics)
        for topic in topics:
            await self.push(topic)

@@ -524,8 +529,6 @@ async def pipeline_convert_to_mp3(transcript: Transcript, logger: Logger):
    # Convert to mp3
    mp3_filename = transcript.audio_mp3_filename

-    import av
-
    with av.open(wav_filename.as_posix()) as in_container:
        in_stream = in_container.streams.audio[0]
        with av.open(mp3_filename.as_posix(), "w") as out_container:
@@ -604,7 +607,7 @@ async def cleanup_consent(transcript: Transcript, logger: Logger):
                        meeting.id
                    )
    except Exception as e:
-        logger.error(f"Failed to get fetch consent: {e}")
+        logger.error(f"Failed to get fetch consent: {e}", exc_info=e)
        consent_denied = True

    if not consent_denied:
@@ -627,7 +630,7 @@ async def cleanup_consent(transcript: Transcript, logger: Logger):
                f"Deleted original Whereby recording: {recording.bucket_name}/{recording.object_key}"
            )
        except Exception as e:
-            logger.error(f"Failed to delete Whereby recording: {e}")
+            logger.error(f"Failed to delete Whereby recording: {e}", exc_info=e)

    # non-transactional, files marked for deletion not actually deleted is possible
    await transcripts_controller.update(transcript, {"audio_deleted": True})
@@ -640,7 +643,7 @@ async def cleanup_consent(transcript: Transcript, logger: Logger):
                f"Deleted processed audio from storage: {transcript.storage_audio_path}"
            )
        except Exception as e:
-            logger.error(f"Failed to delete processed audio: {e}")
+            logger.error(f"Failed to delete processed audio: {e}", exc_info=e)

    # 3. Delete local audio files
    try:
@@ -649,7 +652,7 @@ async def cleanup_consent(transcript: Transcript, logger: Logger):
        if hasattr(transcript, "audio_wav_filename") and transcript.audio_wav_filename:
            transcript.audio_wav_filename.unlink(missing_ok=True)
    except Exception as e:
-        logger.error(f"Failed to delete local audio files: {e}")
+        logger.error(f"Failed to delete local audio files: {e}", exc_info=e)

    logger.info("Consent cleanup done")

@@ -794,8 +797,6 @@ def pipeline_post(*, transcript_id: str):

@get_transcript
 async def pipeline_process(transcript: Transcript, logger: Logger):
-    import av
-
    try:
        if transcript.audio_location == "storage":
            await transcripts_controller.download_mp3_from_storage(transcript)
--- a/server/reflector/pipelines/runner.py
+++ b/server/reflector/pipelines/runner.py
@@ -16,21 +16,16 @@ During its lifecycle, it will emit the following status:
 """

 import asyncio
-
-from pydantic import BaseModel, ConfigDict
+from typing import Generic, TypeVar

 from reflector.logger import logger
 from reflector.processors import Pipeline

+PipelineMessage = TypeVar("PipelineMessage")

-class PipelineRunner(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True)

-    status: str = "idle"
-    pipeline: Pipeline | None = None
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
+class PipelineRunner(Generic[PipelineMessage]):
+    def __init__(self):
        self._task = None
        self._q_cmd = asyncio.Queue(maxsize=4096)
        self._ev_done = asyncio.Event()
@@ -39,6 +34,8 @@ class PipelineRunner(BaseModel):
            runner=id(self),
            runner_cls=self.__class__.__name__,
        )
+        self.status = "idle"
+        self.pipeline: Pipeline | None = None

    async def create(self) -> Pipeline:
        """
@@ -67,7 +64,7 @@ class PipelineRunner(BaseModel):
        coro = self.run()
        asyncio.run(coro)

-    async def push(self, data):
+    async def push(self, data: PipelineMessage):
        """
        Push data to the pipeline
        """
@@ -92,7 +89,11 @@ class PipelineRunner(BaseModel):
        pass

    async def _add_cmd(
-        self, cmd: str, data, max_retries: int = 3, retry_time_limit: int = 3
+        self,
+        cmd: str,
+        data: PipelineMessage,
+        max_retries: int = 3,
+        retry_time_limit: int = 3,
    ):
        """
        Enqueue a command to be executed in the runner.
@@ -143,7 +144,10 @@ class PipelineRunner(BaseModel):
                cmd, data = await self._q_cmd.get()
                func = getattr(self, f"cmd_{cmd.lower()}")
                if func:
-                    await func(data)
+                    if cmd.upper() == "FLUSH":
+                        await func()
+                    else:
+                        await func(data)
                else:
                    raise Exception(f"Unknown command {cmd}")
        except Exception:
@@ -152,13 +156,13 @@ class PipelineRunner(BaseModel):
            self._ev_done.set()
            raise

-    async def cmd_push(self, data):
+    async def cmd_push(self, data: PipelineMessage):
        if self._is_first_push:
            await self._set_status("push")
            self._is_first_push = False
        await self.pipeline.push(data)

-    async def cmd_flush(self, data):
+    async def cmd_flush(self):
        await self._set_status("flush")
        await self.pipeline.flush()
        await self._set_status("ended")
--- a/server/reflector/processors/init.py
+++ b/server/reflector/processors/init.py
@@ -11,11 +11,19 @@ from .base import (  # noqa: F401
    Processor,
    ThreadedProcessor,
 )
+from .file_diarization import FileDiarizationProcessor  # noqa: F401
+from .file_diarization_auto import FileDiarizationAutoProcessor  # noqa: F401
+from .file_transcript import FileTranscriptProcessor  # noqa: F401
+from .file_transcript_auto import FileTranscriptAutoProcessor  # noqa: F401
+from .transcript_diarization_assembler import (
+    TranscriptDiarizationAssemblerProcessor,  # noqa: F401
+)
 from .transcript_final_summary import TranscriptFinalSummaryProcessor  # noqa: F401
 from .transcript_final_title import TranscriptFinalTitleProcessor  # noqa: F401
 from .transcript_liner import TranscriptLinerProcessor  # noqa: F401
 from .transcript_topic_detector import TranscriptTopicDetectorProcessor  # noqa: F401
 from .transcript_translator import TranscriptTranslatorProcessor  # noqa: F401
+from .transcript_translator_auto import TranscriptTranslatorAutoProcessor  # noqa: F401
 from .types import (  # noqa: F401
    AudioFile,
    FinalLongSummary,
--- a/server/reflector/processors/audio_chunker.py
+++ b/server/reflector/processors/audio_chunker.py
@@ -1,28 +1,340 @@
+from typing import Optional
+
 import av
+import numpy as np
+import torch
+from silero_vad import VADIterator, load_silero_vad

 from reflector.processors.base import Processor


 class AudioChunkerProcessor(Processor):
    """
-    Assemble audio frames into chunks
+    Assemble audio frames into chunks with VAD-based speech detection
    """

    INPUT_TYPE = av.AudioFrame
    OUTPUT_TYPE = list[av.AudioFrame]

-    def __init__(self, max_frames=256):
+    def __init__(
+        self,
+        block_frames=256,
+        max_frames=1024,
+        vad_threshold=0.5,
+        use_onnx=False,
+        min_frames=2,
+    ):
        super().__init__()
        self.frames: list[av.AudioFrame] = []
+        self.block_frames = block_frames
        self.max_frames = max_frames
+        self.vad_threshold = vad_threshold
+        self.min_frames = min_frames
+
+        # Initialize Silero VAD
+        self._init_vad(use_onnx)
+
+    def _init_vad(self, use_onnx=False):
+        """Initialize Silero VAD model"""
+        try:
+            torch.set_num_threads(1)
+            self.vad_model = load_silero_vad(onnx=use_onnx)
+            self.vad_iterator = VADIterator(self.vad_model, sampling_rate=16000)
+            self.logger.info("Silero VAD initialized successfully")
+
+        except Exception as e:
+            self.logger.error(f"Failed to initialize Silero VAD: {e}")
+            self.vad_model = None
+            self.vad_iterator = None

    async def _push(self, data: av.AudioFrame):
        self.frames.append(data)
-        if len(self.frames) >= self.max_frames:
-            await self.flush()
+        # print("timestamp", data.pts * data.time_base * 1000)
+
+        # Check for speech segments every 32 frames (~1 second)
+        if len(self.frames) >= 32 and len(self.frames) % 32 == 0:
+            await self._process_block()
+
+        # Safety fallback - emit if we hit max frames
+        elif len(self.frames) >= self.max_frames:
+            self.logger.warning(
+                f"AudioChunkerProcessor: Reached max frames ({self.max_frames}), "
+                f"emitting first {self.max_frames // 2} frames"
+            )
+            frames_to_emit = self.frames[: self.max_frames // 2]
+            self.frames = self.frames[self.max_frames // 2 :]
+            if len(frames_to_emit) >= self.min_frames:
+                await self.emit(frames_to_emit)
+            else:
+                self.logger.debug(
+                    f"Ignoring fallback segment with {len(frames_to_emit)} frames "
+                    f"(< {self.min_frames} minimum)"
+                )
+
+    async def _process_block(self):
+        # Need at least 32 frames for VAD detection (~1 second)
+        if len(self.frames) < 32 or self.vad_iterator is None:
+            return
+
+        # Processing block with current buffer size
+        # print(f"Processing block: {len(self.frames)} frames in buffer")
+
+        try:
+            # Convert frames to numpy array for VAD
+            audio_array = self._frames_to_numpy(self.frames)
+
+            if audio_array is None:
+                # Fallback: emit all frames if conversion failed
+                frames_to_emit = self.frames[:]
+                self.frames = []
+                if len(frames_to_emit) >= self.min_frames:
+                    await self.emit(frames_to_emit)
+                else:
+                    self.logger.debug(
+                        f"Ignoring conversion-failed segment with {len(frames_to_emit)} frames "
+                        f"(< {self.min_frames} minimum)"
+                    )
+                return
+
+            # Find complete speech segments in the buffer
+            speech_end_frame = self._find_speech_segment_end(audio_array)
+
+            if speech_end_frame is None or speech_end_frame <= 0:
+                # No speech found but buffer is getting large
+                if len(self.frames) > 512:
+                    # Check if it's all silence and can be discarded
+                    # No speech segment found, buffer at {len(self.frames)} frames
+
+                    # Could emit silence or discard old frames here
+                    # For now, keep first 256 frames and discard older silence
+                    if len(self.frames) > 768:
+                        self.logger.debug(
+                            f"Discarding {len(self.frames) - 256} old frames (likely silence)"
+                        )
+                        self.frames = self.frames[-256:]
+                return
+
+            # Calculate segment timing information
+            frames_to_emit = self.frames[:speech_end_frame]
+
+            # Get timing from av.AudioFrame
+            if frames_to_emit:
+                first_frame = frames_to_emit[0]
+                last_frame = frames_to_emit[-1]
+                sample_rate = first_frame.sample_rate
+
+                # Calculate duration
+                total_samples = sum(f.samples for f in frames_to_emit)
+                duration_seconds = total_samples / sample_rate if sample_rate > 0 else 0
+
+                # Get timestamps if available
+                start_time = (
+                    first_frame.pts * first_frame.time_base if first_frame.pts else 0
+                )
+                end_time = (
+                    last_frame.pts * last_frame.time_base if last_frame.pts else 0
+                )
+
+                # Convert to HH:MM:SS format for logging
+                def format_time(seconds):
+                    if not seconds:
+                        return "00:00:00"
+                    total_seconds = int(float(seconds))
+                    hours = total_seconds // 3600
+                    minutes = (total_seconds % 3600) // 60
+                    secs = total_seconds % 60
+                    return f"{hours:02d}:{minutes:02d}:{secs:02d}"
+
+                start_formatted = format_time(start_time)
+                end_formatted = format_time(end_time)
+
+                # Keep remaining frames for next processing
+                remaining_after = len(self.frames) - speech_end_frame
+
+                # Single structured log line
+                self.logger.info(
+                    "Speech segment found",
+                    start=start_formatted,
+                    end=end_formatted,
+                    frames=speech_end_frame,
+                    duration=round(duration_seconds, 2),
+                    buffer_before=len(self.frames),
+                    remaining=remaining_after,
+                )
+
+            # Keep remaining frames for next processing
+            self.frames = self.frames[speech_end_frame:]
+
+            # Filter out segments with too few frames
+            if len(frames_to_emit) >= self.min_frames:
+                await self.emit(frames_to_emit)
+            else:
+                self.logger.debug(
+                    f"Ignoring segment with {len(frames_to_emit)} frames "
+                    f"(< {self.min_frames} minimum)"
+                )
+
+        except Exception as e:
+            self.logger.error(f"Error in VAD processing: {e}")
+            # Fallback to simple chunking
+            if len(self.frames) >= self.block_frames:
+                frames_to_emit = self.frames[: self.block_frames]
+                self.frames = self.frames[self.block_frames :]
+                if len(frames_to_emit) >= self.min_frames:
+                    await self.emit(frames_to_emit)
+                else:
+                    self.logger.debug(
+                        f"Ignoring exception-fallback segment with {len(frames_to_emit)} frames "
+                        f"(< {self.min_frames} minimum)"
+                    )
+
+    def _frames_to_numpy(self, frames: list[av.AudioFrame]) -> Optional[np.ndarray]:
+        """Convert av.AudioFrame list to numpy array for VAD processing"""
+        if not frames:
+            return None
+
+        try:
+            first_frame = frames[0]
+            original_sample_rate = first_frame.sample_rate
+
+            audio_data = []
+            for frame in frames:
+                frame_array = frame.to_ndarray()
+
+                # Handle stereo -> mono conversion
+                if len(frame_array.shape) == 2 and frame_array.shape[0] > 1:
+                    frame_array = np.mean(frame_array, axis=0)
+                elif len(frame_array.shape) == 2:
+                    frame_array = frame_array.flatten()
+
+                audio_data.append(frame_array)
+
+            if not audio_data:
+                return None
+
+            combined_audio = np.concatenate(audio_data)
+
+            # Resample from 48kHz to 16kHz if needed
+            if original_sample_rate != 16000:
+                combined_audio = self._resample_audio(
+                    combined_audio, original_sample_rate, 16000
+                )
+
+            # Ensure float32 format
+            if combined_audio.dtype == np.int16:
+                # Normalize int16 audio to float32 in range [-1.0, 1.0]
+                combined_audio = combined_audio.astype(np.float32) / 32768.0
+            elif combined_audio.dtype != np.float32:
+                combined_audio = combined_audio.astype(np.float32)
+
+            return combined_audio
+
+        except Exception as e:
+            self.logger.error(f"Error converting frames to numpy: {e}")
+
+        return None
+
+    def _resample_audio(
+        self, audio: np.ndarray, from_sr: int, to_sr: int
+    ) -> np.ndarray:
+        """Simple linear resampling from from_sr to to_sr"""
+        if from_sr == to_sr:
+            return audio
+
+        try:
+            # Simple linear interpolation resampling
+            ratio = to_sr / from_sr
+            new_length = int(len(audio) * ratio)
+
+            # Create indices for interpolation
+            old_indices = np.linspace(0, len(audio) - 1, new_length)
+            resampled = np.interp(old_indices, np.arange(len(audio)), audio)
+
+            return resampled.astype(np.float32)
+
+        except Exception as e:
+            self.logger.error("Resampling error", exc_info=e)
+            # Fallback: simple decimation/repetition
+            if from_sr > to_sr:
+                # Downsample by taking every nth sample
+                step = from_sr // to_sr
+                return audio[::step]
+            else:
+                # Upsample by repeating samples
+                repeat = to_sr // from_sr
+                return np.repeat(audio, repeat)
+
+    def _find_speech_segment_end(self, audio_array: np.ndarray) -> Optional[int]:
+        """Find complete speech segments and return frame index at segment end"""
+        if self.vad_iterator is None or len(audio_array) == 0:
+            return None
+
+        try:
+            # Process audio in 512-sample windows for VAD
+            window_size = 512
+            min_silence_windows = 3  # Require 3 windows of silence after speech
+
+            # Track speech state
+            in_speech = False
+            speech_start = None
+            speech_end = None
+            silence_count = 0
+
+            for i in range(0, len(audio_array), window_size):
+                chunk = audio_array[i : i + window_size]
+                if len(chunk) < window_size:
+                    chunk = np.pad(chunk, (0, window_size - len(chunk)))
+
+                # Detect if this window has speech
+                speech_dict = self.vad_iterator(chunk, return_seconds=True)
+
+                # VADIterator returns dict with 'start' and 'end' when speech segments are detected
+                if speech_dict:
+                    if not in_speech:
+                        # Speech started
+                        speech_start = i
+                        in_speech = True
+                        # Debug: print(f"Speech START at sample {i}, VAD: {speech_dict}")
+                    silence_count = 0  # Reset silence counter
+                    continue
+
+                if not in_speech:
+                    continue
+
+                # We're in speech but found silence
+                silence_count += 1
+                if silence_count < min_silence_windows:
+                    continue
+
+                # Found end of speech segment
+                speech_end = i - (min_silence_windows - 1) * window_size
+                # Debug: print(f"Speech END at sample {speech_end}")
+
+                # Convert sample position to frame index
+                samples_per_frame = self.frames[0].samples if self.frames else 1024
+                # Account for resampling: we process at 16kHz but frames might be 48kHz
+                resample_ratio = 48000 / 16000  # 3x
+                actual_sample_pos = int(speech_end * resample_ratio)
+                frame_index = actual_sample_pos // samples_per_frame
+
+                # Ensure we don't exceed buffer
+                frame_index = min(frame_index, len(self.frames))
+                return frame_index
+
+            return None
+
+        except Exception as e:
+            self.logger.error(f"Error finding speech segment: {e}")
+            return None

    async def _flush(self):
        frames = self.frames[:]
        self.frames = []
        if frames:
-            await self.emit(frames)
+            if len(frames) >= self.min_frames:
+                await self.emit(frames)
+            else:
+                self.logger.debug(
+                    f"Ignoring flush segment with {len(frames)} frames "
+                    f"(< {self.min_frames} minimum)"
+                )
--- a/server/reflector/processors/audio_diarization.py
+++ b/server/reflector/processors/audio_diarization.py
@@ -1,5 +1,10 @@
 from reflector.processors.base import Processor
-from reflector.processors.types import AudioDiarizationInput, TitleSummary, Word
+from reflector.processors.types import (
+    AudioDiarizationInput,
+    DiarizationSegment,
+    TitleSummary,
+    Word,
+)


 class AudioDiarizationProcessor(Processor):
@@ -33,18 +38,21 @@ class AudioDiarizationProcessor(Processor):
    async def _diarize(self, data: AudioDiarizationInput):
        raise NotImplementedError

-    def assign_speaker(self, words: list[Word], diarization: list[dict]):
-        self._diarization_remove_overlap(diarization)
-        self._diarization_remove_segment_without_words(words, diarization)
-        self._diarization_merge_same_speaker(words, diarization)
-        self._diarization_assign_speaker(words, diarization)
+    @classmethod
+    def assign_speaker(cls, words: list[Word], diarization: list[DiarizationSegment]):
+        cls._diarization_remove_overlap(diarization)
+        cls._diarization_remove_segment_without_words(words, diarization)
+        cls._diarization_merge_same_speaker(diarization)
+        cls._diarization_assign_speaker(words, diarization)

-    def iter_words_from_topics(self, topics: TitleSummary):
+    @staticmethod
+    def iter_words_from_topics(topics: list[TitleSummary]):
        for topic in topics:
            for word in topic.transcript.words:
                yield word

-    def is_word_continuation(self, word_prev, word):
+    @staticmethod
+    def is_word_continuation(word_prev, word):
        """
        Return True if the word is a continuation of the previous word
        by checking if the previous word is ending with a punctuation
@@ -57,7 +65,8 @@ class AudioDiarizationProcessor(Processor):
            return False
        return True

-    def _diarization_remove_overlap(self, diarization: list[dict]):
+    @staticmethod
+    def _diarization_remove_overlap(diarization: list[DiarizationSegment]):
        """
        Remove overlap in diarization results

@@ -82,8 +91,9 @@ class AudioDiarizationProcessor(Processor):
            else:
                diarization_idx += 1

+    @staticmethod
    def _diarization_remove_segment_without_words(
-        self, words: list[Word], diarization: list[dict]
+        words: list[Word], diarization: list[DiarizationSegment]
    ):
        """
        Remove diarization segments without words
@@ -112,9 +122,8 @@ class AudioDiarizationProcessor(Processor):
            else:
                diarization_idx += 1

-    def _diarization_merge_same_speaker(
-        self, words: list[Word], diarization: list[dict]
-    ):
+    @staticmethod
+    def _diarization_merge_same_speaker(diarization: list[DiarizationSegment]):
        """
        Merge diarization contigous segments with the same speaker

@@ -131,7 +140,10 @@ class AudioDiarizationProcessor(Processor):
            else:
                diarization_idx += 1

-    def _diarization_assign_speaker(self, words: list[Word], diarization: list[dict]):
+    @classmethod
+    def _diarization_assign_speaker(
+        cls, words: list[Word], diarization: list[DiarizationSegment]
+    ):
        """
        Assign speaker to words based on diarization

@@ -139,7 +151,7 @@ class AudioDiarizationProcessor(Processor):
        """

        word_idx = 0
-        last_speaker = None
+        last_speaker = 0
        for d in diarization:
            start = d["start"]
            end = d["end"]
@@ -154,7 +166,7 @@ class AudioDiarizationProcessor(Processor):
                    # If it's a continuation, assign with the last speaker
                    is_continuation = False
                    if word_idx > 0 and word_idx < len(words) - 1:
-                        is_continuation = self.is_word_continuation(
+                        is_continuation = cls.is_word_continuation(
                            *words[word_idx - 1 : word_idx + 1]
                        )
                    if is_continuation:
--- a/server/reflector/processors/audio_diarization_modal.py
+++ b/server/reflector/processors/audio_diarization_modal.py
@@ -10,12 +10,17 @@ class AudioDiarizationModalProcessor(AudioDiarizationProcessor):
    INPUT_TYPE = AudioDiarizationInput
    OUTPUT_TYPE = TitleSummary

-    def __init__(self, **kwargs):
+    def __init__(self, modal_api_key: str | None = None, **kwargs):
        super().__init__(**kwargs)
+        if not settings.DIARIZATION_URL:
+            raise Exception(
+                "DIARIZATION_URL required to use AudioDiarizationModalProcessor"
+            )
        self.diarization_url = settings.DIARIZATION_URL + "/diarize"
-        self.headers = {
-            "Authorization": f"Bearer {settings.LLM_MODAL_API_KEY}",
-        }
+        self.modal_api_key = modal_api_key
+        self.headers = {}
+        if self.modal_api_key:
+            self.headers["Authorization"] = f"Bearer {self.modal_api_key}"

    async def _diarize(self, data: AudioDiarizationInput):
        # Gather diarization data
--- a/server/reflector/processors/audio_diarization_pyannote.py
+++ b/server/reflector/processors/audio_diarization_pyannote.py
@@ -0,0 +1,74 @@
+import os
+
+import torch
+import torchaudio
+from pyannote.audio import Pipeline
+
+from reflector.processors.audio_diarization import AudioDiarizationProcessor
+from reflector.processors.audio_diarization_auto import AudioDiarizationAutoProcessor
+from reflector.processors.types import AudioDiarizationInput, DiarizationSegment
+
+
+class AudioDiarizationPyannoteProcessor(AudioDiarizationProcessor):
+    """Local diarization processor using pyannote.audio library"""
+
+    def __init__(
+        self,
+        model_name: str = "pyannote/speaker-diarization-3.1",
+        pyannote_auth_token: str | None = None,
+        device: str | None = None,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.model_name = model_name
+        self.auth_token = pyannote_auth_token or os.environ.get("HF_TOKEN")
+        self.device = device
+
+        if device is None:
+            self.device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        self.logger.info(f"Loading pyannote diarization model: {self.model_name}")
+        self.diarization_pipeline = Pipeline.from_pretrained(
+            self.model_name, use_auth_token=self.auth_token
+        )
+        self.diarization_pipeline.to(torch.device(self.device))
+        self.logger.info(f"Diarization model loaded on device: {self.device}")
+
+    async def _diarize(self, data: AudioDiarizationInput) -> list[DiarizationSegment]:
+        try:
+            # Load audio file (audio_url is assumed to be a local file path)
+            self.logger.info(f"Loading local audio file: {data.audio_url}")
+            waveform, sample_rate = torchaudio.load(data.audio_url)
+            audio_input = {"waveform": waveform, "sample_rate": sample_rate}
+            self.logger.info("Running speaker diarization")
+            diarization = self.diarization_pipeline(audio_input)
+
+            # Convert pyannote diarization output to our format
+            segments = []
+            for segment, _, speaker in diarization.itertracks(yield_label=True):
+                # Extract speaker number from label (e.g., "SPEAKER_00" -> 0)
+                speaker_id = 0
+                if speaker.startswith("SPEAKER_"):
+                    try:
+                        speaker_id = int(speaker.split("_")[-1])
+                    except (ValueError, IndexError):
+                        # Fallback to hash-based ID if parsing fails
+                        speaker_id = hash(speaker) % 1000
+
+                segments.append(
+                    {
+                        "start": round(segment.start, 3),
+                        "end": round(segment.end, 3),
+                        "speaker": speaker_id,
+                    }
+                )
+
+            self.logger.info(f"Diarization completed with {len(segments)} segments")
+            return segments
+
+        except Exception as e:
+            self.logger.exception(f"Diarization failed: {e}")
+            raise
+
+
+AudioDiarizationAutoProcessor.register("pyannote", AudioDiarizationPyannoteProcessor)
--- a/server/reflector/processors/audio_merge.py
+++ b/server/reflector/processors/audio_merge.py
@@ -3,11 +3,24 @@ from time import monotonic_ns
 from uuid import uuid4

 import av
+from av.audio.resampler import AudioResampler

 from reflector.processors.base import Processor
 from reflector.processors.types import AudioFile


+def copy_frame(frame: av.AudioFrame) -> av.AudioFrame:
+    frame_copy = frame.from_ndarray(
+        frame.to_ndarray(),
+        format=frame.format.name,
+        layout=frame.layout.name,
+    )
+    frame_copy.sample_rate = frame.sample_rate
+    frame_copy.pts = frame.pts
+    frame_copy.time_base = frame.time_base
+    return frame_copy
+
+
 class AudioMergeProcessor(Processor):
    """
    Merge audio frame into a single file
@@ -16,37 +29,92 @@ class AudioMergeProcessor(Processor):
    INPUT_TYPE = list[av.AudioFrame]
    OUTPUT_TYPE = AudioFile

+    def __init__(self, downsample_to_16k_mono: bool = True, **kwargs):
+        super().__init__(**kwargs)
+        self.downsample_to_16k_mono = downsample_to_16k_mono
+
    async def _push(self, data: list[av.AudioFrame]):
        if not data:
            return

        # get audio information from first frame
        frame = data[0]
-        channels = len(frame.layout.channels)
-        sample_rate = frame.sample_rate
-        sample_width = frame.format.bytes
+        original_channels = len(frame.layout.channels)
+        original_sample_rate = frame.sample_rate
+        original_sample_width = frame.format.bytes
+
+        # determine if we need processing
+        needs_processing = self.downsample_to_16k_mono and (
+            original_sample_rate != 16000 or original_channels != 1
+        )
+
+        # determine output parameters
+        if self.downsample_to_16k_mono:
+            output_sample_rate = 16000
+            output_channels = 1
+            output_sample_width = 2  # 16-bit = 2 bytes
+        else:
+            output_sample_rate = original_sample_rate
+            output_channels = original_channels
+            output_sample_width = original_sample_width

        # create audio file
        uu = uuid4().hex
        fd = io.BytesIO()

-        out_container = av.open(fd, "w", format="wav")
-        out_stream = out_container.add_stream("pcm_s16le", rate=sample_rate)
-        for frame in data:
-            for packet in out_stream.encode(frame):
+        if needs_processing:
+            # Process with PyAV resampler
+            out_container = av.open(fd, "w", format="wav")
+            out_stream = out_container.add_stream("pcm_s16le", rate=16000)
+            out_stream.layout = "mono"
+
+            # Create resampler if needed
+            resampler = None
+            if original_sample_rate != 16000 or original_channels != 1:
+                resampler = AudioResampler(format="s16", layout="mono", rate=16000)
+
+            for frame in data:
+                if resampler:
+                    # Resample and convert to mono
+                    # XXX for an unknown reason, if we don't use a copy of the frame, we get
+                    # Invalid Argumment from resample. Debugging indicate that when a previous processor
+                    # already used the frame (like AudioFileWriter), it make it invalid argument here.
+                    resampled_frames = resampler.resample(copy_frame(frame))
+                    for resampled_frame in resampled_frames:
+                        for packet in out_stream.encode(resampled_frame):
+                            out_container.mux(packet)
+                else:
+                    # Direct encoding without resampling
+                    for packet in out_stream.encode(frame):
+                        out_container.mux(packet)
+
+            # Flush the encoder
+            for packet in out_stream.encode(None):
                out_container.mux(packet)
-        for packet in out_stream.encode(None):
-            out_container.mux(packet)
-        out_container.close()
+            out_container.close()
+        else:
+            # Use PyAV for original frames (no processing needed)
+            out_container = av.open(fd, "w", format="wav")
+            out_stream = out_container.add_stream("pcm_s16le", rate=output_sample_rate)
+            out_stream.layout = "mono" if output_channels == 1 else frame.layout
+
+            for frame in data:
+                for packet in out_stream.encode(frame):
+                    out_container.mux(packet)
+
+            for packet in out_stream.encode(None):
+                out_container.mux(packet)
+            out_container.close()
+
        fd.seek(0)

        # emit audio file
        audiofile = AudioFile(
            name=f"{monotonic_ns()}-{uu}.wav",
            fd=fd,
-            sample_rate=sample_rate,
-            channels=channels,
-            sample_width=sample_width,
+            sample_rate=output_sample_rate,
+            channels=output_channels,
+            sample_width=output_sample_width,
            timestamp=data[0].pts * data[0].time_base,
        )

--- a/server/reflector/processors/audio_transcript_modal.py
+++ b/server/reflector/processors/audio_transcript_modal.py
@@ -12,6 +12,9 @@ API will be a POST request to TRANSCRIPT_URL:

 """

+from typing import List
+
+import aiohttp
 from openai import AsyncOpenAI

 from reflector.processors.audio_transcript import AudioTranscriptProcessor
@@ -21,16 +24,142 @@ from reflector.settings import settings


 class AudioTranscriptModalProcessor(AudioTranscriptProcessor):
-    def __init__(self, modal_api_key: str):
+    def __init__(
+        self, modal_api_key: str | None = None, batch_enabled: bool = True, **kwargs
+    ):
        super().__init__()
+        if not settings.TRANSCRIPT_URL:
+            raise Exception(
+                "TRANSCRIPT_URL required to use AudioTranscriptModalProcessor"
+            )
        self.transcript_url = settings.TRANSCRIPT_URL + "/v1"
        self.timeout = settings.TRANSCRIPT_TIMEOUT
-        self.api_key = settings.TRANSCRIPT_MODAL_API_KEY
+        self.modal_api_key = modal_api_key
+        self.max_batch_duration = 10.0
+        self.max_batch_files = 15
+        self.batch_enabled = batch_enabled
+        self.pending_files: List[AudioFile] = []  # Files waiting to be processed
+
+    @classmethod
+    def _calculate_duration(cls, audio_file: AudioFile) -> float:
+        """Calculate audio duration in seconds from AudioFile metadata"""
+        # Duration = total_samples / sample_rate
+        # We need to estimate total samples from the file data
+        import wave
+
+        try:
+            # Try to read as WAV file to get duration
+            audio_file.fd.seek(0)
+            with wave.open(audio_file.fd, "rb") as wav_file:
+                frames = wav_file.getnframes()
+                sample_rate = wav_file.getframerate()
+                duration = frames / sample_rate
+                return duration
+        except Exception:
+            # Fallback: estimate from file size and audio parameters
+            audio_file.fd.seek(0, 2)  # Seek to end
+            file_size = audio_file.fd.tell()
+            audio_file.fd.seek(0)  # Reset to beginning
+
+            # Estimate: file_size / (sample_rate * channels * sample_width)
+            bytes_per_second = (
+                audio_file.sample_rate
+                * audio_file.channels
+                * (audio_file.sample_width // 8)
+            )
+            estimated_duration = (
+                file_size / bytes_per_second if bytes_per_second > 0 else 0
+            )
+            return max(0, estimated_duration)
+
+    def _create_batches(self, audio_files: List[AudioFile]) -> List[List[AudioFile]]:
+        """Group audio files into batches with maximum 30s total duration"""
+        batches = []
+        current_batch = []
+        current_duration = 0.0
+
+        for audio_file in audio_files:
+            duration = self._calculate_duration(audio_file)
+
+            # If adding this file exceeds max duration, start a new batch
+            if current_duration + duration > self.max_batch_duration and current_batch:
+                batches.append(current_batch)
+                current_batch = [audio_file]
+                current_duration = duration
+            else:
+                current_batch.append(audio_file)
+                current_duration += duration
+
+        # Add the last batch if not empty
+        if current_batch:
+            batches.append(current_batch)
+
+        return batches
+
+    async def _transcript_batch(self, audio_files: List[AudioFile]) -> List[Transcript]:
+        """Transcribe a batch of audio files using the parakeet backend"""
+        if not audio_files:
+            return []
+
+        self.logger.debug(f"Batch transcribing {len(audio_files)} files")
+
+        # Prepare form data for batch request
+        data = aiohttp.FormData()
+        data.add_field("language", self.get_pref("audio:source_language", "en"))
+        data.add_field("batch", "true")
+
+        for i, audio_file in enumerate(audio_files):
+            audio_file.fd.seek(0)
+            data.add_field(
+                "files",
+                audio_file.fd,
+                filename=f"{audio_file.name}",
+                content_type="audio/wav",
+            )
+
+        # Make batch request
+        headers = {"Authorization": f"Bearer {self.modal_api_key}"}
+
+        async with aiohttp.ClientSession(
+            timeout=aiohttp.ClientTimeout(total=self.timeout)
+        ) as session:
+            async with session.post(
+                f"{self.transcript_url}/audio/transcriptions",
+                data=data,
+                headers=headers,
+            ) as response:
+                if response.status != 200:
+                    error_text = await response.text()
+                    raise Exception(
+                        f"Batch transcription failed: {response.status} {error_text}"
+                    )
+
+                result = await response.json()
+
+        # Process batch results
+        transcripts = []
+        results = result.get("results", [])
+
+        for i, (audio_file, file_result) in enumerate(zip(audio_files, results)):
+            transcript = Transcript(
+                words=[
+                    Word(
+                        text=word_info["word"],
+                        start=word_info["start"],
+                        end=word_info["end"],
+                    )
+                    for word_info in file_result.get("words", [])
+                ]
+            )
+            transcript.add_offset(audio_file.timestamp)
+            transcripts.append(transcript)
+
+        return transcripts

    async def _transcript(self, data: AudioFile):
        async with AsyncOpenAI(
            base_url=self.transcript_url,
-            api_key=self.api_key,
+            api_key=self.modal_api_key,
            timeout=self.timeout,
        ) as client:
            self.logger.debug(f"Try to transcribe audio {data.name}")
@@ -58,5 +187,96 @@ class AudioTranscriptModalProcessor(AudioTranscriptProcessor):

        return transcript

+    async def transcript_multiple(
+        self, audio_files: List[AudioFile]
+    ) -> List[Transcript]:
+        """Transcribe multiple audio files using batching"""
+        if len(audio_files) == 1:
+            # Single file, use existing method
+            return [await self._transcript(audio_files[0])]
+
+        # Create batches with max 30s duration each
+        batches = self._create_batches(audio_files)
+
+        self.logger.debug(
+            f"Processing {len(audio_files)} files in {len(batches)} batches"
+        )
+
+        # Process all batches concurrently
+        all_transcripts = []
+
+        for batch in batches:
+            batch_transcripts = await self._transcript_batch(batch)
+            all_transcripts.extend(batch_transcripts)
+
+        return all_transcripts
+
+    async def _push(self, data: AudioFile):
+        """Override _push to support batching"""
+        if not self.batch_enabled:
+            # Use parent implementation for single file processing
+            return await super()._push(data)
+
+        # Add file to pending batch
+        self.pending_files.append(data)
+        self.logger.debug(
+            f"Added file to batch: {data.name}, batch size: {len(self.pending_files)}"
+        )
+
+        # Calculate total duration of pending files
+        total_duration = sum(self._calculate_duration(f) for f in self.pending_files)
+
+        # Process batch if it reaches max duration or has multiple files ready for optimization
+        should_process_batch = (
+            total_duration >= self.max_batch_duration
+            or len(self.pending_files) >= self.max_batch_files
+        )
+
+        if should_process_batch:
+            await self._process_pending_batch()
+
+    async def _process_pending_batch(self):
+        """Process all pending files as batches"""
+        if not self.pending_files:
+            return
+
+        self.logger.debug(f"Processing batch of {len(self.pending_files)} files")
+
+        try:
+            # Create batches respecting duration limit
+            batches = self._create_batches(self.pending_files)
+
+            # Process each batch
+            for batch in batches:
+                self.m_transcript_call.inc()
+                try:
+                    with self.m_transcript.time():
+                        # Use batch transcription
+                        transcripts = await self._transcript_batch(batch)
+
+                    self.m_transcript_success.inc()
+
+                    # Emit each transcript
+                    for transcript in transcripts:
+                        if transcript:
+                            await self.emit(transcript)
+
+                except Exception:
+                    self.m_transcript_failure.inc()
+                    raise
+                finally:
+                    # Release audio files
+                    for audio_file in batch:
+                        audio_file.release()
+
+        finally:
+            # Clear pending files
+            self.pending_files.clear()
+
+    async def _flush(self):
+        """Process any remaining files when flushing"""
+        await self._process_pending_batch()
+        await super()._flush()
+

 AudioTranscriptAutoProcessor.register("modal", AudioTranscriptModalProcessor)
--- a/server/reflector/processors/base.py
+++ b/server/reflector/processors/base.py
@@ -173,6 +173,7 @@ class Processor(Emitter):
        except Exception:
            self.m_processor_failure.inc()
            self.logger.exception("Error in push")
+            raise

    async def flush(self):
        """
@@ -240,33 +241,45 @@ class ThreadedProcessor(Processor):
        self.INPUT_TYPE = processor.INPUT_TYPE
        self.OUTPUT_TYPE = processor.OUTPUT_TYPE
        self.executor = ThreadPoolExecutor(max_workers=max_workers)
-        self.queue = asyncio.Queue()
-        self.task = asyncio.get_running_loop().create_task(self.loop())
+        self.queue = asyncio.Queue(maxsize=50)
+        self.task: asyncio.Task | None = None

    def set_pipeline(self, pipeline: "Pipeline"):
        super().set_pipeline(pipeline)
        self.processor.set_pipeline(pipeline)

    async def loop(self):
-        while True:
-            data = await self.queue.get()
-            self.m_processor_queue.set(self.queue.qsize())
-            with self.m_processor_queue_in_progress.track_inprogress():
-                try:
-                    if data is None:
-                        await self.processor.flush()
-                        break
+        try:
+            while True:
+                data = await self.queue.get()
+                self.m_processor_queue.set(self.queue.qsize())
+                with self.m_processor_queue_in_progress.track_inprogress():
                    try:
-                        await self.processor.push(data)
-                    except Exception:
-                        self.logger.error(
-                            f"Error in push {self.processor.__class__.__name__}"
-                            ", continue"
-                        )
-                finally:
-                    self.queue.task_done()
+                        if data is None:
+                            await self.processor.flush()
+                            break
+                        try:
+                            await self.processor.push(data)
+                        except Exception:
+                            self.logger.error(
+                                f"Error in push {self.processor.__class__.__name__}"
+                                ", continue"
+                            )
+                    finally:
+                        self.queue.task_done()
+        except Exception as e:
+            logger.error(f"Crash in {self.__class__.__name__}: {e}", exc_info=e)
+
+    async def _ensure_task(self):
+        if self.task is None:
+            self.task = asyncio.get_running_loop().create_task(self.loop())
+
+        # XXX not doing a sleep here make the whole pipeline prior the thread
+        # to be running without having a chance to work on the task here.
+        await asyncio.sleep(0)

    async def _push(self, data):
+        await self._ensure_task()
        await self.queue.put(data)

    async def _flush(self):
--- a/server/reflector/processors/file_diarization.py
+++ b/server/reflector/processors/file_diarization.py
@@ -0,0 +1,33 @@
+from pydantic import BaseModel
+
+from reflector.processors.base import Processor
+from reflector.processors.types import DiarizationSegment
+
+
+class FileDiarizationInput(BaseModel):
+    """Input for file diarization containing audio URL"""
+
+    audio_url: str
+
+
+class FileDiarizationOutput(BaseModel):
+    """Output for file diarization containing speaker segments"""
+
+    diarization: list[DiarizationSegment]
+
+
+class FileDiarizationProcessor(Processor):
+    """
+    Diarize complete audio files from URL
+    """
+
+    INPUT_TYPE = FileDiarizationInput
+    OUTPUT_TYPE = FileDiarizationOutput
+
+    async def _push(self, data: FileDiarizationInput):
+        result = await self._diarize(data)
+        if result:
+            await self.emit(result)
+
+    async def _diarize(self, data: FileDiarizationInput):
+        raise NotImplementedError
--- a/server/reflector/processors/file_diarization_auto.py
+++ b/server/reflector/processors/file_diarization_auto.py
@@ -0,0 +1,33 @@
+import importlib
+
+from reflector.processors.file_diarization import FileDiarizationProcessor
+from reflector.settings import settings
+
+
+class FileDiarizationAutoProcessor(FileDiarizationProcessor):
+    _registry = {}
+
+    @classmethod
+    def register(cls, name, kclass):
+        cls._registry[name] = kclass
+
+    def __new__(cls, name: str | None = None, **kwargs):
+        if name is None:
+            name = settings.DIARIZATION_BACKEND
+
+        if name not in cls._registry:
+            module_name = f"reflector.processors.file_diarization_{name}"
+            importlib.import_module(module_name)
+
+        # gather specific configuration for the processor
+        # search `DIARIZATION_BACKEND_XXX_YYY`, push to constructor as `backend_xxx_yyy`
+        config = {}
+        name_upper = name.upper()
+        settings_prefix = "DIARIZATION_"
+        config_prefix = f"{settings_prefix}{name_upper}_"
+        for key, value in settings:
+            if key.startswith(config_prefix):
+                config_name = key[len(settings_prefix) :].lower()
+                config[config_name] = value
+
+        return cls._registry[name](**config | kwargs)
--- a/server/reflector/processors/file_diarization_modal.py
+++ b/server/reflector/processors/file_diarization_modal.py
@@ -0,0 +1,57 @@
+"""
+File diarization implementation using the GPU service from modal.com
+
+API will be a POST request to DIARIZATION_URL:
+
+```
+POST /diarize?audio_file_url=...&timestamp=0
+Authorization: Bearer <modal_api_key>
+```
+"""
+
+import httpx
+
+from reflector.processors.file_diarization import (
+    FileDiarizationInput,
+    FileDiarizationOutput,
+    FileDiarizationProcessor,
+)
+from reflector.processors.file_diarization_auto import FileDiarizationAutoProcessor
+from reflector.settings import settings
+
+
+class FileDiarizationModalProcessor(FileDiarizationProcessor):
+    def __init__(self, modal_api_key: str | None = None, **kwargs):
+        super().__init__(**kwargs)
+        if not settings.DIARIZATION_URL:
+            raise Exception(
+                "DIARIZATION_URL required to use FileDiarizationModalProcessor"
+            )
+        self.diarization_url = settings.DIARIZATION_URL + "/diarize"
+        self.file_timeout = settings.DIARIZATION_FILE_TIMEOUT
+        self.modal_api_key = modal_api_key
+
+    async def _diarize(self, data: FileDiarizationInput):
+        """Get speaker diarization for file"""
+        self.logger.info(f"Starting diarization from {data.audio_url}")
+
+        headers = {}
+        if self.modal_api_key:
+            headers["Authorization"] = f"Bearer {self.modal_api_key}"
+
+        async with httpx.AsyncClient(timeout=self.file_timeout) as client:
+            response = await client.post(
+                self.diarization_url,
+                headers=headers,
+                params={
+                    "audio_file_url": data.audio_url,
+                    "timestamp": 0,
+                },
+            )
+            response.raise_for_status()
+            diarization_data = response.json()["diarization"]
+
+        return FileDiarizationOutput(diarization=diarization_data)
+
+
+FileDiarizationAutoProcessor.register("modal", FileDiarizationModalProcessor)
--- a/server/reflector/processors/file_transcript.py
+++ b/server/reflector/processors/file_transcript.py
@@ -0,0 +1,65 @@
+from prometheus_client import Counter, Histogram
+
+from reflector.processors.base import Processor
+from reflector.processors.types import Transcript
+
+
+class FileTranscriptInput:
+    """Input for file transcription containing audio URL and language settings"""
+
+    def __init__(self, audio_url: str, language: str = "en"):
+        self.audio_url = audio_url
+        self.language = language
+
+
+class FileTranscriptProcessor(Processor):
+    """
+    Transcript complete audio files from URL
+    """
+
+    INPUT_TYPE = FileTranscriptInput
+    OUTPUT_TYPE = Transcript
+
+    m_transcript = Histogram(
+        "file_transcript",
+        "Time spent in FileTranscript.transcript",
+        ["backend"],
+    )
+    m_transcript_call = Counter(
+        "file_transcript_call",
+        "Number of calls to FileTranscript.transcript",
+        ["backend"],
+    )
+    m_transcript_success = Counter(
+        "file_transcript_success",
+        "Number of successful calls to FileTranscript.transcript",
+        ["backend"],
+    )
+    m_transcript_failure = Counter(
+        "file_transcript_failure",
+        "Number of failed calls to FileTranscript.transcript",
+        ["backend"],
+    )
+
+    def __init__(self, *args, **kwargs):
+        name = self.__class__.__name__
+        self.m_transcript = self.m_transcript.labels(name)
+        self.m_transcript_call = self.m_transcript_call.labels(name)
+        self.m_transcript_success = self.m_transcript_success.labels(name)
+        self.m_transcript_failure = self.m_transcript_failure.labels(name)
+        super().__init__(*args, **kwargs)
+
+    async def _push(self, data: FileTranscriptInput):
+        try:
+            self.m_transcript_call.inc()
+            with self.m_transcript.time():
+                result = await self._transcript(data)
+            self.m_transcript_success.inc()
+            if result:
+                await self.emit(result)
+        except Exception:
+            self.m_transcript_failure.inc()
+            raise
+
+    async def _transcript(self, data: FileTranscriptInput):
+        raise NotImplementedError
--- a/server/reflector/processors/file_transcript_auto.py
+++ b/server/reflector/processors/file_transcript_auto.py
@@ -0,0 +1,32 @@
+import importlib
+
+from reflector.processors.file_transcript import FileTranscriptProcessor
+from reflector.settings import settings
+
+
+class FileTranscriptAutoProcessor(FileTranscriptProcessor):
+    _registry = {}
+
+    @classmethod
+    def register(cls, name, kclass):
+        cls._registry[name] = kclass
+
+    def __new__(cls, name: str | None = None, **kwargs):
+        if name is None:
+            name = settings.TRANSCRIPT_BACKEND
+        if name not in cls._registry:
+            module_name = f"reflector.processors.file_transcript_{name}"
+            importlib.import_module(module_name)
+
+        # gather specific configuration for the processor
+        # search `TRANSCRIPT_BACKEND_XXX_YYY`, push to constructor as `backend_xxx_yyy`
+        config = {}
+        name_upper = name.upper()
+        settings_prefix = "TRANSCRIPT_"
+        config_prefix = f"{settings_prefix}{name_upper}_"
+        for key, value in settings:
+            if key.startswith(config_prefix):
+                config_name = key[len(settings_prefix) :].lower()
+                config[config_name] = value
+
+        return cls._registry[name](**config | kwargs)
--- a/server/reflector/processors/file_transcript_modal.py
+++ b/server/reflector/processors/file_transcript_modal.py
@@ -0,0 +1,74 @@
+"""
+File transcription implementation using the GPU service from modal.com
+
+API will be a POST request to TRANSCRIPT_URL:
+
+```json
+{
+    "audio_file_url": "https://...",
+    "language": "en",
+    "model": "parakeet-tdt-0.6b-v2",
+    "batch": true
+}
+```
+"""
+
+import httpx
+
+from reflector.processors.file_transcript import (
+    FileTranscriptInput,
+    FileTranscriptProcessor,
+)
+from reflector.processors.file_transcript_auto import FileTranscriptAutoProcessor
+from reflector.processors.types import Transcript, Word
+from reflector.settings import settings
+
+
+class FileTranscriptModalProcessor(FileTranscriptProcessor):
+    def __init__(self, modal_api_key: str | None = None, **kwargs):
+        super().__init__(**kwargs)
+        if not settings.TRANSCRIPT_URL:
+            raise Exception(
+                "TRANSCRIPT_URL required to use FileTranscriptModalProcessor"
+            )
+        self.transcript_url = settings.TRANSCRIPT_URL
+        self.file_timeout = settings.TRANSCRIPT_FILE_TIMEOUT
+        self.modal_api_key = modal_api_key
+
+    async def _transcript(self, data: FileTranscriptInput):
+        """Send full file to Modal for transcription"""
+        url = f"{self.transcript_url}/v1/audio/transcriptions-from-url"
+
+        self.logger.info(f"Starting file transcription from {data.audio_url}")
+
+        headers = {}
+        if self.modal_api_key:
+            headers["Authorization"] = f"Bearer {self.modal_api_key}"
+
+        async with httpx.AsyncClient(timeout=self.file_timeout) as client:
+            response = await client.post(
+                url,
+                headers=headers,
+                json={
+                    "audio_file_url": data.audio_url,
+                    "language": data.language,
+                    "batch": True,
+                },
+            )
+            response.raise_for_status()
+            result = response.json()
+
+        words = [
+            Word(
+                text=word_info["word"],
+                start=word_info["start"],
+                end=word_info["end"],
+            )
+            for word_info in result.get("words", [])
+        ]
+
+        return Transcript(words=words)
+
+
+# Register with the auto processor
+FileTranscriptAutoProcessor.register("modal", FileTranscriptModalProcessor)
--- a/server/reflector/processors/summary/summary_builder.py
+++ b/server/reflector/processors/summary/summary_builder.py
@@ -6,7 +6,7 @@ This script is used to generate a summary of a meeting notes transcript.

 import asyncio
 import sys
-from datetime import datetime
+from datetime import datetime, timezone
 from enum import Enum
 from textwrap import dedent
 from typing import Type, TypeVar
@@ -474,7 +474,7 @@ if __name__ == "__main__":

        if args.save:
            # write the summary to a file, on the format summary-<iso date>.md
-            filename = f"summary-{datetime.now().isoformat()}.md"
+            filename = f"summary-{datetime.now(timezone.utc).isoformat()}.md"
            with open(filename, "w", encoding="utf-8") as f:
                f.write(sm.as_markdown())

--- a/server/reflector/processors/transcript_diarization_assembler.py
+++ b/server/reflector/processors/transcript_diarization_assembler.py
@@ -0,0 +1,45 @@
+"""
+Processor to assemble transcript with diarization results
+"""
+
+from reflector.processors.audio_diarization import AudioDiarizationProcessor
+from reflector.processors.base import Processor
+from reflector.processors.types import DiarizationSegment, Transcript
+
+
+class TranscriptDiarizationAssemblerInput:
+    """Input containing transcript and diarization data"""
+
+    def __init__(self, transcript: Transcript, diarization: list[DiarizationSegment]):
+        self.transcript = transcript
+        self.diarization = diarization
+
+
+class TranscriptDiarizationAssemblerProcessor(Processor):
+    """
+    Assemble transcript with diarization results by applying speaker assignments
+    """
+
+    INPUT_TYPE = TranscriptDiarizationAssemblerInput
+    OUTPUT_TYPE = Transcript
+
+    async def _push(self, data: TranscriptDiarizationAssemblerInput):
+        result = await self._assemble(data)
+        if result:
+            await self.emit(result)
+
+    async def _assemble(self, data: TranscriptDiarizationAssemblerInput):
+        """Apply diarization to transcript words"""
+        if not data.diarization:
+            self.logger.info(
+                "No diarization data provided, returning original transcript"
+            )
+            return data.transcript
+
+        # Reuse logic from AudioDiarizationProcessor
+        processor = AudioDiarizationProcessor()
+        words = data.transcript.words
+        processor.assign_speaker(words, data.diarization)
+
+        self.logger.info(f"Applied diarization to {len(words)} words")
+        return data.transcript
--- a/server/reflector/processors/transcript_translator.py
+++ b/server/reflector/processors/transcript_translator.py
@@ -1,9 +1,5 @@
-import httpx
-
 from reflector.processors.base import Processor
-from reflector.processors.types import Transcript, TranslationLanguages
-from reflector.settings import settings
-from reflector.utils.retry import retry
+from reflector.processors.types import Transcript


 class TranscriptTranslatorProcessor(Processor):
@@ -17,56 +13,23 @@ class TranscriptTranslatorProcessor(Processor):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.transcript = None
-        self.translate_url = settings.TRANSLATE_URL
-        self.timeout = settings.TRANSLATE_TIMEOUT
-        self.headers = {"Authorization": f"Bearer {settings.TRANSCRIPT_MODAL_API_KEY}"}

    async def _push(self, data: Transcript):
        self.transcript = data
        await self.flush()

-    async def get_translation(self, text: str) -> str | None:
-        # FIXME this should be a processor after, as each user may want
-        # different languages
-
-        source_language = self.get_pref("audio:source_language", "en")
-        target_language = self.get_pref("audio:target_language", "en")
-        if source_language == target_language:
-            return
-
-        languages = TranslationLanguages()
-        # Only way to set the target should be the UI element like dropdown.
-        # Hence, this assert should never fail.
-        assert languages.is_supported(target_language)
-        self.logger.debug(f"Try to translate {text=}")
-        json_payload = {
-            "text": text,
-            "source_language": source_language,
-            "target_language": target_language,
-        }
-
-        async with httpx.AsyncClient() as client:
-            response = await retry(client.post)(
-                self.translate_url + "/translate",
-                headers=self.headers,
-                params=json_payload,
-                timeout=self.timeout,
-                follow_redirects=True,
-                logger=self.logger,
-            )
-            response.raise_for_status()
-            result = response.json()["text"]
-
-            # Sanity check for translation status in the result
-            if target_language in result:
-                translation = result[target_language]
-            self.logger.debug(f"Translation response: {text=}, {translation=}")
-        return translation
+    async def _translate(self, text: str) -> str | None:
+        raise NotImplementedError

    async def _flush(self):
        if not self.transcript:
            return
-        self.transcript.translation = await self.get_translation(
-            text=self.transcript.text
-        )
+
+        source_language = self.get_pref("audio:source_language", "en")
+        target_language = self.get_pref("audio:target_language", "en")
+        if source_language == target_language:
+            self.transcript.translation = None
+        else:
+            self.transcript.translation = await self._translate(self.transcript.text)
+
        await self.emit(self.transcript)
--- a/server/reflector/processors/transcript_translator_auto.py
+++ b/server/reflector/processors/transcript_translator_auto.py
@@ -0,0 +1,32 @@
+import importlib
+
+from reflector.processors.transcript_translator import TranscriptTranslatorProcessor
+from reflector.settings import settings
+
+
+class TranscriptTranslatorAutoProcessor(TranscriptTranslatorProcessor):
+    _registry = {}
+
+    @classmethod
+    def register(cls, name, kclass):
+        cls._registry[name] = kclass
+
+    def __new__(cls, name: str | None = None, **kwargs):
+        if name is None:
+            name = settings.TRANSLATION_BACKEND
+        if name not in cls._registry:
+            module_name = f"reflector.processors.transcript_translator_{name}"
+            importlib.import_module(module_name)
+
+        # gather specific configuration for the processor
+        # search `TRANSLATION_BACKEND_XXX_YYY`, push to constructor as `backend_xxx_yyy`
+        config = {}
+        name_upper = name.upper()
+        settings_prefix = "TRANSLATION_"
+        config_prefix = f"{settings_prefix}{name_upper}_"
+        for key, value in settings:
+            if key.startswith(config_prefix):
+                config_name = key[len(settings_prefix) :].lower()
+                config[config_name] = value
+
+        return cls._registry[name](**config | kwargs)
--- a/server/reflector/processors/transcript_translator_modal.py
+++ b/server/reflector/processors/transcript_translator_modal.py
@@ -0,0 +1,66 @@
+import httpx
+
+from reflector.processors.transcript_translator import TranscriptTranslatorProcessor
+from reflector.processors.transcript_translator_auto import (
+    TranscriptTranslatorAutoProcessor,
+)
+from reflector.processors.types import TranslationLanguages
+from reflector.settings import settings
+from reflector.utils.retry import retry
+
+
+class TranscriptTranslatorModalProcessor(TranscriptTranslatorProcessor):
+    """
+    Translate the transcript into the target language using Modal.com
+    """
+
+    def __init__(self, modal_api_key: str | None = None, **kwargs):
+        super().__init__(**kwargs)
+        if not settings.TRANSLATE_URL:
+            raise Exception(
+                "TRANSLATE_URL is required for TranscriptTranslatorModalProcessor"
+            )
+        self.translate_url = settings.TRANSLATE_URL
+        self.timeout = settings.TRANSLATE_TIMEOUT
+        self.modal_api_key = modal_api_key
+        self.headers = {}
+        if self.modal_api_key:
+            self.headers["Authorization"] = f"Bearer {self.modal_api_key}"
+
+    async def _translate(self, text: str) -> str | None:
+        source_language = self.get_pref("audio:source_language", "en")
+        target_language = self.get_pref("audio:target_language", "en")
+
+        languages = TranslationLanguages()
+        # Only way to set the target should be the UI element like dropdown.
+        # Hence, this assert should never fail.
+        assert languages.is_supported(target_language)
+        self.logger.debug(f"Try to translate {text=}")
+        json_payload = {
+            "text": text,
+            "source_language": source_language,
+            "target_language": target_language,
+        }
+
+        async with httpx.AsyncClient() as client:
+            response = await retry(client.post)(
+                self.translate_url + "/translate",
+                headers=self.headers,
+                params=json_payload,
+                timeout=self.timeout,
+                follow_redirects=True,
+                logger=self.logger,
+            )
+            response.raise_for_status()
+            result = response.json()["text"]
+
+            # Sanity check for translation status in the result
+            if target_language in result:
+                translation = result[target_language]
+            else:
+                translation = None
+            self.logger.debug(f"Translation response: {text=}, {translation=}")
+        return translation
+
+
+TranscriptTranslatorAutoProcessor.register("modal", TranscriptTranslatorModalProcessor)
--- a/server/reflector/processors/transcript_translator_passthrough.py
+++ b/server/reflector/processors/transcript_translator_passthrough.py
@@ -0,0 +1,14 @@
+from reflector.processors.transcript_translator import TranscriptTranslatorProcessor
+from reflector.processors.transcript_translator_auto import (
+    TranscriptTranslatorAutoProcessor,
+)
+
+
+class TranscriptTranslatorPassthroughProcessor(TranscriptTranslatorProcessor):
+    async def _translate(self, text: str) -> None:
+        return None
+
+
+TranscriptTranslatorAutoProcessor.register(
+    "passthrough", TranscriptTranslatorPassthroughProcessor
+)
--- a/server/reflector/processors/types.py
+++ b/server/reflector/processors/types.py
@@ -2,12 +2,22 @@ import io
 import re
 import tempfile
 from pathlib import Path
+from typing import Annotated, TypedDict

 from profanityfilter import ProfanityFilter
-from pydantic import BaseModel, PrivateAttr
+from pydantic import BaseModel, Field, PrivateAttr

 from reflector.redis_cache import redis_cache

+
+class DiarizationSegment(TypedDict):
+    """Type definition for diarization segment containing speaker information"""
+
+    start: float
+    end: float
+    speaker: int
+
+
 PUNC_RE = re.compile(r"[.;:?!…]")

 profanity_filter = ProfanityFilter()
@@ -48,20 +58,70 @@ class AudioFile(BaseModel):
            self._path.unlink()


+# non-negative seconds with float part
+Seconds = Annotated[float, Field(ge=0.0, description="Time in seconds with float part")]
+
+
 class Word(BaseModel):
    text: str
-    start: float
-    end: float
+    start: Seconds
+    end: Seconds
    speaker: int = 0


 class TranscriptSegment(BaseModel):
    text: str
-    start: float
-    end: float
+    start: Seconds
+    end: Seconds
    speaker: int = 0


+def words_to_segments(words: list[Word]) -> list[TranscriptSegment]:
+    # from a list of word, create a list of segments
+    # join the word that are less than 2 seconds apart
+    # but separate if the speaker changes, or if the punctuation is a . , ; : ? !
+    segments = []
+    current_segment = None
+    MAX_SEGMENT_LENGTH = 120
+
+    for word in words:
+        if current_segment is None:
+            current_segment = TranscriptSegment(
+                text=word.text,
+                start=word.start,
+                end=word.end,
+                speaker=word.speaker,
+            )
+            continue
+
+        # If the word is attach to another speaker, push the current segment
+        # and start a new one
+        if word.speaker != current_segment.speaker:
+            segments.append(current_segment)
+            current_segment = TranscriptSegment(
+                text=word.text,
+                start=word.start,
+                end=word.end,
+                speaker=word.speaker,
+            )
+            continue
+
+        # if the word is the end of a sentence, and we have enough content,
+        # add the word to the current segment and push it
+        current_segment.text += word.text
+        current_segment.end = word.end
+
+        have_punc = PUNC_RE.search(word.text)
+        if have_punc and (len(current_segment.text) > MAX_SEGMENT_LENGTH):
+            segments.append(current_segment)
+            current_segment = None
+
+    if current_segment:
+        segments.append(current_segment)
+
+    return segments
+
+
 class Transcript(BaseModel):
    translation: str | None = None
    words: list[Word] = None
@@ -117,49 +177,7 @@ class Transcript(BaseModel):
        return Transcript(text=self.text, translation=self.translation, words=words)

    def as_segments(self) -> list[TranscriptSegment]:
-        # from a list of word, create a list of segments
-        # join the word that are less than 2 seconds apart
-        # but separate if the speaker changes, or if the punctuation is a . , ; : ? !
-        segments = []
-        current_segment = None
-        MAX_SEGMENT_LENGTH = 120
-
-        for word in self.words:
-            if current_segment is None:
-                current_segment = TranscriptSegment(
-                    text=word.text,
-                    start=word.start,
-                    end=word.end,
-                    speaker=word.speaker,
-                )
-                continue
-
-            # If the word is attach to another speaker, push the current segment
-            # and start a new one
-            if word.speaker != current_segment.speaker:
-                segments.append(current_segment)
-                current_segment = TranscriptSegment(
-                    text=word.text,
-                    start=word.start,
-                    end=word.end,
-                    speaker=word.speaker,
-                )
-                continue
-
-            # if the word is the end of a sentence, and we have enough content,
-            # add the word to the current segment and push it
-            current_segment.text += word.text
-            current_segment.end = word.end
-
-            have_punc = PUNC_RE.search(word.text)
-            if have_punc and (len(current_segment.text) > MAX_SEGMENT_LENGTH):
-                segments.append(current_segment)
-                current_segment = None
-
-        if current_segment:
-            segments.append(current_segment)
-
-        return segments
+        return words_to_segments(self.words)


 class TitleSummary(BaseModel):
--- a/server/reflector/settings.py
+++ b/server/reflector/settings.py
@@ -14,7 +14,9 @@ class Settings(BaseSettings):
    CORS_ALLOW_CREDENTIALS: bool = False

    # Database
-    DATABASE_URL: str = "sqlite:///./reflector.sqlite3"
+    DATABASE_URL: str = (
+        "postgresql+asyncpg://reflector:reflector@localhost:5432/reflector"
+    )

    # local data directory
    DATA_DIR: str = "./data"
@@ -24,8 +26,9 @@ class Settings(BaseSettings):
    TRANSCRIPT_BACKEND: str = "whisper"
    TRANSCRIPT_URL: str | None = None
    TRANSCRIPT_TIMEOUT: int = 90
+    TRANSCRIPT_FILE_TIMEOUT: int = 600

-    # Audio transcription modal.com configuration
+    # Audio Transcription: modal backend
    TRANSCRIPT_MODAL_API_KEY: str | None = None

    # Audio transcription storage
@@ -37,10 +40,23 @@ class Settings(BaseSettings):
    TRANSCRIPT_STORAGE_AWS_ACCESS_KEY_ID: str | None = None
    TRANSCRIPT_STORAGE_AWS_SECRET_ACCESS_KEY: str | None = None

+    # Recording storage
+    RECORDING_STORAGE_BACKEND: str | None = None
+
+    # Recording storage configuration for AWS
+    RECORDING_STORAGE_AWS_BUCKET_NAME: str = "recording-bucket"
+    RECORDING_STORAGE_AWS_REGION: str = "us-east-1"
+    RECORDING_STORAGE_AWS_ACCESS_KEY_ID: str | None = None
+    RECORDING_STORAGE_AWS_SECRET_ACCESS_KEY: str | None = None
+
    # Translate into the target language
+    TRANSLATION_BACKEND: str = "passthrough"
    TRANSLATE_URL: str | None = None
    TRANSLATE_TIMEOUT: int = 90

+    # Translation: modal backend
+    TRANSLATE_MODAL_API_KEY: str | None = None
+
    # LLM
    LLM_MODEL: str = "microsoft/phi-4"
    LLM_URL: str | None = None
@@ -51,6 +67,13 @@ class Settings(BaseSettings):
    DIARIZATION_ENABLED: bool = True
    DIARIZATION_BACKEND: str = "modal"
    DIARIZATION_URL: str | None = None
+    DIARIZATION_FILE_TIMEOUT: int = 600
+
+    # Diarization: modal backend
+    DIARIZATION_MODAL_API_KEY: str | None = None
+
+    # Diarization: local pyannote.audio
+    DIARIZATION_PYANNOTE_AUTH_TOKEN: str | None = None

    # Sentry
    SENTRY_DSN: str | None = None
@@ -95,25 +118,11 @@ class Settings(BaseSettings):
    WHEREBY_API_URL: str = "https://api.whereby.dev/v1"
    WHEREBY_API_KEY: str | None = None
    WHEREBY_WEBHOOK_SECRET: str | None = None
-    AWS_WHEREBY_S3_BUCKET: str | None = None
    AWS_WHEREBY_ACCESS_KEY_ID: str | None = None
    AWS_WHEREBY_ACCESS_KEY_SECRET: str | None = None
    AWS_PROCESS_RECORDING_QUEUE_URL: str | None = None
    SQS_POLLING_TIMEOUT_SECONDS: int = 60

-    # Daily.co integration
-    DAILY_API_KEY: str | None = None
-    DAILY_WEBHOOK_SECRET: str | None = None
-    DAILY_SUBDOMAIN: str | None = None
-    AWS_DAILY_S3_BUCKET: str | None = None
-    AWS_DAILY_S3_REGION: str = "us-west-2"
-    AWS_DAILY_ROLE_ARN: str | None = None
-
-    # Video platform migration feature flags
-    DAILY_MIGRATION_ENABLED: bool = True
-    DAILY_MIGRATION_ROOM_IDS: list[str] = []
-    DEFAULT_VIDEO_PLATFORM: str = "daily"
-
    # Zulip integration
    ZULIP_REALM: str | None = None
    ZULIP_API_KEY: str | None = None
--- a/server/reflector/storage/init.py
+++ b/server/reflector/storage/init.py
@@ -1,10 +1,17 @@
 from .base import Storage  # noqa
+from reflector.settings import settings


 def get_transcripts_storage() -> Storage:
-    from reflector.settings import settings
-
+    assert settings.TRANSCRIPT_STORAGE_BACKEND
    return Storage.get_instance(
        name=settings.TRANSCRIPT_STORAGE_BACKEND,
        settings_prefix="TRANSCRIPT_STORAGE_",
    )
+
+
+def get_recordings_storage() -> Storage:
+    return Storage.get_instance(
+        name=settings.RECORDING_STORAGE_BACKEND,
+        settings_prefix="RECORDING_STORAGE_",
+    )
--- a/server/reflector/tools/exportdanswer.py
+++ b/server/reflector/tools/exportdanswer.py
@@ -9,8 +9,9 @@ async def export_db(filename: str) -> None:
    filename = pathlib.Path(filename).resolve()
    settings.DATABASE_URL = f"sqlite:///{filename}"

-    from reflector.db import database, transcripts
+    from reflector.db import get_database, transcripts

+    database = get_database()
    await database.connect()
    transcripts = await database.fetch_all(transcripts.select())
    await database.disconnect()
--- a/server/reflector/tools/exportdb.py
+++ b/server/reflector/tools/exportdb.py
@@ -8,8 +8,9 @@ async def export_db(filename: str) -> None:
    filename = pathlib.Path(filename).resolve()
    settings.DATABASE_URL = f"sqlite:///{filename}"

-    from reflector.db import database, transcripts
+    from reflector.db import get_database, transcripts

+    database = get_database()
    await database.connect()
    transcripts = await database.fetch_all(transcripts.select())
    await database.disconnect()
--- a/server/reflector/tools/process.py
+++ b/server/reflector/tools/process.py
@@ -1,10 +1,23 @@
+"""
+Process audio file with diarization support
+===========================================
+
+Extended version of process.py that includes speaker diarization.
+This tool processes audio files locally without requiring the full server infrastructure.
+"""
+
 import asyncio
+import tempfile
+import uuid
+from pathlib import Path
+from typing import List

 import av

 from reflector.logger import logger
 from reflector.processors import (
    AudioChunkerProcessor,
+    AudioFileWriterProcessor,
    AudioMergeProcessor,
    AudioTranscriptAutoProcessor,
    Pipeline,
@@ -13,9 +26,45 @@ from reflector.processors import (
    TranscriptFinalTitleProcessor,
    TranscriptLinerProcessor,
    TranscriptTopicDetectorProcessor,
-    TranscriptTranslatorProcessor,
+    TranscriptTranslatorAutoProcessor,
 )
-from reflector.processors.base import BroadcastProcessor
+from reflector.processors.base import BroadcastProcessor, Processor
+from reflector.processors.types import (
+    AudioDiarizationInput,
+    TitleSummary,
+    TitleSummaryWithId,
+)
+
+
+class TopicCollectorProcessor(Processor):
+    """Collect topics for diarization"""
+
+    INPUT_TYPE = TitleSummary
+    OUTPUT_TYPE = TitleSummary
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.topics: List[TitleSummaryWithId] = []
+        self._topic_id = 0
+
+    async def _push(self, data: TitleSummary):
+        # Convert to TitleSummaryWithId and collect
+        self._topic_id += 1
+        topic_with_id = TitleSummaryWithId(
+            id=str(self._topic_id),
+            title=data.title,
+            summary=data.summary,
+            timestamp=data.timestamp,
+            duration=data.duration,
+            transcript=data.transcript,
+        )
+        self.topics.append(topic_with_id)
+
+        # Pass through the original topic
+        await self.emit(data)
+
+    def get_topics(self) -> List[TitleSummaryWithId]:
+        return self.topics


 async def process_audio_file(
@@ -24,18 +73,40 @@ async def process_audio_file(
    only_transcript=False,
    source_language="en",
    target_language="en",
+    enable_diarization=True,
+    diarization_backend="pyannote",
 ):
-    # build pipeline for audio processing
-    processors = [
+    # Create temp file for audio if diarization is enabled
+    audio_temp_path = None
+    if enable_diarization:
+        audio_temp_file = tempfile.NamedTemporaryFile(suffix=".wav", delete=False)
+        audio_temp_path = audio_temp_file.name
+        audio_temp_file.close()
+
+    # Create processor for collecting topics
+    topic_collector = TopicCollectorProcessor()
+
+    # Build pipeline for audio processing
+    processors = []
+
+    # Add audio file writer at the beginning if diarization is enabled
+    if enable_diarization:
+        processors.append(AudioFileWriterProcessor(audio_temp_path))
+
+    # Add the rest of the processors
+    processors += [
        AudioChunkerProcessor(),
        AudioMergeProcessor(),
        AudioTranscriptAutoProcessor.as_threaded(),
        TranscriptLinerProcessor(),
-        TranscriptTranslatorProcessor.as_threaded(),
+        TranscriptTranslatorAutoProcessor.as_threaded(),
    ]
+
    if not only_transcript:
        processors += [
            TranscriptTopicDetectorProcessor.as_threaded(),
+            # Collect topics for diarization
+            topic_collector,
            BroadcastProcessor(
                processors=[
                    TranscriptFinalTitleProcessor.as_threaded(),
@@ -44,14 +115,14 @@ async def process_audio_file(
            ),
        ]

-    # transcription output
+    # Create main pipeline
    pipeline = Pipeline(*processors)
    pipeline.set_pref("audio:source_language", source_language)
    pipeline.set_pref("audio:target_language", target_language)
    pipeline.describe()
    pipeline.on(event_callback)

-    # start processing audio
+    # Start processing audio
    logger.info(f"Opening {filename}")
    container = av.open(filename)
    try:
@@ -62,43 +133,242 @@ async def process_audio_file(
        logger.info("Flushing the pipeline")
        await pipeline.flush()

-    logger.info("All done !")
+    # Run diarization if enabled and we have topics
+    if enable_diarization and not only_transcript and audio_temp_path:
+        topics = topic_collector.get_topics()
+
+        if topics:
+            logger.info(f"Starting diarization with {len(topics)} topics")
+
+            try:
+                from reflector.processors import AudioDiarizationAutoProcessor
+
+                diarization_processor = AudioDiarizationAutoProcessor(
+                    name=diarization_backend
+                )
+
+                diarization_processor.set_pipeline(pipeline)
+
+                # For Modal backend, we need to upload the file to S3 first
+                if diarization_backend == "modal":
+                    from datetime import datetime
+
+                    from reflector.storage import get_transcripts_storage
+                    from reflector.utils.s3_temp_file import S3TemporaryFile
+
+                    storage = get_transcripts_storage()
+
+                    # Generate a unique filename in evaluation folder
+                    timestamp = datetime.utcnow().strftime("%Y%m%d_%H%M%S")
+                    audio_filename = f"evaluation/diarization_temp/{timestamp}_{uuid.uuid4().hex}.wav"
+
+                    # Use context manager for automatic cleanup
+                    async with S3TemporaryFile(storage, audio_filename) as s3_file:
+                        # Read and upload the audio file
+                        with open(audio_temp_path, "rb") as f:
+                            audio_data = f.read()
+
+                        audio_url = await s3_file.upload(audio_data)
+                        logger.info(f"Uploaded audio to S3: {audio_filename}")
+
+                        # Create diarization input with S3 URL
+                        diarization_input = AudioDiarizationInput(
+                            audio_url=audio_url, topics=topics
+                        )
+
+                        # Run diarization
+                        await diarization_processor.push(diarization_input)
+                        await diarization_processor.flush()
+
+                        logger.info("Diarization complete")
+                        # File will be automatically cleaned up when exiting the context
+                else:
+                    # For local backend, use local file path
+                    audio_url = audio_temp_path
+
+                    # Create diarization input
+                    diarization_input = AudioDiarizationInput(
+                        audio_url=audio_url, topics=topics
+                    )
+
+                    # Run diarization
+                    await diarization_processor.push(diarization_input)
+                    await diarization_processor.flush()
+
+                    logger.info("Diarization complete")
+
+            except ImportError as e:
+                logger.error(f"Failed to import diarization dependencies: {e}")
+                logger.error(
+                    "Install with: uv pip install pyannote.audio torch torchaudio"
+                )
+                logger.error(
+                    "And set HF_TOKEN environment variable for pyannote models"
+                )
+                raise SystemExit(1)
+            except Exception as e:
+                logger.error(f"Diarization failed: {e}")
+                raise SystemExit(1)
+        else:
+            logger.warning("Skipping diarization: no topics available")
+
+    # Clean up temp file
+    if audio_temp_path:
+        try:
+            Path(audio_temp_path).unlink()
+        except Exception as e:
+            logger.warning(f"Failed to clean up temp file {audio_temp_path}: {e}")
+
+    logger.info("All done!")
+
+
+async def process_file_pipeline(
+    filename: str,
+    event_callback,
+    source_language="en",
+    target_language="en",
+    enable_diarization=True,
+    diarization_backend="modal",
+):
+    """Process audio/video file using the optimized file pipeline"""
+    try:
+        from reflector.db import database
+        from reflector.db.transcripts import SourceKind, transcripts_controller
+        from reflector.pipelines.main_file_pipeline import PipelineMainFile
+
+        await database.connect()
+        try:
+            # Create a temporary transcript for processing
+            transcript = await transcripts_controller.add(
+                "",
+                source_kind=SourceKind.FILE,
+                source_language=source_language,
+                target_language=target_language,
+            )
+
+            # Process the file
+            pipeline = PipelineMainFile(transcript_id=transcript.id)
+            await pipeline.process(Path(filename))
+
+            logger.info("File pipeline processing complete")
+
+        finally:
+            await database.disconnect()
+    except ImportError as e:
+        logger.error(f"File pipeline not available: {e}")
+        logger.info("Falling back to stream pipeline")
+        # Fall back to stream pipeline
+        await process_audio_file(
+            filename,
+            event_callback,
+            only_transcript=False,
+            source_language=source_language,
+            target_language=target_language,
+            enable_diarization=enable_diarization,
+            diarization_backend=diarization_backend,
+        )


 if __name__ == "__main__":
    import argparse
+    import os

-    parser = argparse.ArgumentParser()
+    parser = argparse.ArgumentParser(
+        description="Process audio files with optional speaker diarization"
+    )
    parser.add_argument("source", help="Source file (mp3, wav, mp4...)")
-    parser.add_argument("--only-transcript", "-t", action="store_true")
-    parser.add_argument("--source-language", default="en")
-    parser.add_argument("--target-language", default="en")
+    parser.add_argument(
+        "--stream",
+        action="store_true",
+        help="Use streaming pipeline (original frame-based processing)",
+    )
+    parser.add_argument(
+        "--only-transcript",
+        "-t",
+        action="store_true",
+        help="Only generate transcript without topics/summaries",
+    )
+    parser.add_argument(
+        "--source-language", default="en", help="Source language code (default: en)"
+    )
+    parser.add_argument(
+        "--target-language", default="en", help="Target language code (default: en)"
+    )
    parser.add_argument("--output", "-o", help="Output file (output.jsonl)")
+    parser.add_argument(
+        "--enable-diarization",
+        "-d",
+        action="store_true",
+        help="Enable speaker diarization",
+    )
+    parser.add_argument(
+        "--diarization-backend",
+        default="pyannote",
+        choices=["pyannote", "modal"],
+        help="Diarization backend to use (default: pyannote)",
+    )
    args = parser.parse_args()

+    if "REDIS_HOST" not in os.environ:
+        os.environ["REDIS_HOST"] = "localhost"
+
    output_fd = None
    if args.output:
        output_fd = open(args.output, "w")

    async def event_callback(event: PipelineEvent):
        processor = event.processor
-        # ignore some processor
-        if processor in ("AudioChunkerProcessor", "AudioMergeProcessor"):
+        data = event.data
+
+        # Ignore internal processors
+        if processor in (
+            "AudioChunkerProcessor",
+            "AudioMergeProcessor",
+            "AudioFileWriterProcessor",
+            "TopicCollectorProcessor",
+            "BroadcastProcessor",
+        ):
            return
-        logger.info(f"Event: {event}")
+
+        # If diarization is enabled, skip the original topic events from the pipeline
+        # The diarization processor will emit the same topics but with speaker info
+        if processor == "TranscriptTopicDetectorProcessor" and args.enable_diarization:
+            return
+
+        # Log all events
+        logger.info(f"Event: {processor} - {type(data).__name__}")
+
+        # Write to output
        if output_fd:
            output_fd.write(event.model_dump_json())
            output_fd.write("\n")
+            output_fd.flush()

-    asyncio.run(
-        process_audio_file(
-            args.source,
-            event_callback,
-            only_transcript=args.only_transcript,
-            source_language=args.source_language,
-            target_language=args.target_language,
+    if args.stream:
+        # Use original streaming pipeline
+        asyncio.run(
+            process_audio_file(
+                args.source,
+                event_callback,
+                only_transcript=args.only_transcript,
+                source_language=args.source_language,
+                target_language=args.target_language,
+                enable_diarization=args.enable_diarization,
+                diarization_backend=args.diarization_backend,
+            )
+        )
+    else:
+        # Use optimized file pipeline (default)
+        asyncio.run(
+            process_file_pipeline(
+                args.source,
+                event_callback,
+                source_language=args.source_language,
+                target_language=args.target_language,
+                enable_diarization=args.enable_diarization,
+                diarization_backend=args.diarization_backend,
+            )
        )
-    )

    if output_fd:
        output_fd.close()
--- a/server/reflector/tools/process_with_diarization.py
+++ b/server/reflector/tools/process_with_diarization.py
@@ -27,7 +27,7 @@ from reflector.processors import (
    TranscriptFinalTitleProcessor,
    TranscriptLinerProcessor,
    TranscriptTopicDetectorProcessor,
-    TranscriptTranslatorProcessor,
+    TranscriptTranslatorAutoProcessor,
 )
 from reflector.processors.base import BroadcastProcessor, Processor
 from reflector.processors.types import (
@@ -103,7 +103,7 @@ async def process_audio_file_with_diarization(

    processors += [
        TranscriptLinerProcessor(),
-        TranscriptTranslatorProcessor.as_threaded(),
+        TranscriptTranslatorAutoProcessor.as_threaded(),
    ]

    if not only_transcript:
@@ -145,18 +145,17 @@ async def process_audio_file_with_diarization(
            logger.info(f"Starting diarization with {len(topics)} topics")

            try:
-                # Import diarization processor
                from reflector.processors import AudioDiarizationAutoProcessor

-                # Create diarization processor
                diarization_processor = AudioDiarizationAutoProcessor(
                    name=diarization_backend
                )
-                diarization_processor.on(event_callback)
+
+                diarization_processor.set_pipeline(pipeline)

                # For Modal backend, we need to upload the file to S3 first
                if diarization_backend == "modal":
-                    from datetime import datetime
+                    from datetime import datetime, timezone

                    from reflector.storage import get_transcripts_storage
                    from reflector.utils.s3_temp_file import S3TemporaryFile
@@ -164,7 +163,7 @@ async def process_audio_file_with_diarization(
                    storage = get_transcripts_storage()

                    # Generate a unique filename in evaluation folder
-                    timestamp = datetime.utcnow().strftime("%Y%m%d_%H%M%S")
+                    timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
                    audio_filename = f"evaluation/diarization_temp/{timestamp}_{uuid.uuid4().hex}.wav"

                    # Use context manager for automatic cleanup
--- a/server/reflector/utils/webvtt.py
+++ b/server/reflector/utils/webvtt.py
@@ -0,0 +1,63 @@
+"""WebVTT utilities for generating subtitle files from transcript data."""
+
+from typing import TYPE_CHECKING, Annotated
+
+import webvtt
+
+from reflector.processors.types import Seconds, Word, words_to_segments
+
+if TYPE_CHECKING:
+    from reflector.db.transcripts import TranscriptTopic
+
+VttTimestamp = Annotated[str, "vtt_timestamp"]
+WebVTTStr = Annotated[str, "webvtt_str"]
+
+
+def _seconds_to_timestamp(seconds: Seconds) -> VttTimestamp:
+    # lib doesn't do that
+    hours = int(seconds // 3600)
+    minutes = int((seconds % 3600) // 60)
+    secs = int(seconds % 60)
+    milliseconds = int((seconds % 1) * 1000)
+
+    return f"{hours:02d}:{minutes:02d}:{secs:02d}.{milliseconds:03d}"
+
+
+def words_to_webvtt(words: list[Word]) -> WebVTTStr:
+    """Convert words to WebVTT using existing segmentation logic."""
+    vtt = webvtt.WebVTT()
+    if not words:
+        return vtt.content
+
+    segments = words_to_segments(words)
+
+    for segment in segments:
+        text = segment.text.strip()
+        # lib doesn't do that
+        text = f"<v Speaker{segment.speaker}>{text}"
+
+        caption = webvtt.Caption(
+            start=_seconds_to_timestamp(segment.start),
+            end=_seconds_to_timestamp(segment.end),
+            text=text,
+        )
+        vtt.captions.append(caption)
+
+    return vtt.content
+
+
+def topics_to_webvtt(topics: list["TranscriptTopic"]) -> WebVTTStr:
+    if not topics:
+        return webvtt.WebVTT().content
+
+    all_words: list[Word] = []
+    for topic in topics:
+        all_words.extend(topic.words)
+
+    # assert it's in sequence
+    for i in range(len(all_words) - 1):
+        assert (
+            all_words[i].start <= all_words[i + 1].start
+        ), f"Words are not in sequence: {all_words[i].text} and {all_words[i + 1].text} are not consecutive: {all_words[i].start} > {all_words[i + 1].start}"
+
+    return words_to_webvtt(all_words)
--- a/server/reflector/video_platforms/init.py
+++ b/server/reflector/video_platforms/init.py
@@ -1,17 +0,0 @@
-# Video Platform Abstraction Layer
-"""
-This module provides an abstraction layer for different video conferencing platforms.
-It allows seamless switching between providers (Whereby, Daily.co, etc.) without
-changing the core application logic.
-"""
-
-from .base import MeetingData, VideoPlatformClient, VideoPlatformConfig
-from .registry import get_platform_client, register_platform
-
-__all__ = [
-    "VideoPlatformClient",
-    "VideoPlatformConfig",
-    "MeetingData",
-    "get_platform_client",
-    "register_platform",
-]
--- a/server/reflector/video_platforms/base.py
+++ b/server/reflector/video_platforms/base.py
@@ -1,82 +0,0 @@
-from abc import ABC, abstractmethod
-from datetime import datetime
-from typing import Any, Dict, Optional
-
-from pydantic import BaseModel
-
-from reflector.db.rooms import Room
-
-
-class MeetingData(BaseModel):
-    """Standardized meeting data returned by all platforms."""
-
-    meeting_id: str
-    room_name: str
-    room_url: str
-    host_room_url: str
-    platform: str
-    extra_data: Dict[str, Any] = {}  # Platform-specific data
-
-
-class VideoPlatformConfig(BaseModel):
-    """Configuration for a video platform."""
-
-    api_key: str
-    webhook_secret: str
-    api_url: Optional[str] = None
-    subdomain: Optional[str] = None
-    s3_bucket: Optional[str] = None
-    s3_region: Optional[str] = None
-    aws_role_arn: Optional[str] = None
-    aws_access_key_id: Optional[str] = None
-    aws_access_key_secret: Optional[str] = None
-
-
-class VideoPlatformClient(ABC):
-    """Abstract base class for video platform integrations."""
-
-    PLATFORM_NAME: str = ""
-
-    def __init__(self, config: VideoPlatformConfig):
-        self.config = config
-
-    @abstractmethod
-    async def create_meeting(
-        self, room_name_prefix: str, end_date: datetime, room: Room
-    ) -> MeetingData:
-        """Create a new meeting room."""
-        pass
-
-    @abstractmethod
-    async def get_room_sessions(self, room_name: str) -> Dict[str, Any]:
-        """Get session information for a room."""
-        pass
-
-    @abstractmethod
-    async def delete_room(self, room_name: str) -> bool:
-        """Delete a room. Returns True if successful."""
-        pass
-
-    @abstractmethod
-    async def upload_logo(self, room_name: str, logo_path: str) -> bool:
-        """Upload a logo to the room. Returns True if successful."""
-        pass
-
-    @abstractmethod
-    def verify_webhook_signature(
-        self, body: bytes, signature: str, timestamp: Optional[str] = None
-    ) -> bool:
-        """Verify webhook signature for security."""
-        pass
-
-    def format_recording_config(self, room: Room) -> Dict[str, Any]:
-        """Format recording configuration for the platform.
-        Can be overridden by specific implementations."""
-        if room.recording_type == "cloud" and self.config.s3_bucket:
-            return {
-                "type": room.recording_type,
-                "bucket": self.config.s3_bucket,
-                "region": self.config.s3_region,
-                "trigger": room.recording_trigger,
-            }
-        return {"type": room.recording_type}
--- a/server/reflector/video_platforms/daily.py
+++ b/server/reflector/video_platforms/daily.py
@@ -1,127 +0,0 @@
-import hmac
-from datetime import datetime
-from hashlib import sha256
-from typing import Any, Dict, Optional
-
-import httpx
-
-from reflector.db.rooms import Room
-
-from .base import MeetingData, VideoPlatformClient, VideoPlatformConfig
-
-
-class DailyClient(VideoPlatformClient):
-    """Daily.co video platform implementation."""
-
-    PLATFORM_NAME = "daily"
-    TIMEOUT = 10  # seconds
-    BASE_URL = "https://api.daily.co/v1"
-
-    def __init__(self, config: VideoPlatformConfig):
-        super().__init__(config)
-        self.headers = {
-            "Authorization": f"Bearer {config.api_key}",
-            "Content-Type": "application/json",
-        }
-
-    async def create_meeting(
-        self, room_name_prefix: str, end_date: datetime, room: Room
-    ) -> MeetingData:
-        """Create a Daily.co room."""
-        room_name = f"{room_name_prefix}-{datetime.now().strftime('%Y%m%d%H%M%S')}"
-
-        data = {
-            "name": room_name,
-            "privacy": "private" if room.is_locked else "public",
-            "properties": {
-                "enable_recording": room.recording_type
-                if room.recording_type != "none"
-                else False,
-                "enable_chat": True,
-                "enable_screenshare": True,
-                "start_video_off": False,
-                "start_audio_off": False,
-                "exp": int(end_date.timestamp()),
-            },
-        }
-
-        # Configure S3 bucket for cloud recordings
-        if room.recording_type == "cloud" and self.config.s3_bucket:
-            data["properties"]["recordings_bucket"] = {
-                "bucket_name": self.config.s3_bucket,
-                "bucket_region": self.config.s3_region,
-                "assume_role_arn": self.config.aws_role_arn,
-                "allow_api_access": True,
-            }
-
-        async with httpx.AsyncClient() as client:
-            response = await client.post(
-                f"{self.BASE_URL}/rooms",
-                headers=self.headers,
-                json=data,
-                timeout=self.TIMEOUT,
-            )
-            response.raise_for_status()
-            result = response.json()
-
-        # Format response to match our standard
-        room_url = result["url"]
-
-        return MeetingData(
-            meeting_id=result["id"],
-            room_name=result["name"],
-            room_url=room_url,
-            host_room_url=room_url,
-            platform=self.PLATFORM_NAME,
-            extra_data=result,
-        )
-
-    async def get_room_sessions(self, room_name: str) -> Dict[str, Any]:
-        """Get Daily.co room information."""
-        async with httpx.AsyncClient() as client:
-            response = await client.get(
-                f"{self.BASE_URL}/rooms/{room_name}",
-                headers=self.headers,
-                timeout=self.TIMEOUT,
-            )
-            response.raise_for_status()
-            return response.json()
-
-    async def get_room_presence(self, room_name: str) -> Dict[str, Any]:
-        """Get real-time participant data - Daily.co specific feature."""
-        async with httpx.AsyncClient() as client:
-            response = await client.get(
-                f"{self.BASE_URL}/rooms/{room_name}/presence",
-                headers=self.headers,
-                timeout=self.TIMEOUT,
-            )
-            response.raise_for_status()
-            return response.json()
-
-    async def delete_room(self, room_name: str) -> bool:
-        """Delete a Daily.co room."""
-        async with httpx.AsyncClient() as client:
-            response = await client.delete(
-                f"{self.BASE_URL}/rooms/{room_name}",
-                headers=self.headers,
-                timeout=self.TIMEOUT,
-            )
-            # Daily.co returns 200 for success, 404 if room doesn't exist
-            return response.status_code in (200, 404)
-
-    async def upload_logo(self, room_name: str, logo_path: str) -> bool:
-        """Daily.co doesn't support custom logos per room - this is a no-op."""
-        return True
-
-    def verify_webhook_signature(
-        self, body: bytes, signature: str, timestamp: Optional[str] = None
-    ) -> bool:
-        """Verify Daily.co webhook signature."""
-        expected = hmac.new(
-            self.config.webhook_secret.encode(), body, sha256
-        ).hexdigest()
-
-        try:
-            return hmac.compare_digest(expected, signature)
-        except Exception:
-            return False
--- a/server/reflector/video_platforms/factory.py
+++ b/server/reflector/video_platforms/factory.py
@@ -1,52 +0,0 @@
-"""Factory for creating video platform clients based on configuration."""
-
-from typing import Optional
-
-from reflector.settings import settings
-
-from .base import VideoPlatformClient, VideoPlatformConfig
-from .registry import get_platform_client
-
-
-def get_platform_config(platform: str) -> VideoPlatformConfig:
-    """Get configuration for a specific platform."""
-    if platform == "whereby":
-        return VideoPlatformConfig(
-            api_key=settings.WHEREBY_API_KEY or "",
-            webhook_secret=settings.WHEREBY_WEBHOOK_SECRET or "",
-            api_url=settings.WHEREBY_API_URL,
-            s3_bucket=settings.AWS_WHEREBY_S3_BUCKET,
-            aws_access_key_id=settings.AWS_WHEREBY_ACCESS_KEY_ID,
-            aws_access_key_secret=settings.AWS_WHEREBY_ACCESS_KEY_SECRET,
-        )
-    elif platform == "daily":
-        return VideoPlatformConfig(
-            api_key=settings.DAILY_API_KEY or "",
-            webhook_secret=settings.DAILY_WEBHOOK_SECRET or "",
-            subdomain=settings.DAILY_SUBDOMAIN,
-            s3_bucket=settings.AWS_DAILY_S3_BUCKET,
-            s3_region=settings.AWS_DAILY_S3_REGION,
-            aws_role_arn=settings.AWS_DAILY_ROLE_ARN,
-        )
-    else:
-        raise ValueError(f"Unknown platform: {platform}")
-
-
-def create_platform_client(platform: str) -> VideoPlatformClient:
-    """Create a video platform client instance."""
-    config = get_platform_config(platform)
-    return get_platform_client(platform, config)
-
-
-def get_platform_for_room(room_id: Optional[str] = None) -> str:
-    """Determine which platform to use for a room based on feature flags."""
-    # If Daily migration is disabled, always use Whereby
-    if not settings.DAILY_MIGRATION_ENABLED:
-        return "whereby"
-
-    # If a specific room is in the migration list, use Daily
-    if room_id and room_id in settings.DAILY_MIGRATION_ROOM_IDS:
-        return "daily"
-
-    # Otherwise use the default platform
-    return settings.DEFAULT_VIDEO_PLATFORM
--- a/server/reflector/video_platforms/mock.py
+++ b/server/reflector/video_platforms/mock.py
@@ -1,124 +0,0 @@
-"""Mock video platform client for testing."""
-
-import uuid
-from datetime import datetime
-from typing import Any, Dict, Optional
-
-from reflector.db.rooms import Room
-
-from .base import MeetingData, VideoPlatformClient, VideoPlatformConfig
-
-
-class MockPlatformClient(VideoPlatformClient):
-    """Mock video platform implementation for testing."""
-
-    PLATFORM_NAME = "mock"
-
-    def __init__(self, config: VideoPlatformConfig):
-        super().__init__(config)
-        # Store created rooms for testing
-        self._rooms: Dict[str, Dict[str, Any]] = {}
-        self._webhook_calls: list[Dict[str, Any]] = []
-
-    async def create_meeting(
-        self, room_name_prefix: str, end_date: datetime, room: Room
-    ) -> MeetingData:
-        """Create a mock meeting."""
-        meeting_id = str(uuid.uuid4())
-        room_name = f"{room_name_prefix}-{meeting_id[:8]}"
-        room_url = f"https://mock.video/{room_name}"
-        host_room_url = f"{room_url}?host=true"
-
-        # Store room data for later retrieval
-        self._rooms[room_name] = {
-            "id": meeting_id,
-            "name": room_name,
-            "url": room_url,
-            "host_url": host_room_url,
-            "end_date": end_date,
-            "room": room,
-            "participants": [],
-            "is_active": True,
-        }
-
-        return MeetingData(
-            meeting_id=meeting_id,
-            room_name=room_name,
-            room_url=room_url,
-            host_room_url=host_room_url,
-            platform=self.PLATFORM_NAME,
-            extra_data={"mock": True},
-        )
-
-    async def get_room_sessions(self, room_name: str) -> Dict[str, Any]:
-        """Get mock room session information."""
-        if room_name not in self._rooms:
-            return {"error": "Room not found"}
-
-        room_data = self._rooms[room_name]
-        return {
-            "roomName": room_name,
-            "sessions": [
-                {
-                    "sessionId": room_data["id"],
-                    "startTime": datetime.utcnow().isoformat(),
-                    "participants": room_data["participants"],
-                    "isActive": room_data["is_active"],
-                }
-            ],
-        }
-
-    async def delete_room(self, room_name: str) -> bool:
-        """Delete a mock room."""
-        if room_name in self._rooms:
-            self._rooms[room_name]["is_active"] = False
-            return True
-        return False
-
-    async def upload_logo(self, room_name: str, logo_path: str) -> bool:
-        """Mock logo upload."""
-        if room_name in self._rooms:
-            self._rooms[room_name]["logo_path"] = logo_path
-            return True
-        return False
-
-    def verify_webhook_signature(
-        self, body: bytes, signature: str, timestamp: Optional[str] = None
-    ) -> bool:
-        """Mock webhook signature verification."""
-        # For testing, accept signature == "valid"
-        return signature == "valid"
-
-    # Mock-specific methods for testing
-
-    def add_participant(
-        self, room_name: str, participant_id: str, participant_name: str
-    ):
-        """Add a participant to a mock room (for testing)."""
-        if room_name in self._rooms:
-            self._rooms[room_name]["participants"].append(
-                {
-                    "id": participant_id,
-                    "name": participant_name,
-                    "joined_at": datetime.utcnow().isoformat(),
-                }
-            )
-
-    def trigger_webhook(self, event_type: str, data: Dict[str, Any]):
-        """Trigger a mock webhook event (for testing)."""
-        self._webhook_calls.append(
-            {
-                "type": event_type,
-                "data": data,
-                "timestamp": datetime.utcnow().isoformat(),
-            }
-        )
-
-    def get_webhook_calls(self) -> list[Dict[str, Any]]:
-        """Get all webhook calls made (for testing)."""
-        return self._webhook_calls.copy()
-
-    def clear_data(self):
-        """Clear all mock data (for testing)."""
-        self._rooms.clear()
-        self._webhook_calls.clear()
--- a/server/reflector/video_platforms/registry.py
+++ b/server/reflector/video_platforms/registry.py
@@ -1,42 +0,0 @@
-from typing import Dict, Type
-
-from .base import VideoPlatformClient, VideoPlatformConfig
-
-# Registry of available video platforms
-_PLATFORMS: Dict[str, Type[VideoPlatformClient]] = {}
-
-
-def register_platform(name: str, client_class: Type[VideoPlatformClient]):
-    """Register a video platform implementation."""
-    _PLATFORMS[name.lower()] = client_class
-
-
-def get_platform_client(
-    platform: str, config: VideoPlatformConfig
-) -> VideoPlatformClient:
-    """Get a video platform client instance."""
-    platform_lower = platform.lower()
-    if platform_lower not in _PLATFORMS:
-        raise ValueError(f"Unknown video platform: {platform}")
-
-    client_class = _PLATFORMS[platform_lower]
-    return client_class(config)
-
-
-def get_available_platforms() -> list[str]:
-    """Get list of available platform names."""
-    return list(_PLATFORMS.keys())
-
-
-# Auto-register built-in platforms
-def _register_builtin_platforms():
-    from .daily import DailyClient
-    from .mock import MockPlatformClient
-    from .whereby import WherebyClient
-
-    register_platform("whereby", WherebyClient)
-    register_platform("daily", DailyClient)
-    register_platform("mock", MockPlatformClient)
-
-
-_register_builtin_platforms()
--- a/server/reflector/video_platforms/whereby.py
+++ b/server/reflector/video_platforms/whereby.py
@@ -1,140 +0,0 @@
-import hmac
-import json
-import re
-import time
-from datetime import datetime
-from hashlib import sha256
-from typing import Any, Dict, Optional
-
-import httpx
-
-from reflector.db.rooms import Room
-
-from .base import MeetingData, VideoPlatformClient, VideoPlatformConfig
-
-
-class WherebyClient(VideoPlatformClient):
-    """Whereby video platform implementation."""
-
-    PLATFORM_NAME = "whereby"
-    TIMEOUT = 10  # seconds
-    MAX_ELAPSED_TIME = 60 * 1000  # 1 minute in milliseconds
-
-    def __init__(self, config: VideoPlatformConfig):
-        super().__init__(config)
-        self.headers = {
-            "Content-Type": "application/json; charset=utf-8",
-            "Authorization": f"Bearer {config.api_key}",
-        }
-
-    async def create_meeting(
-        self, room_name_prefix: str, end_date: datetime, room: Room
-    ) -> MeetingData:
-        """Create a Whereby meeting."""
-        data = {
-            "isLocked": room.is_locked,
-            "roomNamePrefix": room_name_prefix,
-            "roomNamePattern": "uuid",
-            "roomMode": room.room_mode,
-            "endDate": end_date.isoformat(),
-            "fields": ["hostRoomUrl"],
-        }
-
-        # Add recording configuration if cloud recording is enabled
-        if room.recording_type == "cloud":
-            data["recording"] = {
-                "type": room.recording_type,
-                "destination": {
-                    "provider": "s3",
-                    "bucket": self.config.s3_bucket,
-                    "accessKeyId": self.config.aws_access_key_id,
-                    "accessKeySecret": self.config.aws_access_key_secret,
-                    "fileFormat": "mp4",
-                },
-                "startTrigger": room.recording_trigger,
-            }
-
-        async with httpx.AsyncClient() as client:
-            response = await client.post(
-                f"{self.config.api_url}/meetings",
-                headers=self.headers,
-                json=data,
-                timeout=self.TIMEOUT,
-            )
-            response.raise_for_status()
-            result = response.json()
-
-        return MeetingData(
-            meeting_id=result["meetingId"],
-            room_name=result["roomName"],
-            room_url=result["roomUrl"],
-            host_room_url=result["hostRoomUrl"],
-            platform=self.PLATFORM_NAME,
-            extra_data=result,
-        )
-
-    async def get_room_sessions(self, room_name: str) -> Dict[str, Any]:
-        """Get Whereby room session information."""
-        async with httpx.AsyncClient() as client:
-            response = await client.get(
-                f"{self.config.api_url}/insights/room-sessions?roomName={room_name}",
-                headers=self.headers,
-                timeout=self.TIMEOUT,
-            )
-            response.raise_for_status()
-            return response.json()
-
-    async def delete_room(self, room_name: str) -> bool:
-        """Whereby doesn't support room deletion - meetings expire automatically."""
-        return True
-
-    async def upload_logo(self, room_name: str, logo_path: str) -> bool:
-        """Upload logo to Whereby room."""
-        async with httpx.AsyncClient() as client:
-            with open(logo_path, "rb") as f:
-                response = await client.put(
-                    f"{self.config.api_url}/rooms/{room_name}/theme/logo",
-                    headers={
-                        "Authorization": f"Bearer {self.config.api_key}",
-                    },
-                    timeout=self.TIMEOUT,
-                    files={"image": f},
-                )
-                response.raise_for_status()
-        return True
-
-    def verify_webhook_signature(
-        self, body: bytes, signature: str, timestamp: Optional[str] = None
-    ) -> bool:
-        """Verify Whereby webhook signature."""
-        if not signature:
-            return False
-
-        matches = re.match(r"t=(.*),v1=(.*)", signature)
-        if not matches:
-            return False
-
-        ts, sig = matches.groups()
-
-        # Check timestamp to prevent replay attacks
-        current_time = int(time.time() * 1000)
-        diff_time = current_time - int(ts) * 1000
-        if diff_time >= self.MAX_ELAPSED_TIME:
-            return False
-
-        # Verify signature
-        body_dict = json.loads(body)
-        signed_payload = f"{ts}.{json.dumps(body_dict, separators=(',', ':'))}"
-        hmac_obj = hmac.new(
-            self.config.webhook_secret.encode("utf-8"),
-            signed_payload.encode("utf-8"),
-            sha256,
-        )
-        expected_signature = hmac_obj.hexdigest()
-
-        try:
-            return hmac.compare_digest(
-                expected_signature.encode("utf-8"), sig.encode("utf-8")
-            )
-        except Exception:
-            return False
--- a/server/reflector/views/_range_requests_response.py
+++ b/server/reflector/views/_range_requests_response.py
@@ -44,8 +44,6 @@ def range_requests_response(
    """Returns StreamingResponse using Range Requests of a given file"""

    if not os.path.exists(file_path):
-        from fastapi import HTTPException
-
        raise HTTPException(status_code=404, detail="File not found")

    file_size = os.stat(file_path).st_size
--- a/server/reflector/views/daily.py
+++ b/server/reflector/views/daily.py
@@ -1,145 +0,0 @@
-"""Daily.co webhook handler endpoint."""
-
-import hmac
-from hashlib import sha256
-from typing import Any, Dict
-
-from fastapi import APIRouter, HTTPException, Request
-from pydantic import BaseModel
-
-from reflector.db.meetings import meetings_controller
-from reflector.settings import settings
-
-router = APIRouter()
-
-
-class DailyWebhookEvent(BaseModel):
-    """Daily.co webhook event structure."""
-
-    type: str
-    id: str
-    ts: int  # Unix timestamp in milliseconds
-    data: Dict[str, Any]
-
-
-def verify_daily_webhook_signature(body: bytes, signature: str) -> bool:
-    """Verify Daily.co webhook signature using HMAC-SHA256."""
-    if not signature or not settings.DAILY_WEBHOOK_SECRET:
-        return False
-
-    try:
-        expected = hmac.new(
-            settings.DAILY_WEBHOOK_SECRET.encode(), body, sha256
-        ).hexdigest()
-        return hmac.compare_digest(expected, signature)
-    except Exception:
-        return False
-
-
-@router.post("/daily_webhook")
-async def daily_webhook(event: DailyWebhookEvent, request: Request):
-    """Handle Daily.co webhook events."""
-    # Verify webhook signature for security
-    body = await request.body()
-    signature = request.headers.get("X-Daily-Signature", "")
-
-    if not verify_daily_webhook_signature(body, signature):
-        raise HTTPException(status_code=401, detail="Invalid webhook signature")
-
-    # Handle participant events
-    if event.type == "participant.joined":
-        await _handle_participant_joined(event)
-    elif event.type == "participant.left":
-        await _handle_participant_left(event)
-    elif event.type == "recording.started":
-        await _handle_recording_started(event)
-    elif event.type == "recording.ready-to-download":
-        await _handle_recording_ready(event)
-    elif event.type == "recording.error":
-        await _handle_recording_error(event)
-
-    return {"status": "ok"}
-
-
-async def _handle_participant_joined(event: DailyWebhookEvent):
-    """Handle participant joined event."""
-    room_name = event.data.get("room", {}).get("name")
-    if not room_name:
-        return
-
-    meeting = await meetings_controller.get_by_room_name(room_name)
-    if meeting:
-        # Update participant count (same as Whereby)
-        current_count = getattr(meeting, "num_clients", 0)
-        await meetings_controller.update_meeting(
-            meeting.id, num_clients=current_count + 1
-        )
-
-
-async def _handle_participant_left(event: DailyWebhookEvent):
-    """Handle participant left event."""
-    room_name = event.data.get("room", {}).get("name")
-    if not room_name:
-        return
-
-    meeting = await meetings_controller.get_by_room_name(room_name)
-    if meeting:
-        # Update participant count (same as Whereby)
-        current_count = getattr(meeting, "num_clients", 0)
-        await meetings_controller.update_meeting(
-            meeting.id, num_clients=max(0, current_count - 1)
-        )
-
-
-async def _handle_recording_started(event: DailyWebhookEvent):
-    """Handle recording started event."""
-    room_name = event.data.get("room", {}).get("name")
-    if not room_name:
-        return
-
-    meeting = await meetings_controller.get_by_room_name(room_name)
-    if meeting:
-        # Log recording start for debugging
-        print(f"Recording started for meeting {meeting.id} in room {room_name}")
-
-
-async def _handle_recording_ready(event: DailyWebhookEvent):
-    """Handle recording ready for download event."""
-    room_name = event.data.get("room", {}).get("name")
-    recording_data = event.data.get("recording", {})
-    download_link = recording_data.get("download_url")
-    recording_id = recording_data.get("id")
-
-    if not room_name or not download_link:
-        return
-
-    meeting = await meetings_controller.get_by_room_name(room_name)
-    if meeting:
-        # Queue recording processing task (same as Whereby)
-        try:
-            # Import here to avoid circular imports
-            from reflector.worker.process import process_recording_from_url
-
-            # For Daily.co, we need to queue recording processing with URL
-            # This will download from the URL and process similar to S3
-            process_recording_from_url.delay(
-                recording_url=download_link,
-                meeting_id=meeting.id,
-                recording_id=recording_id or event.id,
-            )
-        except ImportError:
-            # Handle case where worker tasks aren't available
-            print(
-                f"Warning: Could not queue recording processing for meeting {meeting.id}"
-            )
-
-
-async def _handle_recording_error(event: DailyWebhookEvent):
-    """Handle recording error event."""
-    room_name = event.data.get("room", {}).get("name")
-    error = event.data.get("error", "Unknown error")
-
-    if room_name:
-        meeting = await meetings_controller.get_by_room_name(room_name)
-        if meeting:
-            print(f"Recording error for meeting {meeting.id}: {error}")
--- a/server/reflector/views/meetings.py
+++ b/server/reflector/views/meetings.py
@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Annotated, Optional

 from fastapi import APIRouter, Depends, HTTPException, Request
@@ -35,7 +35,7 @@ async def meeting_audio_consent(
        meeting_id=meeting_id,
        user_id=user_id,
        consent_given=request.consent_given,
-        consent_timestamp=datetime.utcnow(),
+        consent_timestamp=datetime.now(timezone.utc),
    )

    updated_consent = await meeting_consent_controller.upsert(consent)
--- a/server/reflector/views/rooms.py
+++ b/server/reflector/views/rooms.py
@@ -1,29 +1,34 @@
 import logging
 import sqlite3
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from typing import Annotated, Literal, Optional

 import asyncpg.exceptions
 from fastapi import APIRouter, Depends, HTTPException
 from fastapi_pagination import Page
-from fastapi_pagination.ext.databases import paginate
+from fastapi_pagination.ext.databases import apaginate
 from pydantic import BaseModel

 import reflector.auth as auth
-from reflector.db import database
+from reflector.db import get_database
 from reflector.db.meetings import meetings_controller
 from reflector.db.rooms import rooms_controller
 from reflector.settings import settings
-from reflector.video_platforms.factory import (
-    create_platform_client,
-    get_platform_for_room,
-)
+from reflector.whereby import create_meeting, upload_logo

 logger = logging.getLogger(__name__)

 router = APIRouter()


+def parse_datetime_with_timezone(iso_string: str) -> datetime:
+    """Parse ISO datetime string and ensure timezone awareness (defaults to UTC if naive)."""
+    dt = datetime.fromisoformat(iso_string)
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt
+
+
 class Room(BaseModel):
    id: str
    name: str
@@ -37,7 +42,6 @@ class Room(BaseModel):
    recording_type: str
    recording_trigger: str
    is_shared: bool
-    platform: str


 class Meeting(BaseModel):
@@ -48,7 +52,6 @@ class Meeting(BaseModel):
    start_date: datetime
    end_date: datetime
    recording_type: Literal["none", "local", "cloud"] = "cloud"
-    platform: str


 class CreateRoom(BaseModel):
@@ -88,8 +91,8 @@ async def rooms_list(

    user_id = user["sub"] if user else None

-    return await paginate(
-        database,
+    return await apaginate(
+        get_database(),
        await rooms_controller.get_all(
            user_id=user_id, order_by="-created_at", return_query=True
        ),
@@ -103,14 +106,6 @@ async def rooms_create(
 ):
    user_id = user["sub"] if user else None

-    # Determine platform for this room (will be "whereby" unless feature flag is enabled)
-    # Note: Since room doesn't exist yet, we can't use room_id for selection
-    platform = (
-        settings.DEFAULT_VIDEO_PLATFORM
-        if settings.DAILY_MIGRATION_ENABLED
-        else "whereby"
-    )
-
    return await rooms_controller.add(
        name=room.name,
        user_id=user_id,
@@ -122,7 +117,6 @@ async def rooms_create(
        recording_type=room.recording_type,
        recording_trigger=room.recording_trigger,
        is_shared=room.is_shared,
-        platform=platform,
    )


@@ -164,32 +158,24 @@ async def rooms_create_meeting(
    if not room:
        raise HTTPException(status_code=404, detail="Room not found")

-    current_time = datetime.utcnow()
+    current_time = datetime.now(timezone.utc)
    meeting = await meetings_controller.get_active(room=room, current_time=current_time)

    if meeting is None:
        end_date = current_time + timedelta(hours=8)

-        # Use the platform abstraction to create meeting
-        platform = get_platform_for_room(room.id)
-        client = create_platform_client(platform)
-
-        meeting_data = await client.create_meeting(
-            room_name_prefix=room.name, end_date=end_date, room=room
-        )
-
-        # Upload logo if supported by platform
-        await client.upload_logo(meeting_data.room_name, "./images/logo.png")
+        whereby_meeting = await create_meeting("", end_date=end_date, room=room)
+        await upload_logo(whereby_meeting["roomName"], "./images/logo.png")

        # Now try to save to database
        try:
            meeting = await meetings_controller.create(
-                id=meeting_data.meeting_id,
-                room_name=meeting_data.room_name,
-                room_url=meeting_data.room_url,
-                host_room_url=meeting_data.host_room_url,
-                start_date=current_time,
-                end_date=end_date,
+                id=whereby_meeting["meetingId"],
+                room_name=whereby_meeting["roomName"],
+                room_url=whereby_meeting["roomUrl"],
+                host_room_url=whereby_meeting["hostRoomUrl"],
+                start_date=parse_datetime_with_timezone(whereby_meeting["startDate"]),
+                end_date=parse_datetime_with_timezone(whereby_meeting["endDate"]),
                user_id=user_id,
                room=room,
            )
@@ -201,9 +187,8 @@ async def rooms_create_meeting(
                room.name,
            )
            logger.warning(
-                "%s meeting %s was created but not used (resource leak) for room %s",
-                platform,
-                meeting_data.meeting_id,
+                "Whereby meeting %s was created but not used (resource leak) for room %s",
+                whereby_meeting["meetingId"],
                room.name,
            )

--- a/server/reflector/views/transcripts.py
+++ b/server/reflector/views/transcripts.py
@@ -1,15 +1,29 @@
 from datetime import datetime, timedelta, timezone
 from typing import Annotated, Literal, Optional

-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, Query
 from fastapi_pagination import Page
-from fastapi_pagination.ext.databases import paginate
+from fastapi_pagination.ext.databases import apaginate
 from jose import jwt
 from pydantic import BaseModel, Field, field_serializer

 import reflector.auth as auth
+from reflector.db import get_database
 from reflector.db.meetings import meetings_controller
 from reflector.db.rooms import rooms_controller
+from reflector.db.search import (
+    DEFAULT_SEARCH_LIMIT,
+    SearchLimit,
+    SearchLimitBase,
+    SearchOffset,
+    SearchOffsetBase,
+    SearchParameters,
+    SearchQuery,
+    SearchQueryBase,
+    SearchResult,
+    SearchTotal,
+    search_controller,
+)
 from reflector.db.transcripts import (
    SourceKind,
    TranscriptParticipant,
@@ -34,7 +48,7 @@ DOWNLOAD_EXPIRE_MINUTES = 60

 def create_access_token(data: dict, expires_delta: timedelta):
    to_encode = data.copy()
-    expire = datetime.utcnow() + expires_delta
+    expire = datetime.now(timezone.utc) + expires_delta
    to_encode.update({"exp": expire})
    encoded_jwt = jwt.encode(to_encode, settings.SECRET_KEY, algorithm=ALGORITHM)
    return encoded_jwt
@@ -100,6 +114,21 @@ class DeletionStatus(BaseModel):
    status: str


+SearchQueryParam = Annotated[SearchQueryBase, Query(description="Search query text")]
+SearchLimitParam = Annotated[SearchLimitBase, Query(description="Results per page")]
+SearchOffsetParam = Annotated[
+    SearchOffsetBase, Query(description="Number of results to skip")
+]
+
+
+class SearchResponse(BaseModel):
+    results: list[SearchResult]
+    total: SearchTotal
+    query: SearchQuery
+    limit: SearchLimit
+    offset: SearchOffset
+
+
@router.get("/transcripts", response_model=Page[GetTranscriptMinimal])
 async def transcripts_list(
    user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
@@ -107,15 +136,13 @@ async def transcripts_list(
    room_id: str | None = None,
    search_term: str | None = None,
 ):
-    from reflector.db import database
-
    if not user and not settings.PUBLIC_MODE:
        raise HTTPException(status_code=401, detail="Not authenticated")

    user_id = user["sub"] if user else None

-    return await paginate(
-        database,
+    return await apaginate(
+        get_database(),
        await transcripts_controller.get_all(
            user_id=user_id,
            source_kind=SourceKind(source_kind) if source_kind else None,
@@ -127,6 +154,45 @@ async def transcripts_list(
    )


+@router.get("/transcripts/search", response_model=SearchResponse)
+async def transcripts_search(
+    q: SearchQueryParam,
+    limit: SearchLimitParam = DEFAULT_SEARCH_LIMIT,
+    offset: SearchOffsetParam = 0,
+    room_id: Optional[str] = None,
+    source_kind: Optional[SourceKind] = None,
+    user: Annotated[
+        Optional[auth.UserInfo], Depends(auth.current_user_optional)
+    ] = None,
+):
+    """
+    Full-text search across transcript titles and content.
+    """
+    if not user and not settings.PUBLIC_MODE:
+        raise HTTPException(status_code=401, detail="Not authenticated")
+
+    user_id = user["sub"] if user else None
+
+    search_params = SearchParameters(
+        query_text=q,
+        limit=limit,
+        offset=offset,
+        user_id=user_id,
+        room_id=room_id,
+        source_kind=source_kind,
+    )
+
+    results, total = await search_controller.search_transcripts(search_params)
+
+    return SearchResponse(
+        results=results,
+        total=total,
+        query=search_params.query_text,
+        limit=search_params.limit,
+        offset=search_params.offset,
+    )
+
+
@router.post("/transcripts", response_model=GetTranscript)
 async def transcripts_create(
    info: CreateTranscript,
@@ -273,8 +339,8 @@ async def transcript_update(
    if not transcript:
        raise HTTPException(status_code=404, detail="Transcript not found")
    values = info.dict(exclude_unset=True)
-    await transcripts_controller.update(transcript, values)
-    return transcript
+    updated_transcript = await transcripts_controller.update(transcript, values)
+    return updated_transcript


@router.delete("/transcripts/{transcript_id}", response_model=DeletionStatus)
--- a/server/reflector/views/transcripts_audio.py
+++ b/server/reflector/views/transcripts_audio.py
@@ -51,24 +51,6 @@ async def transcript_get_audio_mp3(
        transcript_id, user_id=user_id
    )

-    if transcript.audio_location == "storage":
-        # proxy S3 file, to prevent issue with CORS
-        url = await transcript.get_audio_url()
-        headers = {}
-
-        copy_headers = ["range", "accept-encoding"]
-        for header in copy_headers:
-            if header in request.headers:
-                headers[header] = request.headers[header]
-
-        async with httpx.AsyncClient() as client:
-            resp = await client.request(request.method, url, headers=headers)
-            return Response(
-                content=resp.content,
-                status_code=resp.status_code,
-                headers=resp.headers,
-            )
-
    if transcript.audio_location == "storage":
        # proxy S3 file, to prevent issue with CORS
        url = await transcript.get_audio_url()
--- a/server/reflector/views/transcripts_webrtc.py
+++ b/server/reflector/views/transcripts_webrtc.py
@@ -26,7 +26,7 @@ async def transcript_record_webrtc(
        raise HTTPException(status_code=400, detail="Transcript is locked")

    # create a pipeline runner
-    from reflector.pipelines.main_live_pipeline import PipelineMainLive
+    from reflector.pipelines.main_live_pipeline import PipelineMainLive  # noqa: PLC0415

    pipeline_runner = PipelineMainLive(transcript_id=transcript_id)

--- a/server/reflector/whereby.py
+++ b/server/reflector/whereby.py
@@ -23,7 +23,7 @@ async def create_meeting(room_name_prefix: str, end_date: datetime, room: Room):
            "type": room.recording_type,
            "destination": {
                "provider": "s3",
-                "bucket": settings.AWS_WHEREBY_S3_BUCKET,
+                "bucket": settings.RECORDING_STORAGE_AWS_BUCKET_NAME,
                "accessKeyId": settings.AWS_WHEREBY_ACCESS_KEY_ID,
                "accessKeySecret": settings.AWS_WHEREBY_ACCESS_KEY_SECRET,
                "fileFormat": "mp4",
--- a/server/reflector/worker/process.py
+++ b/server/reflector/worker/process.py
@@ -5,7 +5,6 @@ from urllib.parse import unquote

 import av
 import boto3
-import httpx
 import structlog
 from celery import shared_task
 from celery.utils.log import get_task_logger
@@ -15,13 +14,22 @@ from reflector.db.meetings import meetings_controller
 from reflector.db.recordings import Recording, recordings_controller
 from reflector.db.rooms import rooms_controller
 from reflector.db.transcripts import SourceKind, transcripts_controller
-from reflector.pipelines.main_live_pipeline import asynctask, task_pipeline_process
+from reflector.pipelines.main_file_pipeline import task_pipeline_file_process
+from reflector.pipelines.main_live_pipeline import asynctask
 from reflector.settings import settings
 from reflector.whereby import get_room_sessions

 logger = structlog.wrap_logger(get_task_logger(__name__))


+def parse_datetime_with_timezone(iso_string: str) -> datetime:
+    """Parse ISO datetime string and ensure timezone awareness (defaults to UTC if naive)."""
+    dt = datetime.fromisoformat(iso_string)
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt
+
+
@shared_task
 def process_messages():
    queue_url = settings.AWS_PROCESS_RECORDING_QUEUE_URL
@@ -70,7 +78,7 @@ async def process_recording(bucket_name: str, object_key: str):

    # extract a guid and a datetime from the object key
    room_name = f"/{object_key[:36]}"
-    recorded_at = datetime.fromisoformat(object_key[37:57])
+    recorded_at = parse_datetime_with_timezone(object_key[37:57])

    meeting = await meetings_controller.get_by_room_name(room_name)
    room = await rooms_controller.get_by_id(meeting.room_id)
@@ -133,7 +141,7 @@ async def process_recording(bucket_name: str, object_key: str):

    await transcripts_controller.update(transcript, {"status": "uploaded"})

-    task_pipeline_process.delay(transcript_id=transcript.id)
+    task_pipeline_file_process.delay(transcript_id=transcript.id)


@shared_task
@@ -178,7 +186,7 @@ async def reprocess_failed_recordings():
    reprocessed_count = 0
    try:
        paginator = s3.get_paginator("list_objects_v2")
-        bucket_name = settings.AWS_WHEREBY_S3_BUCKET
+        bucket_name = settings.RECORDING_STORAGE_AWS_BUCKET_NAME
        pages = paginator.paginate(Bucket=bucket_name)

        for page in pages:
@@ -221,98 +229,3 @@ async def reprocess_failed_recordings():

    logger.info(f"Reprocessing complete. Requeued {reprocessed_count} recordings")
    return reprocessed_count
-
-
-@shared_task
-@asynctask
-async def process_recording_from_url(
-    recording_url: str, meeting_id: str, recording_id: str
-):
-    """Process recording from Direct URL (Daily.co webhook)."""
-    logger.info("Processing recording from URL for meeting: %s", meeting_id)
-
-    meeting = await meetings_controller.get_by_id(meeting_id)
-    if not meeting:
-        logger.error("Meeting not found: %s", meeting_id)
-        return
-
-    room = await rooms_controller.get_by_id(meeting.room_id)
-    if not room:
-        logger.error("Room not found for meeting: %s", meeting_id)
-        return
-
-    # Create recording record with URL instead of S3 bucket/key
-    recording = await recordings_controller.get_by_object_key(
-        "daily-recordings", recording_id
-    )
-    if not recording:
-        recording = await recordings_controller.create(
-            Recording(
-                bucket_name="daily-recordings",  # Logical bucket name for Daily.co
-                object_key=recording_id,  # Store Daily.co recording ID
-                recorded_at=datetime.utcnow(),
-                meeting_id=meeting.id,
-            )
-        )
-
-    # Get or create transcript record
-    transcript = await transcripts_controller.get_by_recording_id(recording.id)
-    if transcript:
-        await transcripts_controller.update(transcript, {"topics": []})
-    else:
-        transcript = await transcripts_controller.add(
-            "",
-            source_kind=SourceKind.ROOM,
-            source_language="en",
-            target_language="en",
-            user_id=room.user_id,
-            recording_id=recording.id,
-            share_mode="public",
-            meeting_id=meeting.id,
-            room_id=room.id,
-        )
-
-    # Download file from URL
-    upload_filename = transcript.data_path / "upload.mp4"
-    upload_filename.parent.mkdir(parents=True, exist_ok=True)
-
-    try:
-        logger.info("Downloading recording from URL: %s", recording_url)
-        async with httpx.AsyncClient(timeout=300.0) as client:  # 5 minute timeout
-            async with client.stream("GET", recording_url) as response:
-                response.raise_for_status()
-
-                with open(upload_filename, "wb") as f:
-                    async for chunk in response.aiter_bytes(8192):
-                        f.write(chunk)
-
-        logger.info("Download completed: %s", upload_filename)
-    except Exception as e:
-        logger.error("Failed to download recording: %s", str(e))
-        await transcripts_controller.update(transcript, {"status": "error"})
-        if upload_filename.exists():
-            upload_filename.unlink()
-        raise
-
-    # Validate audio content (same as S3 version)
-    try:
-        container = av.open(upload_filename.as_posix())
-        try:
-            if not len(container.streams.audio):
-                raise Exception("File has no audio stream")
-            logger.info("Audio validation successful")
-        finally:
-            container.close()
-    except Exception as e:
-        logger.error("Audio validation failed: %s", str(e))
-        await transcripts_controller.update(transcript, {"status": "error"})
-        if upload_filename.exists():
-            upload_filename.unlink()
-        raise
-
-    # Mark as uploaded and trigger processing pipeline
-    await transcripts_controller.update(transcript, {"status": "uploaded"})
-    logger.info("Queuing transcript for processing pipeline: %s", transcript.id)
-
-    # Start the ML pipeline (same as S3 version)
-    task_pipeline_process.delay(transcript_id=transcript.id)
--- a/server/reflector/ws_manager.py
+++ b/server/reflector/ws_manager.py
@@ -62,6 +62,7 @@ class RedisPubSubManager:
 class WebsocketManager:
    def __init__(self, pubsub_client: RedisPubSubManager = None):
        self.rooms: dict = {}
+        self.tasks: dict = {}
        self.pubsub_client = pubsub_client

    async def add_user_to_room(self, room_id: str, websocket: WebSocket) -> None:
@@ -74,13 +75,17 @@ class WebsocketManager:

            await self.pubsub_client.connect()
            pubsub_subscriber = await self.pubsub_client.subscribe(room_id)
-            asyncio.create_task(self._pubsub_data_reader(pubsub_subscriber))
+            task = asyncio.create_task(self._pubsub_data_reader(pubsub_subscriber))
+            self.tasks[id(websocket)] = task

    async def send_json(self, room_id: str, message: dict) -> None:
        await self.pubsub_client.send_json(room_id, message)

    async def remove_user_from_room(self, room_id: str, websocket: WebSocket) -> None:
        self.rooms[room_id].remove(websocket)
+        task = self.tasks.pop(id(websocket), None)
+        if task:
+            task.cancel()

        if len(self.rooms[room_id]) == 0:
            del self.rooms[room_id]
--- a/server/tests/cassettes/test_processors_modal/test_file_diarization_modal_processor.yaml
+++ b/server/tests/cassettes/test_processors_modal/test_file_diarization_modal_processor.yaml
@@ -0,0 +1,40 @@
+interactions:
+- request:
+    body: ''
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate
+      authorization:
+      - DUMMY_API_KEY
+      connection:
+      - keep-alive
+      content-length:
+      - '0'
+      host:
+      - monadical-sas--reflector-diarizer-web.modal.run
+      user-agent:
+      - python-httpx/0.27.2
+    method: POST
+    uri: https://monadical-sas--reflector-diarizer-web.modal.run/diarize?audio_file_url=https%3A%2F%2Freflector-github-pytest.s3.us-east-1.amazonaws.com%2Ftest_mathieu_hello.mp3&timestamp=0
+  response:
+    body:
+      string: '{"diarization":[{"start":0.823,"end":1.91,"speaker":0},{"start":2.572,"end":6.409,"speaker":0},{"start":6.783,"end":10.62,"speaker":0},{"start":11.231,"end":14.168,"speaker":0},{"start":14.796,"end":19.295,"speaker":0}]}'
+    headers:
+      Alt-Svc:
+      - h3=":443"; ma=2592000
+      Content-Length:
+      - '220'
+      Content-Type:
+      - application/json
+      Date:
+      - Wed, 13 Aug 2025 18:25:34 GMT
+      Modal-Function-Call-Id:
+      - fc-01K2JAVNEP6N7Y1Y7W3T98BCXK
+      Vary:
+      - accept-encoding
+    status:
+      code: 200
+      message: OK
+version: 1
--- a/server/tests/cassettes/test_processors_modal/test_file_transcript_modal_processor.yaml
+++ b/server/tests/cassettes/test_processors_modal/test_file_transcript_modal_processor.yaml
@@ -0,0 +1,46 @@
+interactions:
+- request:
+    body: '{"audio_file_url": "https://reflector-github-pytest.s3.us-east-1.amazonaws.com/test_mathieu_hello.mp3",
+      "language": "en", "batch": true}'
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate
+      authorization:
+      - DUMMY_API_KEY
+      connection:
+      - keep-alive
+      content-length:
+      - '136'
+      content-type:
+      - application/json
+      host:
+      - monadical-sas--reflector-transcriber-parakeet-web.modal.run
+      user-agent:
+      - python-httpx/0.27.2
+    method: POST
+    uri: https://monadical-sas--reflector-transcriber-parakeet-web.modal.run/v1/audio/transcriptions-from-url
+  response:
+    body:
+      string: '{"text":"Hi there everyone. Today I want to share my incredible experience
+        with Reflector. a Q teenage product that revolutionizes audio processing.
+        With reflector, I can easily convert any audio into accurate transcription.
+        saving me hours of tedious manual work.","words":[{"word":"Hi","start":0.87,"end":1.19},{"word":"there","start":1.19,"end":1.35},{"word":"everyone.","start":1.51,"end":1.83},{"word":"Today","start":2.63,"end":2.87},{"word":"I","start":3.36,"end":3.52},{"word":"want","start":3.6,"end":3.76},{"word":"to","start":3.76,"end":3.92},{"word":"share","start":3.92,"end":4.16},{"word":"my","start":4.16,"end":4.4},{"word":"incredible","start":4.32,"end":4.96},{"word":"experience","start":4.96,"end":5.44},{"word":"with","start":5.44,"end":5.68},{"word":"Reflector.","start":5.68,"end":6.24},{"word":"a","start":6.93,"end":7.01},{"word":"Q","start":7.01,"end":7.17},{"word":"teenage","start":7.25,"end":7.65},{"word":"product","start":7.89,"end":8.29},{"word":"that","start":8.29,"end":8.61},{"word":"revolutionizes","start":8.61,"end":9.65},{"word":"audio","start":9.65,"end":10.05},{"word":"processing.","start":10.05,"end":10.53},{"word":"With","start":11.27,"end":11.43},{"word":"reflector,","start":11.51,"end":12.15},{"word":"I","start":12.31,"end":12.39},{"word":"can","start":12.39,"end":12.55},{"word":"easily","start":12.55,"end":12.95},{"word":"convert","start":12.95,"end":13.43},{"word":"any","start":13.43,"end":13.67},{"word":"audio","start":13.67,"end":13.99},{"word":"into","start":14.98,"end":15.06},{"word":"accurate","start":15.22,"end":15.54},{"word":"transcription.","start":15.7,"end":16.34},{"word":"saving","start":16.99,"end":17.15},{"word":"me","start":17.31,"end":17.47},{"word":"hours","start":17.47,"end":17.87},{"word":"of","start":17.87,"end":18.11},{"word":"tedious","start":18.11,"end":18.67},{"word":"manual","start":18.67,"end":19.07},{"word":"work.","start":19.07,"end":19.31}]}'
+    headers:
+      Alt-Svc:
+      - h3=":443"; ma=2592000
+      Content-Length:
+      - '1933'
+      Content-Type:
+      - application/json
+      Date:
+      - Wed, 13 Aug 2025 18:26:59 GMT
+      Modal-Function-Call-Id:
+      - fc-01K2JAWC7GAMKX4DSJ21WV31NG
+      Vary:
+      - accept-encoding
+    status:
+      code: 200
+      message: OK
+version: 1
--- a/server/tests/cassettes/test_processors_modal/test_full_modal_pipeline_integration.yaml
+++ b/server/tests/cassettes/test_processors_modal/test_full_modal_pipeline_integration.yaml
@@ -0,0 +1,84 @@
+interactions:
+- request:
+    body: '{"audio_file_url": "https://reflector-github-pytest.s3.us-east-1.amazonaws.com/test_mathieu_hello.mp3",
+      "language": "en", "batch": true}'
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate
+      authorization:
+      - DUMMY_API_KEY
+      connection:
+      - keep-alive
+      content-length:
+      - '136'
+      content-type:
+      - application/json
+      host:
+      - monadical-sas--reflector-transcriber-parakeet-web.modal.run
+      user-agent:
+      - python-httpx/0.27.2
+    method: POST
+    uri: https://monadical-sas--reflector-transcriber-parakeet-web.modal.run/v1/audio/transcriptions-from-url
+  response:
+    body:
+      string: '{"text":"Hi there everyone. Today I want to share my incredible experience
+        with Reflector. a Q teenage product that revolutionizes audio processing.
+        With reflector, I can easily convert any audio into accurate transcription.
+        saving me hours of tedious manual work.","words":[{"word":"Hi","start":0.87,"end":1.19},{"word":"there","start":1.19,"end":1.35},{"word":"everyone.","start":1.51,"end":1.83},{"word":"Today","start":2.63,"end":2.87},{"word":"I","start":3.36,"end":3.52},{"word":"want","start":3.6,"end":3.76},{"word":"to","start":3.76,"end":3.92},{"word":"share","start":3.92,"end":4.16},{"word":"my","start":4.16,"end":4.4},{"word":"incredible","start":4.32,"end":4.96},{"word":"experience","start":4.96,"end":5.44},{"word":"with","start":5.44,"end":5.68},{"word":"Reflector.","start":5.68,"end":6.24},{"word":"a","start":6.93,"end":7.01},{"word":"Q","start":7.01,"end":7.17},{"word":"teenage","start":7.25,"end":7.65},{"word":"product","start":7.89,"end":8.29},{"word":"that","start":8.29,"end":8.61},{"word":"revolutionizes","start":8.61,"end":9.65},{"word":"audio","start":9.65,"end":10.05},{"word":"processing.","start":10.05,"end":10.53},{"word":"With","start":11.27,"end":11.43},{"word":"reflector,","start":11.51,"end":12.15},{"word":"I","start":12.31,"end":12.39},{"word":"can","start":12.39,"end":12.55},{"word":"easily","start":12.55,"end":12.95},{"word":"convert","start":12.95,"end":13.43},{"word":"any","start":13.43,"end":13.67},{"word":"audio","start":13.67,"end":13.99},{"word":"into","start":14.98,"end":15.06},{"word":"accurate","start":15.22,"end":15.54},{"word":"transcription.","start":15.7,"end":16.34},{"word":"saving","start":16.99,"end":17.15},{"word":"me","start":17.31,"end":17.47},{"word":"hours","start":17.47,"end":17.87},{"word":"of","start":17.87,"end":18.11},{"word":"tedious","start":18.11,"end":18.67},{"word":"manual","start":18.67,"end":19.07},{"word":"work.","start":19.07,"end":19.31}]}'
+    headers:
+      Alt-Svc:
+      - h3=":443"; ma=2592000
+      Content-Length:
+      - '1933'
+      Content-Type:
+      - application/json
+      Date:
+      - Wed, 13 Aug 2025 18:27:02 GMT
+      Modal-Function-Call-Id:
+      - fc-01K2JAYZ1AR2HE422VJVKBWX9Z
+      Vary:
+      - accept-encoding
+    status:
+      code: 200
+      message: OK
+- request:
+    body: ''
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate
+      authorization:
+      - DUMMY_API_KEY
+      connection:
+      - keep-alive
+      content-length:
+      - '0'
+      host:
+      - monadical-sas--reflector-diarizer-web.modal.run
+      user-agent:
+      - python-httpx/0.27.2
+    method: POST
+    uri: https://monadical-sas--reflector-diarizer-web.modal.run/diarize?audio_file_url=https%3A%2F%2Freflector-github-pytest.s3.us-east-1.amazonaws.com%2Ftest_mathieu_hello.mp3&timestamp=0
+  response:
+    body:
+      string: '{"diarization":[{"start":0.823,"end":1.91,"speaker":0},{"start":2.572,"end":6.409,"speaker":0},{"start":6.783,"end":10.62,"speaker":0},{"start":11.231,"end":14.168,"speaker":0},{"start":14.796,"end":19.295,"speaker":0}]}'
+    headers:
+      Alt-Svc:
+      - h3=":443"; ma=2592000
+      Content-Length:
+      - '220'
+      Content-Type:
+      - application/json
+      Date:
+      - Wed, 13 Aug 2025 18:27:18 GMT
+      Modal-Function-Call-Id:
+      - fc-01K2JAZ1M34NQRJK03CCFK95D6
+      Vary:
+      - accept-encoding
+    status:
+      code: 200
+      message: OK
+version: 1
--- a/server/tests/conftest.py
+++ b/server/tests/conftest.py
@@ -1,21 +1,85 @@
+import os
 from tempfile import NamedTemporaryFile
 from unittest.mock import patch

 import pytest


-@pytest.fixture(scope="function", autouse=True)
-@pytest.mark.asyncio
-async def setup_database():
+@pytest.fixture(scope="session", autouse=True)
+def settings_configuration():
+    # theses settings are linked to monadical for pytest-recording
+    # if a fork is done, they have to provide their own url when cassettes needs to be updated
+    # modal api keys has to be defined by the user
    from reflector.settings import settings

-    with NamedTemporaryFile() as f:
-        settings.DATABASE_URL = f"sqlite:///{f.name}"
-        from reflector.db import engine, metadata
+    settings.TRANSCRIPT_BACKEND = "modal"
+    settings.TRANSCRIPT_URL = (
+        "https://monadical-sas--reflector-transcriber-parakeet-web.modal.run"
+    )
+    settings.DIARIZATION_BACKEND = "modal"
+    settings.DIARIZATION_URL = "https://monadical-sas--reflector-diarizer-web.modal.run"

-        metadata.create_all(bind=engine)

+@pytest.fixture(scope="module")
+def vcr_config():
+    """VCR configuration to filter sensitive headers"""
+    return {
+        "filter_headers": [("authorization", "DUMMY_API_KEY")],
+    }
+
+
+@pytest.fixture(scope="session")
+def docker_compose_file(pytestconfig):
+    return os.path.join(str(pytestconfig.rootdir), "tests", "docker-compose.test.yml")
+
+
+@pytest.fixture(scope="session")
+def postgres_service(docker_ip, docker_services):
+    """Ensure that PostgreSQL service is up and responsive."""
+    port = docker_services.port_for("postgres_test", 5432)
+
+    def is_responsive():
+        try:
+            import psycopg2
+
+            conn = psycopg2.connect(
+                host=docker_ip,
+                port=port,
+                dbname="reflector_test",
+                user="test_user",
+                password="test_password",
+            )
+            conn.close()
+            return True
+        except Exception:
+            return False
+
+    docker_services.wait_until_responsive(timeout=30.0, pause=0.1, check=is_responsive)
+
+    # Return connection parameters
+    return {
+        "host": docker_ip,
+        "port": port,
+        "dbname": "reflector_test",
+        "user": "test_user",
+        "password": "test_password",
+    }
+
+
+@pytest.fixture(scope="function", autouse=True)
+@pytest.mark.asyncio
+async def setup_database(postgres_service):
+    from reflector.db import engine, metadata, get_database  # noqa
+
+    metadata.drop_all(bind=engine)
+    metadata.create_all(bind=engine)
+    database = get_database()
+
+    try:
+        await database.connect()
        yield
+    finally:
+        await database.disconnect()


@pytest.fixture
@@ -33,9 +97,6 @@ def dummy_processors():
        patch(
            "reflector.processors.transcript_final_summary.TranscriptFinalSummaryProcessor.get_short_summary"
        ) as mock_short_summary,
-        patch(
-            "reflector.processors.transcript_translator.TranscriptTranslatorProcessor.get_translation"
-        ) as mock_translate,
    ):
        from reflector.processors.transcript_topic_detector import TopicResponse

@@ -45,9 +106,7 @@ def dummy_processors():
        mock_title.return_value = "LLM Title"
        mock_long_summary.return_value = "LLM LONG SUMMARY"
        mock_short_summary.return_value = "LLM SHORT SUMMARY"
-        mock_translate.return_value = "Bonjour le monde"
        yield (
-            mock_translate,
            mock_topic,
            mock_title,
            mock_long_summary,
@@ -55,6 +114,20 @@ def dummy_processors():
        )  # noqa


+@pytest.fixture
+async def whisper_transcript():
+    from reflector.processors.audio_transcript_whisper import (
+        AudioTranscriptWhisperProcessor,
+    )
+
+    with patch(
+        "reflector.processors.audio_transcript_auto"
+        ".AudioTranscriptAutoProcessor.__new__"
+    ) as mock_audio:
+        mock_audio.return_value = AudioTranscriptWhisperProcessor()
+        yield
+
+
@pytest.fixture
 async def dummy_transcript():
    from reflector.processors.audio_transcript import AudioTranscriptProcessor
@@ -105,6 +178,27 @@ async def dummy_diarization():
        yield


+@pytest.fixture
+async def dummy_transcript_translator():
+    from reflector.processors.transcript_translator import TranscriptTranslatorProcessor
+
+    class TestTranscriptTranslatorProcessor(TranscriptTranslatorProcessor):
+        async def _translate(self, text: str) -> str:
+            source_language = self.get_pref("audio:source_language", "en")
+            target_language = self.get_pref("audio:target_language", "en")
+            return f"{source_language}:{target_language}:{text}"
+
+    def mock_new(cls, *args, **kwargs):
+        return TestTranscriptTranslatorProcessor(*args, **kwargs)
+
+    with patch(
+        "reflector.processors.transcript_translator_auto"
+        ".TranscriptTranslatorAutoProcessor.__new__",
+        mock_new,
+    ):
+        yield
+
+
@pytest.fixture
 async def dummy_llm():
    from reflector.llm import LLM
@@ -169,6 +263,16 @@ def celery_includes():
    return ["reflector.pipelines.main_live_pipeline"]


+@pytest.fixture
+async def client():
+    from httpx import AsyncClient
+
+    from reflector.app import app
+
+    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
+        yield ac
+
+
@pytest.fixture(scope="session")
 def fake_mp3_upload():
    with patch(
@@ -179,13 +283,10 @@ def fake_mp3_upload():


@pytest.fixture
-async def fake_transcript_with_topics(tmpdir):
+async def fake_transcript_with_topics(tmpdir, client):
    import shutil
    from pathlib import Path

-    from httpx import AsyncClient
-
-    from reflector.app import app
    from reflector.db.transcripts import TranscriptTopic
    from reflector.processors.types import Word
    from reflector.settings import settings
@@ -194,8 +295,7 @@ async def fake_transcript_with_topics(tmpdir):
    settings.DATA_DIR = Path(tmpdir)

    # create a transcript
-    ac = AsyncClient(app=app, base_url="http://test/v1")
-    response = await ac.post("/transcripts", json={"name": "Test audio download"})
+    response = await client.post("/transcripts", json={"name": "Test audio download"})
    assert response.status_code == 200
    tid = response.json()["id"]

--- a/server/tests/docker-compose.test.yml
+++ b/server/tests/docker-compose.test.yml
@@ -0,0 +1,13 @@
+version: "3.8"
+services:
+  postgres_test:
+    image: postgres:17
+    environment:
+      POSTGRES_DB: reflector_test
+      POSTGRES_USER: test_user
+      POSTGRES_PASSWORD: test_password
+    ports:
+      - "15432:5432"
+    command: postgres -c fsync=off -c synchronous_commit=off -c full_page_writes=off
+    tmpfs:
+      - /var/lib/postgresql/data:rw,noexec,nosuid,size=1g
--- a/server/tests/test_daily_webhook.py
+++ b/server/tests/test_daily_webhook.py
@@ -1,390 +0,0 @@
-"""Tests for Daily.co webhook integration."""
-
-import hashlib
-import hmac
-import json
-from datetime import datetime
-from unittest.mock import MagicMock, patch
-
-import pytest
-from httpx import AsyncClient
-
-from reflector.app import app
-from reflector.views.daily import DailyWebhookEvent
-
-
-class TestDailyWebhookIntegration:
-    """Test Daily.co webhook endpoint integration."""
-
-    @pytest.fixture
-    def webhook_secret(self):
-        """Test webhook secret."""
-        return "test-webhook-secret-123"
-
-    @pytest.fixture
-    def mock_room(self):
-        """Create a mock room for testing."""
-        room = MagicMock()
-        room.id = "test-room-123"
-        room.name = "Test Room"
-        room.recording_type = "cloud"
-        room.platform = "daily"
-        return room
-
-    @pytest.fixture
-    def mock_meeting(self):
-        """Create a mock meeting for testing."""
-        meeting = MagicMock()
-        meeting.id = "test-meeting-456"
-        meeting.room_id = "test-room-123"
-        meeting.platform = "daily"
-        meeting.room_name = "test-room-123-abc"
-        return meeting
-
-    def create_webhook_signature(self, payload: bytes, secret: str) -> str:
-        """Create HMAC signature for webhook payload."""
-        return hmac.new(secret.encode(), payload, hashlib.sha256).hexdigest()
-
-    def create_webhook_event(
-        self, event_type: str, room_name: str = "test-room-123-abc", **kwargs
-    ) -> dict:
-        """Create a Daily.co webhook event payload."""
-        base_event = {
-            "type": event_type,
-            "id": f"evt_{event_type.replace('.', '_')}_{int(datetime.utcnow().timestamp())}",
-            "ts": int(datetime.utcnow().timestamp() * 1000),  # milliseconds
-            "data": {"room": {"name": room_name}, **kwargs},
-        }
-        return base_event
-
-    @pytest.mark.asyncio
-    async def test_webhook_participant_joined(
-        self, webhook_secret, mock_room, mock_meeting
-    ):
-        """Test participant joined webhook event."""
-        event_data = self.create_webhook_event(
-            "participant.joined",
-            participant={
-                "id": "participant-123",
-                "user_name": "John Doe",
-                "session_id": "session-456",
-            },
-        )
-
-        payload = json.dumps(event_data).encode()
-        signature = self.create_webhook_signature(payload, webhook_secret)
-
-        with patch("reflector.views.daily.settings") as mock_settings:
-            mock_settings.DAILY_WEBHOOK_SECRET = webhook_secret
-
-            with patch(
-                "reflector.db.meetings.meetings_controller.get_by_room_name"
-            ) as mock_get_meeting:
-                mock_get_meeting.return_value = mock_meeting
-
-                with patch(
-                    "reflector.db.meetings.meetings_controller.update_meeting"
-                ) as mock_update:
-                    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-                        response = await ac.post(
-                            "/daily_webhook",
-                            json=event_data,
-                            headers={"X-Daily-Signature": signature},
-                        )
-
-                        assert response.status_code == 200
-                        assert response.json() == {"status": "ok"}
-
-                        # Verify meeting was looked up
-                        mock_get_meeting.assert_called_once_with("test-room-123-abc")
-
-    @pytest.mark.asyncio
-    async def test_webhook_participant_left(
-        self, webhook_secret, mock_room, mock_meeting
-    ):
-        """Test participant left webhook event."""
-        event_data = self.create_webhook_event(
-            "participant.left",
-            participant={
-                "id": "participant-123",
-                "user_name": "John Doe",
-                "session_id": "session-456",
-            },
-        )
-
-        payload = json.dumps(event_data).encode()
-        signature = self.create_webhook_signature(payload, webhook_secret)
-
-        with patch("reflector.views.daily.settings") as mock_settings:
-            mock_settings.DAILY_WEBHOOK_SECRET = webhook_secret
-
-            with patch(
-                "reflector.db.meetings.meetings_controller.get_by_room_name"
-            ) as mock_get_meeting:
-                mock_get_meeting.return_value = mock_meeting
-
-                async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-                    response = await ac.post(
-                        "/daily_webhook",
-                        json=event_data,
-                        headers={"X-Daily-Signature": signature},
-                    )
-
-                    assert response.status_code == 200
-                    assert response.json() == {"status": "ok"}
-
-    @pytest.mark.asyncio
-    async def test_webhook_recording_started(
-        self, webhook_secret, mock_room, mock_meeting
-    ):
-        """Test recording started webhook event."""
-        event_data = self.create_webhook_event(
-            "recording.started",
-            recording={
-                "id": "recording-789",
-                "status": "recording",
-                "start_time": "2025-01-01T10:00:00Z",
-            },
-        )
-
-        payload = json.dumps(event_data).encode()
-        signature = self.create_webhook_signature(payload, webhook_secret)
-
-        with patch("reflector.views.daily.settings") as mock_settings:
-            mock_settings.DAILY_WEBHOOK_SECRET = webhook_secret
-
-            with patch(
-                "reflector.db.meetings.meetings_controller.get_by_room_name"
-            ) as mock_get_meeting:
-                mock_get_meeting.return_value = mock_meeting
-
-                with patch(
-                    "reflector.db.meetings.meetings_controller.update_meeting"
-                ) as mock_update:
-                    async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-                        response = await ac.post(
-                            "/daily_webhook",
-                            json=event_data,
-                            headers={"X-Daily-Signature": signature},
-                        )
-
-                        assert response.status_code == 200
-                        assert response.json() == {"status": "ok"}
-
-    @pytest.mark.asyncio
-    async def test_webhook_recording_ready_triggers_processing(
-        self, webhook_secret, mock_room, mock_meeting
-    ):
-        """Test recording ready webhook triggers audio processing."""
-        event_data = self.create_webhook_event(
-            "recording.ready-to-download",
-            recording={
-                "id": "recording-789",
-                "status": "finished",
-                "download_url": "https://s3.amazonaws.com/bucket/recording.mp4",
-                "start_time": "2025-01-01T10:00:00Z",
-                "duration": 1800,
-            },
-        )
-
-        payload = json.dumps(event_data).encode()
-        signature = self.create_webhook_signature(payload, webhook_secret)
-
-        with patch("reflector.views.daily.settings") as mock_settings:
-            mock_settings.DAILY_WEBHOOK_SECRET = webhook_secret
-
-            with patch(
-                "reflector.db.meetings.meetings_controller.get_by_room_name"
-            ) as mock_get_meeting:
-                mock_get_meeting.return_value = mock_meeting
-
-                with patch(
-                    "reflector.db.meetings.meetings_controller.update_meeting"
-                ) as mock_update_url:
-                    with patch(
-                        "reflector.worker.process.process_recording_from_url.delay"
-                    ) as mock_process:
-                        async with AsyncClient(
-                            app=app, base_url="http://test/v1"
-                        ) as ac:
-                            response = await ac.post(
-                                "/daily_webhook",
-                                json=event_data,
-                                headers={"X-Daily-Signature": signature},
-                            )
-
-                            assert response.status_code == 200
-                            assert response.json() == {"status": "ok"}
-
-                            # Verify processing was triggered with correct parameters
-                            mock_process.assert_called_once_with(
-                                recording_url="https://s3.amazonaws.com/bucket/recording.mp4",
-                                meeting_id=mock_meeting.id,
-                                recording_id="recording-789",
-                            )
-
-    @pytest.mark.asyncio
-    async def test_webhook_invalid_signature_rejected(self, webhook_secret):
-        """Test webhook with invalid signature is rejected."""
-        event_data = self.create_webhook_event("participant.joined")
-
-        with patch("reflector.views.daily.settings") as mock_settings:
-            mock_settings.DAILY_WEBHOOK_SECRET = webhook_secret
-
-            async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-                response = await ac.post(
-                    "/daily_webhook",
-                    json=event_data,
-                    headers={"X-Daily-Signature": "invalid-signature"},
-                )
-
-                assert response.status_code == 401
-                assert "Invalid signature" in response.json()["detail"]
-
-    @pytest.mark.asyncio
-    async def test_webhook_missing_signature_rejected(self):
-        """Test webhook without signature header is rejected."""
-        event_data = self.create_webhook_event("participant.joined")
-
-        async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-            response = await ac.post("/daily_webhook", json=event_data)
-
-            assert response.status_code == 401
-            assert "Missing signature" in response.json()["detail"]
-
-    @pytest.mark.asyncio
-    async def test_webhook_meeting_not_found(self, webhook_secret):
-        """Test webhook for non-existent meeting."""
-        event_data = self.create_webhook_event(
-            "participant.joined", room_name="non-existent-room"
-        )
-
-        payload = json.dumps(event_data).encode()
-        signature = self.create_webhook_signature(payload, webhook_secret)
-
-        with patch("reflector.views.daily.settings") as mock_settings:
-            mock_settings.DAILY_WEBHOOK_SECRET = webhook_secret
-
-            with patch(
-                "reflector.db.meetings.meetings_controller.get_by_room_name"
-            ) as mock_get_meeting:
-                mock_get_meeting.return_value = None
-
-                async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-                    response = await ac.post(
-                        "/daily_webhook",
-                        json=event_data,
-                        headers={"X-Daily-Signature": signature},
-                    )
-
-                    assert response.status_code == 404
-                    assert "Meeting not found" in response.json()["detail"]
-
-    @pytest.mark.asyncio
-    async def test_webhook_unknown_event_type(self, webhook_secret, mock_meeting):
-        """Test webhook with unknown event type."""
-        event_data = self.create_webhook_event("unknown.event")
-
-        payload = json.dumps(event_data).encode()
-        signature = self.create_webhook_signature(payload, webhook_secret)
-
-        with patch("reflector.views.daily.settings") as mock_settings:
-            mock_settings.DAILY_WEBHOOK_SECRET = webhook_secret
-
-            with patch(
-                "reflector.db.meetings.meetings_controller.get_by_room_name"
-            ) as mock_get_meeting:
-                mock_get_meeting.return_value = mock_meeting
-
-                async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-                    response = await ac.post(
-                        "/daily_webhook",
-                        json=event_data,
-                        headers={"X-Daily-Signature": signature},
-                    )
-
-                    # Should still return 200 but log the unknown event
-                    assert response.status_code == 200
-                    assert response.json() == {"status": "ok"}
-
-    @pytest.mark.asyncio
-    async def test_webhook_malformed_json(self, webhook_secret):
-        """Test webhook with malformed JSON."""
-        with patch("reflector.views.daily.settings") as mock_settings:
-            mock_settings.DAILY_WEBHOOK_SECRET = webhook_secret
-
-            async with AsyncClient(app=app, base_url="http://test/v1") as ac:
-                response = await ac.post(
-                    "/daily_webhook",
-                    content="invalid json",
-                    headers={
-                        "Content-Type": "application/json",
-                        "X-Daily-Signature": "test-signature",
-                    },
-                )
-
-                assert response.status_code == 422  # Validation error
-
-
-class TestWebhookEventValidation:
-    """Test webhook event data validation."""
-
-    def test_daily_webhook_event_validation_valid(self):
-        """Test valid webhook event passes validation."""
-        event_data = {
-            "type": "participant.joined",
-            "id": "evt_123",
-            "ts": 1640995200000,  # milliseconds
-            "data": {
-                "room": {"name": "test-room"},
-                "participant": {
-                    "id": "participant-123",
-                    "user_name": "John Doe",
-                    "session_id": "session-456",
-                },
-            },
-        }
-
-        event = DailyWebhookEvent(**event_data)
-        assert event.type == "participant.joined"
-        assert event.data["room"]["name"] == "test-room"
-        assert event.data["participant"]["id"] == "participant-123"
-
-    def test_daily_webhook_event_validation_minimal(self):
-        """Test minimal valid webhook event."""
-        event_data = {
-            "type": "room.created",
-            "id": "evt_123",
-            "ts": 1640995200000,
-            "data": {"room": {"name": "test-room"}},
-        }
-
-        event = DailyWebhookEvent(**event_data)
-        assert event.type == "room.created"
-        assert event.data["room"]["name"] == "test-room"
-
-    def test_daily_webhook_event_validation_with_recording(self):
-        """Test webhook event with recording data."""
-        event_data = {
-            "type": "recording.ready-to-download",
-            "id": "evt_123",
-            "ts": 1640995200000,
-            "data": {
-                "room": {"name": "test-room"},
-                "recording": {
-                    "id": "recording-123",
-                    "status": "finished",
-                    "download_url": "https://example.com/recording.mp4",
-                    "start_time": "2025-01-01T10:00:00Z",
-                    "duration": 1800,
-                },
-            },
-        }
-
-        event = DailyWebhookEvent(**event_data)
-        assert event.type == "recording.ready-to-download"
-        assert event.data["recording"]["id"] == "recording-123"
-        assert (
-            event.data["recording"]["download_url"]
-            == "https://example.com/recording.mp4"
-        )
--- a/server/tests/test_gpu_modal_transcript.py
+++ b/server/tests/test_gpu_modal_transcript.py
@@ -0,0 +1,330 @@
+"""
+Tests for GPU Modal transcription endpoints.
+
+These tests are marked with the "gpu-modal" group and will not run by default.
+Run them with: pytest -m gpu-modal tests/test_gpu_modal_transcript_parakeet.py
+
+Required environment variables:
+- TRANSCRIPT_URL: URL to the Modal.com endpoint (required)
+- TRANSCRIPT_MODAL_API_KEY: API key for authentication (optional)
+- TRANSCRIPT_MODEL: Model name to use (optional, defaults to nvidia/parakeet-tdt-0.6b-v2)
+
+Example with pytest (override default addopts to run ONLY gpu_modal tests):
+    TRANSCRIPT_URL=https://monadical-sas--reflector-transcriber-parakeet-web-dev.modal.run \
+    TRANSCRIPT_MODAL_API_KEY=your-api-key \
+    uv run -m pytest -m gpu_modal --no-cov tests/test_gpu_modal_transcript.py
+
+    # Or with completely clean options:
+    uv run -m pytest -m gpu_modal -o addopts="" tests/
+
+Running Modal locally for testing:
+    modal serve gpu/modal_deployments/reflector_transcriber_parakeet.py
+    # This will give you a local URL like https://xxxxx--reflector-transcriber-parakeet-web-dev.modal.run to test against
+"""
+
+import os
+import tempfile
+from pathlib import Path
+
+import httpx
+import pytest
+
+# Test audio file URL for testing
+TEST_AUDIO_URL = (
+    "https://reflector-github-pytest.s3.us-east-1.amazonaws.com/test_mathieu_hello.mp3"
+)
+
+
+def get_modal_transcript_url():
+    """Get and validate the Modal transcript URL from environment."""
+    url = os.environ.get("TRANSCRIPT_URL")
+    if not url:
+        pytest.skip(
+            "TRANSCRIPT_URL environment variable is required for GPU Modal tests"
+        )
+    return url
+
+
+def get_auth_headers():
+    """Get authentication headers if API key is available."""
+    api_key = os.environ.get("TRANSCRIPT_MODAL_API_KEY")
+    if api_key:
+        return {"Authorization": f"Bearer {api_key}"}
+    return {}
+
+
+def get_model_name():
+    """Get the model name from environment or use default."""
+    return os.environ.get("TRANSCRIPT_MODEL", "nvidia/parakeet-tdt-0.6b-v2")
+
+
+@pytest.mark.gpu_modal
+class TestGPUModalTranscript:
+    """Test suite for GPU Modal transcription endpoints."""
+
+    def test_transcriptions_from_url(self):
+        """Test the /v1/audio/transcriptions-from-url endpoint."""
+        url = get_modal_transcript_url()
+        headers = get_auth_headers()
+
+        with httpx.Client(timeout=60.0) as client:
+            response = client.post(
+                f"{url}/v1/audio/transcriptions-from-url",
+                json={
+                    "audio_file_url": TEST_AUDIO_URL,
+                    "model": get_model_name(),
+                    "language": "en",
+                    "timestamp_offset": 0.0,
+                },
+                headers=headers,
+            )
+
+            assert response.status_code == 200, f"Request failed: {response.text}"
+            result = response.json()
+
+            # Verify response structure
+            assert "text" in result
+            assert "words" in result
+            assert isinstance(result["text"], str)
+            assert isinstance(result["words"], list)
+
+            # Verify content is meaningful
+            assert len(result["text"]) > 0, "Transcript text should not be empty"
+            assert len(result["words"]) > 0, "Words list must not be empty"
+
+            # Verify word structure
+            for word in result["words"]:
+                assert "word" in word
+                assert "start" in word
+                assert "end" in word
+                assert isinstance(word["start"], (int, float))
+                assert isinstance(word["end"], (int, float))
+                assert word["start"] <= word["end"]
+
+    def test_transcriptions_single_file(self):
+        """Test the /v1/audio/transcriptions endpoint with a single file."""
+        url = get_modal_transcript_url()
+        headers = get_auth_headers()
+
+        # Download test audio file to upload
+        with httpx.Client(timeout=60.0) as client:
+            audio_response = client.get(TEST_AUDIO_URL)
+            audio_response.raise_for_status()
+
+            with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as tmp_file:
+                tmp_file.write(audio_response.content)
+                tmp_file_path = tmp_file.name
+
+            try:
+                # Upload the file for transcription
+                with open(tmp_file_path, "rb") as f:
+                    files = {"file": ("test_audio.mp3", f, "audio/mpeg")}
+                    data = {
+                        "model": get_model_name(),
+                        "language": "en",
+                        "batch": "false",
+                    }
+
+                    response = client.post(
+                        f"{url}/v1/audio/transcriptions",
+                        files=files,
+                        data=data,
+                        headers=headers,
+                    )
+
+                assert response.status_code == 200, f"Request failed: {response.text}"
+                result = response.json()
+
+                # Verify response structure for single file
+                assert "text" in result
+                assert "words" in result
+                assert "filename" in result
+                assert isinstance(result["text"], str)
+                assert isinstance(result["words"], list)
+
+                # Verify content
+                assert len(result["text"]) > 0, "Transcript text should not be empty"
+
+            finally:
+                Path(tmp_file_path).unlink(missing_ok=True)
+
+    def test_transcriptions_multiple_files(self):
+        """Test the /v1/audio/transcriptions endpoint with multiple files (non-batch mode)."""
+        url = get_modal_transcript_url()
+        headers = get_auth_headers()
+
+        # Create multiple test files (we'll use the same audio content for simplicity)
+        with httpx.Client(timeout=60.0) as client:
+            audio_response = client.get(TEST_AUDIO_URL)
+            audio_response.raise_for_status()
+            audio_content = audio_response.content
+
+            temp_files = []
+            try:
+                # Create 3 temporary files
+                for i in range(3):
+                    tmp_file = tempfile.NamedTemporaryFile(suffix=".mp3", delete=False)
+                    tmp_file.write(audio_content)
+                    tmp_file.close()
+                    temp_files.append(tmp_file.name)
+
+                # Upload multiple files for transcription (non-batch)
+                files = [
+                    ("files", (f"test_audio_{i}.mp3", open(f, "rb"), "audio/mpeg"))
+                    for i, f in enumerate(temp_files)
+                ]
+                data = {
+                    "model": get_model_name(),
+                    "language": "en",
+                    "batch": "false",
+                }
+
+                response = client.post(
+                    f"{url}/v1/audio/transcriptions",
+                    files=files,
+                    data=data,
+                    headers=headers,
+                )
+
+                # Close file handles
+                for _, file_tuple in files:
+                    file_tuple[1].close()
+
+                assert response.status_code == 200, f"Request failed: {response.text}"
+                result = response.json()
+
+                # Verify response structure for multiple files (non-batch)
+                assert "results" in result
+                assert isinstance(result["results"], list)
+                assert len(result["results"]) == 3
+
+                for idx, file_result in enumerate(result["results"]):
+                    assert "text" in file_result
+                    assert "words" in file_result
+                    assert "filename" in file_result
+                    assert isinstance(file_result["text"], str)
+                    assert isinstance(file_result["words"], list)
+                    assert len(file_result["text"]) > 0
+
+            finally:
+                for f in temp_files:
+                    Path(f).unlink(missing_ok=True)
+
+    def test_transcriptions_multiple_files_batch(self):
+        """Test the /v1/audio/transcriptions endpoint with multiple files in batch mode."""
+        url = get_modal_transcript_url()
+        headers = get_auth_headers()
+
+        # Create multiple test files
+        with httpx.Client(timeout=60.0) as client:
+            audio_response = client.get(TEST_AUDIO_URL)
+            audio_response.raise_for_status()
+            audio_content = audio_response.content
+
+            temp_files = []
+            try:
+                # Create 3 temporary files
+                for i in range(3):
+                    tmp_file = tempfile.NamedTemporaryFile(suffix=".mp3", delete=False)
+                    tmp_file.write(audio_content)
+                    tmp_file.close()
+                    temp_files.append(tmp_file.name)
+
+                # Upload multiple files for batch transcription
+                files = [
+                    ("files", (f"test_audio_{i}.mp3", open(f, "rb"), "audio/mpeg"))
+                    for i, f in enumerate(temp_files)
+                ]
+                data = {
+                    "model": get_model_name(),
+                    "language": "en",
+                    "batch": "true",
+                }
+
+                response = client.post(
+                    f"{url}/v1/audio/transcriptions",
+                    files=files,
+                    data=data,
+                    headers=headers,
+                )
+
+                # Close file handles
+                for _, file_tuple in files:
+                    file_tuple[1].close()
+
+                assert response.status_code == 200, f"Request failed: {response.text}"
+                result = response.json()
+
+                # Verify response structure for batch mode
+                assert "results" in result
+                assert isinstance(result["results"], list)
+                assert len(result["results"]) == 3
+
+                for idx, batch_result in enumerate(result["results"]):
+                    assert "text" in batch_result
+                    assert "words" in batch_result
+                    assert "filename" in batch_result
+                    assert isinstance(batch_result["text"], str)
+                    assert isinstance(batch_result["words"], list)
+                    assert len(batch_result["text"]) > 0
+
+            finally:
+                for f in temp_files:
+                    Path(f).unlink(missing_ok=True)
+
+    def test_transcriptions_error_handling(self):
+        """Test error handling for invalid requests."""
+        url = get_modal_transcript_url()
+        headers = get_auth_headers()
+
+        with httpx.Client(timeout=60.0) as client:
+            # Test with unsupported language
+            response = client.post(
+                f"{url}/v1/audio/transcriptions-from-url",
+                json={
+                    "audio_file_url": TEST_AUDIO_URL,
+                    "model": get_model_name(),
+                    "language": "fr",  # Parakeet only supports English
+                    "timestamp_offset": 0.0,
+                },
+                headers=headers,
+            )
+
+            assert response.status_code == 400
+            assert "only supports English" in response.text
+
+    def test_transcriptions_with_timestamp_offset(self):
+        """Test transcription with timestamp offset parameter."""
+        url = get_modal_transcript_url()
+        headers = get_auth_headers()
+
+        with httpx.Client(timeout=60.0) as client:
+            # Test with timestamp offset
+            response = client.post(
+                f"{url}/v1/audio/transcriptions-from-url",
+                json={
+                    "audio_file_url": TEST_AUDIO_URL,
+                    "model": get_model_name(),
+                    "language": "en",
+                    "timestamp_offset": 10.0,  # Add 10 second offset
+                },
+                headers=headers,
+            )
+
+            assert response.status_code == 200, f"Request failed: {response.text}"
+            result = response.json()
+
+            # Verify response structure
+            assert "text" in result
+            assert "words" in result
+            assert len(result["words"]) > 0, "Words list must not be empty"
+
+            # Verify that timestamps have been offset
+            for word in result["words"]:
+                # All timestamps should be >= 10.0 due to offset
+                assert (
+                    word["start"] >= 10.0
+                ), f"Word start time {word['start']} should be >= 10.0"
+                assert (
+                    word["end"] >= 10.0
+                ), f"Word end time {word['end']} should be >= 10.0"
--- a/server/tests/test_pipeline_main_file.py
+++ b/server/tests/test_pipeline_main_file.py
@@ -0,0 +1,633 @@
+"""
+Tests for PipelineMainFile - file-based processing pipeline
+
+This test verifies the complete file processing pipeline without mocking much,
+ensuring all processors are correctly invoked and the happy path works correctly.
+"""
+
+from pathlib import Path
+from unittest.mock import AsyncMock, MagicMock, patch
+from uuid import uuid4
+
+import pytest
+
+from reflector.pipelines.main_file_pipeline import PipelineMainFile
+from reflector.processors.file_diarization import FileDiarizationOutput
+from reflector.processors.types import (
+    DiarizationSegment,
+    TitleSummary,
+    Word,
+)
+from reflector.processors.types import (
+    Transcript as TranscriptType,
+)
+
+
+@pytest.fixture
+async def dummy_file_transcript():
+    """Mock FileTranscriptAutoProcessor for file processing"""
+    from reflector.processors.file_transcript import FileTranscriptProcessor
+
+    class TestFileTranscriptProcessor(FileTranscriptProcessor):
+        async def _transcript(self, data):
+            return TranscriptType(
+                text="Hello world. How are you today?",
+                words=[
+                    Word(start=0.0, end=0.5, text="Hello", speaker=0),
+                    Word(start=0.5, end=0.6, text=" ", speaker=0),
+                    Word(start=0.6, end=1.0, text="world", speaker=0),
+                    Word(start=1.0, end=1.1, text=".", speaker=0),
+                    Word(start=1.1, end=1.2, text=" ", speaker=0),
+                    Word(start=1.2, end=1.5, text="How", speaker=0),
+                    Word(start=1.5, end=1.6, text=" ", speaker=0),
+                    Word(start=1.6, end=1.8, text="are", speaker=0),
+                    Word(start=1.8, end=1.9, text=" ", speaker=0),
+                    Word(start=1.9, end=2.1, text="you", speaker=0),
+                    Word(start=2.1, end=2.2, text=" ", speaker=0),
+                    Word(start=2.2, end=2.5, text="today", speaker=0),
+                    Word(start=2.5, end=2.6, text="?", speaker=0),
+                ],
+            )
+
+    with patch(
+        "reflector.processors.file_transcript_auto.FileTranscriptAutoProcessor.__new__"
+    ) as mock_auto:
+        mock_auto.return_value = TestFileTranscriptProcessor()
+        yield
+
+
+@pytest.fixture
+async def dummy_file_diarization():
+    """Mock FileDiarizationAutoProcessor for file processing"""
+    from reflector.processors.file_diarization import FileDiarizationProcessor
+
+    class TestFileDiarizationProcessor(FileDiarizationProcessor):
+        async def _diarize(self, data):
+            return FileDiarizationOutput(
+                diarization=[
+                    DiarizationSegment(start=0.0, end=1.1, speaker=0),
+                    DiarizationSegment(start=1.2, end=2.6, speaker=1),
+                ]
+            )
+
+    with patch(
+        "reflector.processors.file_diarization_auto.FileDiarizationAutoProcessor.__new__"
+    ) as mock_auto:
+        mock_auto.return_value = TestFileDiarizationProcessor()
+        yield
+
+
+@pytest.fixture
+async def mock_transcript_in_db(tmpdir):
+    """Create a mock transcript in the database"""
+    from reflector.db.transcripts import Transcript
+    from reflector.settings import settings
+
+    # Set the DATA_DIR to our tmpdir
+    original_data_dir = settings.DATA_DIR
+    settings.DATA_DIR = str(tmpdir)
+
+    transcript_id = str(uuid4())
+    data_path = Path(tmpdir) / transcript_id
+    data_path.mkdir(parents=True, exist_ok=True)
+
+    # Create mock transcript object
+    transcript = Transcript(
+        id=transcript_id,
+        name="Test Transcript",
+        status="processing",
+        source_kind="file",
+        source_language="en",
+        target_language="en",
+    )
+
+    # Mock the controller to return our transcript
+    try:
+        with patch(
+            "reflector.pipelines.main_file_pipeline.transcripts_controller.get_by_id"
+        ) as mock_get:
+            mock_get.return_value = transcript
+            with patch(
+                "reflector.pipelines.main_live_pipeline.transcripts_controller.get_by_id"
+            ) as mock_get2:
+                mock_get2.return_value = transcript
+                with patch(
+                    "reflector.pipelines.main_live_pipeline.transcripts_controller.update"
+                ) as mock_update:
+                    mock_update.return_value = None
+                    yield transcript
+    finally:
+        # Restore original DATA_DIR
+        settings.DATA_DIR = original_data_dir
+
+
+@pytest.fixture
+async def mock_storage():
+    """Mock storage for file uploads"""
+    from reflector.storage.base import Storage
+
+    class TestStorage(Storage):
+        async def _put_file(self, path, data):
+            return None
+
+        async def _get_file_url(self, path):
+            return f"http://test-storage/{path}"
+
+        async def _get_file(self, path):
+            return b"test_audio_data"
+
+        async def _delete_file(self, path):
+            return None
+
+    storage = TestStorage()
+    # Add mock tracking for verification
+    storage._put_file = AsyncMock(side_effect=storage._put_file)
+    storage._get_file_url = AsyncMock(side_effect=storage._get_file_url)
+
+    with patch(
+        "reflector.pipelines.main_file_pipeline.get_transcripts_storage"
+    ) as mock_get:
+        mock_get.return_value = storage
+        yield storage
+
+
+@pytest.fixture
+async def mock_audio_file_writer():
+    """Mock AudioFileWriterProcessor to avoid actual file writing"""
+    with patch(
+        "reflector.pipelines.main_file_pipeline.AudioFileWriterProcessor"
+    ) as mock_writer_class:
+        mock_writer = AsyncMock()
+        mock_writer.push = AsyncMock()
+        mock_writer.flush = AsyncMock()
+        mock_writer_class.return_value = mock_writer
+        yield mock_writer
+
+
+@pytest.fixture
+async def mock_waveform_processor():
+    """Mock AudioWaveformProcessor"""
+    with patch(
+        "reflector.pipelines.main_file_pipeline.AudioWaveformProcessor"
+    ) as mock_waveform_class:
+        mock_waveform = AsyncMock()
+        mock_waveform.set_pipeline = MagicMock()
+        mock_waveform.flush = AsyncMock()
+        mock_waveform_class.return_value = mock_waveform
+        yield mock_waveform
+
+
+@pytest.fixture
+async def mock_topic_detector():
+    """Mock TranscriptTopicDetectorProcessor"""
+    with patch(
+        "reflector.pipelines.main_file_pipeline.TranscriptTopicDetectorProcessor"
+    ) as mock_topic_class:
+        mock_topic = AsyncMock()
+        mock_topic.set_pipeline = MagicMock()
+        mock_topic.push = AsyncMock()
+        mock_topic.flush_called = False
+
+        # When flush is called, simulate topic detection by calling the callback
+        async def flush_with_callback():
+            mock_topic.flush_called = True
+            if hasattr(mock_topic, "_callback"):
+                # Create a minimal transcript for the TitleSummary
+                test_transcript = TranscriptType(words=[], text="test transcript")
+                await mock_topic._callback(
+                    TitleSummary(
+                        title="Test Topic",
+                        summary="Test topic summary",
+                        timestamp=0.0,
+                        duration=10.0,
+                        transcript=test_transcript,
+                    )
+                )
+
+        mock_topic.flush = flush_with_callback
+
+        def init_with_callback(callback=None):
+            mock_topic._callback = callback
+            return mock_topic
+
+        mock_topic_class.side_effect = init_with_callback
+        yield mock_topic
+
+
+@pytest.fixture
+async def mock_title_processor():
+    """Mock TranscriptFinalTitleProcessor"""
+    with patch(
+        "reflector.pipelines.main_file_pipeline.TranscriptFinalTitleProcessor"
+    ) as mock_title_class:
+        mock_title = AsyncMock()
+        mock_title.set_pipeline = MagicMock()
+        mock_title.push = AsyncMock()
+        mock_title.flush_called = False
+
+        # When flush is called, simulate title generation by calling the callback
+        async def flush_with_callback():
+            mock_title.flush_called = True
+            if hasattr(mock_title, "_callback"):
+                from reflector.processors.types import FinalTitle
+
+                await mock_title._callback(FinalTitle(title="Test Title"))
+
+        mock_title.flush = flush_with_callback
+
+        def init_with_callback(callback=None):
+            mock_title._callback = callback
+            return mock_title
+
+        mock_title_class.side_effect = init_with_callback
+        yield mock_title
+
+
+@pytest.fixture
+async def mock_summary_processor():
+    """Mock TranscriptFinalSummaryProcessor"""
+    with patch(
+        "reflector.pipelines.main_file_pipeline.TranscriptFinalSummaryProcessor"
+    ) as mock_summary_class:
+        mock_summary = AsyncMock()
+        mock_summary.set_pipeline = MagicMock()
+        mock_summary.push = AsyncMock()
+        mock_summary.flush_called = False
+
+        # When flush is called, simulate summary generation by calling the callbacks
+        async def flush_with_callback():
+            mock_summary.flush_called = True
+            from reflector.processors.types import FinalLongSummary, FinalShortSummary
+
+            if hasattr(mock_summary, "_callback"):
+                await mock_summary._callback(
+                    FinalLongSummary(long_summary="Test long summary", duration=10.0)
+                )
+            if hasattr(mock_summary, "_on_short_summary"):
+                await mock_summary._on_short_summary(
+                    FinalShortSummary(short_summary="Test short summary", duration=10.0)
+                )
+
+        mock_summary.flush = flush_with_callback
+
+        def init_with_callback(transcript=None, callback=None, on_short_summary=None):
+            mock_summary._callback = callback
+            mock_summary._on_short_summary = on_short_summary
+            return mock_summary
+
+        mock_summary_class.side_effect = init_with_callback
+        yield mock_summary
+
+
+@pytest.mark.asyncio
+async def test_pipeline_main_file_process(
+    tmpdir,
+    mock_transcript_in_db,
+    dummy_file_transcript,
+    dummy_file_diarization,
+    mock_storage,
+    mock_audio_file_writer,
+    mock_waveform_processor,
+    mock_topic_detector,
+    mock_title_processor,
+    mock_summary_processor,
+):
+    """
+    Test the complete PipelineMainFile processing pipeline.
+
+    This test verifies:
+    1. Audio extraction and writing
+    2. Audio upload to storage
+    3. Parallel processing of transcription, diarization, and waveform
+    4. Assembly of transcript with diarization
+    5. Topic detection
+    6. Title and summary generation
+    """
+    # Create a test audio file
+    test_audio_path = Path(__file__).parent / "records" / "test_mathieu_hello.wav"
+
+    # Copy test audio to the transcript's data path as if it was uploaded
+    upload_path = mock_transcript_in_db.data_path / "upload.wav"
+    upload_path.write_bytes(test_audio_path.read_bytes())
+
+    # Also create the audio.mp3 file that would be created by AudioFileWriterProcessor
+    # Since we're mocking AudioFileWriterProcessor, we need to create this manually
+    mp3_path = mock_transcript_in_db.data_path / "audio.mp3"
+    mp3_path.write_bytes(b"mock_mp3_data")
+
+    # Track callback invocations
+    callback_marks = {
+        "on_status": [],
+        "on_duration": [],
+        "on_waveform": [],
+        "on_topic": [],
+        "on_title": [],
+        "on_long_summary": [],
+        "on_short_summary": [],
+    }
+
+    # Create pipeline with mocked callbacks
+    pipeline = PipelineMainFile(transcript_id=mock_transcript_in_db.id)
+
+    # Override callbacks to track invocations
+    async def track_callback(name, data):
+        callback_marks[name].append(data)
+        # Call the original callback
+        original = getattr(PipelineMainFile, name)
+        return await original(pipeline, data)
+
+    for callback_name in callback_marks.keys():
+        setattr(
+            pipeline,
+            callback_name,
+            lambda data, n=callback_name: track_callback(n, data),
+        )
+
+    # Mock av.open for audio processing
+    with patch("reflector.pipelines.main_file_pipeline.av.open") as mock_av:
+        # Mock container for checking video streams
+        mock_container = MagicMock()
+        mock_container.streams.video = []  # No video streams (audio only)
+        mock_container.close = MagicMock()
+
+        # Mock container for decoding audio frames
+        mock_decode_container = MagicMock()
+        mock_decode_container.decode.return_value = iter(
+            [MagicMock()]
+        )  # One mock audio frame
+        mock_decode_container.close = MagicMock()
+
+        # Return different containers for different calls
+        mock_av.side_effect = [mock_container, mock_decode_container]
+
+        # Run the pipeline
+        await pipeline.process(upload_path)
+
+    # Verify audio extraction and writing
+    assert mock_audio_file_writer.push.called
+    assert mock_audio_file_writer.flush.called
+
+    # Verify storage upload
+    assert mock_storage._put_file.called
+    assert mock_storage._get_file_url.called
+
+    # Verify waveform generation
+    assert mock_waveform_processor.flush.called
+    assert mock_waveform_processor.set_pipeline.called
+
+    # Verify topic detection
+    assert mock_topic_detector.push.called
+    assert mock_topic_detector.flush_called
+
+    # Verify title generation
+    assert mock_title_processor.push.called
+    assert mock_title_processor.flush_called
+
+    # Verify summary generation
+    assert mock_summary_processor.push.called
+    assert mock_summary_processor.flush_called
+
+    # Verify callbacks were invoked
+    assert len(callback_marks["on_topic"]) > 0, "Topic callback should be invoked"
+    assert len(callback_marks["on_title"]) > 0, "Title callback should be invoked"
+    assert (
+        len(callback_marks["on_long_summary"]) > 0
+    ), "Long summary callback should be invoked"
+    assert (
+        len(callback_marks["on_short_summary"]) > 0
+    ), "Short summary callback should be invoked"
+
+    print(f"Callback marks: {callback_marks}")
+
+    # Verify the pipeline completed successfully
+    assert pipeline.logger is not None
+    print("PipelineMainFile test completed successfully!")
+
+
+@pytest.mark.asyncio
+async def test_pipeline_main_file_with_video(
+    tmpdir,
+    mock_transcript_in_db,
+    dummy_file_transcript,
+    dummy_file_diarization,
+    mock_storage,
+    mock_audio_file_writer,
+    mock_waveform_processor,
+    mock_topic_detector,
+    mock_title_processor,
+    mock_summary_processor,
+):
+    """
+    Test PipelineMainFile with video input (verifies audio extraction).
+    """
+    # Create a test audio file
+    test_audio_path = Path(__file__).parent / "records" / "test_mathieu_hello.wav"
+
+    # Copy test audio to the transcript's data path as if it was a video upload
+    upload_path = mock_transcript_in_db.data_path / "upload.mp4"
+    upload_path.write_bytes(test_audio_path.read_bytes())
+
+    # Also create the audio.mp3 file that would be created by AudioFileWriterProcessor
+    mp3_path = mock_transcript_in_db.data_path / "audio.mp3"
+    mp3_path.write_bytes(b"mock_mp3_data")
+
+    # Create pipeline
+    pipeline = PipelineMainFile(transcript_id=mock_transcript_in_db.id)
+
+    # Mock av.open for video processing
+    with patch("reflector.pipelines.main_file_pipeline.av.open") as mock_av:
+        # Mock container for checking video streams
+        mock_container = MagicMock()
+        mock_container.streams.video = [MagicMock()]  # Has video streams
+        mock_container.close = MagicMock()
+
+        # Mock container for decoding audio frames
+        mock_decode_container = MagicMock()
+        mock_decode_container.decode.return_value = iter(
+            [MagicMock()]
+        )  # One mock audio frame
+        mock_decode_container.close = MagicMock()
+
+        # Return different containers for different calls
+        mock_av.side_effect = [mock_container, mock_decode_container]
+
+        # Run the pipeline
+        await pipeline.process(upload_path)
+
+    # Verify audio extraction from video
+    assert mock_audio_file_writer.push.called
+    assert mock_audio_file_writer.flush.called
+
+    # Verify the rest of the pipeline completed
+    assert mock_storage._put_file.called
+    assert mock_waveform_processor.flush.called
+    assert mock_topic_detector.push.called
+    assert mock_title_processor.push.called
+    assert mock_summary_processor.push.called
+
+    print("PipelineMainFile video test completed successfully!")
+
+
+@pytest.mark.asyncio
+async def test_pipeline_main_file_no_diarization(
+    tmpdir,
+    mock_transcript_in_db,
+    dummy_file_transcript,
+    mock_storage,
+    mock_audio_file_writer,
+    mock_waveform_processor,
+    mock_topic_detector,
+    mock_title_processor,
+    mock_summary_processor,
+):
+    """
+    Test PipelineMainFile with diarization disabled.
+    """
+    from reflector.settings import settings
+
+    # Disable diarization
+    with patch.object(settings, "DIARIZATION_BACKEND", None):
+        # Create a test audio file
+        test_audio_path = Path(__file__).parent / "records" / "test_mathieu_hello.wav"
+
+        # Copy test audio to the transcript's data path
+        upload_path = mock_transcript_in_db.data_path / "upload.wav"
+        upload_path.write_bytes(test_audio_path.read_bytes())
+
+        # Also create the audio.mp3 file
+        mp3_path = mock_transcript_in_db.data_path / "audio.mp3"
+        mp3_path.write_bytes(b"mock_mp3_data")
+
+        # Create pipeline
+        pipeline = PipelineMainFile(transcript_id=mock_transcript_in_db.id)
+
+        # Mock av.open for audio processing
+        with patch("reflector.pipelines.main_file_pipeline.av.open") as mock_av:
+            # Mock container for checking video streams
+            mock_container = MagicMock()
+            mock_container.streams.video = []  # No video streams
+            mock_container.close = MagicMock()
+
+            # Mock container for decoding audio frames
+            mock_decode_container = MagicMock()
+            mock_decode_container.decode.return_value = iter([MagicMock()])
+            mock_decode_container.close = MagicMock()
+
+            # Return different containers for different calls
+            mock_av.side_effect = [mock_container, mock_decode_container]
+
+            # Run the pipeline
+            await pipeline.process(upload_path)
+
+        # Verify the pipeline completed without diarization
+        assert mock_storage._put_file.called
+        assert mock_waveform_processor.flush.called
+        assert mock_topic_detector.push.called
+        assert mock_title_processor.push.called
+        assert mock_summary_processor.push.called
+
+        print("PipelineMainFile no-diarization test completed successfully!")
+
+
+@pytest.mark.asyncio
+async def test_task_pipeline_file_process(
+    tmpdir,
+    mock_transcript_in_db,
+    dummy_file_transcript,
+    dummy_file_diarization,
+    mock_storage,
+    mock_audio_file_writer,
+    mock_waveform_processor,
+    mock_topic_detector,
+    mock_title_processor,
+    mock_summary_processor,
+):
+    """
+    Test the Celery task entry point for file pipeline processing.
+    """
+    # Direct import of the underlying async function, bypassing the asynctask decorator
+
+    # Create a test audio file in the transcript's data path
+    test_audio_path = Path(__file__).parent / "records" / "test_mathieu_hello.wav"
+    upload_path = mock_transcript_in_db.data_path / "upload.wav"
+    upload_path.write_bytes(test_audio_path.read_bytes())
+
+    # Also create the audio.mp3 file
+    mp3_path = mock_transcript_in_db.data_path / "audio.mp3"
+    mp3_path.write_bytes(b"mock_mp3_data")
+
+    # Mock av.open for audio processing
+    with patch("reflector.pipelines.main_file_pipeline.av.open") as mock_av:
+        # Mock container for checking video streams
+        mock_container = MagicMock()
+        mock_container.streams.video = []  # No video streams
+        mock_container.close = MagicMock()
+
+        # Mock container for decoding audio frames
+        mock_decode_container = MagicMock()
+        mock_decode_container.decode.return_value = iter([MagicMock()])
+        mock_decode_container.close = MagicMock()
+
+        # Return different containers for different calls
+        mock_av.side_effect = [mock_container, mock_decode_container]
+
+        # Get the original async function without the asynctask decorator
+        # The function is wrapped, so we need to call it differently
+        # For now, we test the pipeline directly since the task is just a thin wrapper
+        from reflector.pipelines.main_file_pipeline import PipelineMainFile
+
+        pipeline = PipelineMainFile(transcript_id=mock_transcript_in_db.id)
+        await pipeline.process(upload_path)
+
+    # Verify the pipeline was executed through the task
+    assert mock_audio_file_writer.push.called
+    assert mock_audio_file_writer.flush.called
+    assert mock_storage._put_file.called
+    assert mock_waveform_processor.flush.called
+    assert mock_topic_detector.push.called
+    assert mock_title_processor.push.called
+    assert mock_summary_processor.push.called
+
+    print("task_pipeline_file_process test completed successfully!")
+
+
+@pytest.mark.asyncio
+async def test_pipeline_file_process_no_transcript():
+    """
+    Test the pipeline with a non-existent transcript.
+    """
+    from reflector.pipelines.main_file_pipeline import PipelineMainFile
+
+    # Mock the controller to return None (transcript not found)
+    with patch(
+        "reflector.pipelines.main_file_pipeline.transcripts_controller.get_by_id"
+    ) as mock_get:
+        mock_get.return_value = None
+
+        pipeline = PipelineMainFile(transcript_id=str(uuid4()))
+
+        # Should raise an exception for missing transcript when get_transcript is called
+        with pytest.raises(Exception, match="Transcript not found"):
+            await pipeline.get_transcript()
+
+
+@pytest.mark.asyncio
+async def test_pipeline_file_process_no_audio_file(
+    mock_transcript_in_db,
+):
+    """
+    Test the pipeline when no audio file is found.
+    """
+    from reflector.pipelines.main_file_pipeline import PipelineMainFile
+
+    # Don't create any audio files in the data path
+    # The pipeline's process should handle missing files gracefully
+
+    pipeline = PipelineMainFile(transcript_id=mock_transcript_in_db.id)
+
+    # Try to process a non-existent file
+    non_existent_path = mock_transcript_in_db.data_path / "nonexistent.wav"
+
+    # This should fail when trying to open the file with av
+    with pytest.raises(Exception):
+        await pipeline.process(non_existent_path)
--- a/server/tests/test_processors_modal.py
+++ b/server/tests/test_processors_modal.py
@@ -0,0 +1,265 @@
+"""
+Tests for Modal-based processors using pytest-recording for HTTP recording/playbook
+
+Note: theses tests require full modal configuration to be able to record
+      vcr cassettes
+
+Configuration required for the first recording:
+- TRANSCRIPT_BACKEND=modal
+- TRANSCRIPT_URL=https://xxxxx--reflector-transcriber-parakeet-web.modal.run
+- TRANSCRIPT_MODAL_API_KEY=xxxxx
+- DIARIZATION_BACKEND=modal
+- DIARIZATION_URL=https://xxxxx--reflector-diarizer-web.modal.run
+- DIARIZATION_MODAL_API_KEY=xxxxx
+"""
+
+from unittest.mock import patch
+
+import pytest
+
+from reflector.processors.file_diarization import FileDiarizationInput
+from reflector.processors.file_diarization_modal import FileDiarizationModalProcessor
+from reflector.processors.file_transcript import FileTranscriptInput
+from reflector.processors.file_transcript_modal import FileTranscriptModalProcessor
+from reflector.processors.transcript_diarization_assembler import (
+    TranscriptDiarizationAssemblerInput,
+    TranscriptDiarizationAssemblerProcessor,
+)
+from reflector.processors.types import DiarizationSegment, Transcript, Word
+
+# Public test audio file hosted on S3 specifically for reflector pytests
+TEST_AUDIO_URL = (
+    "https://reflector-github-pytest.s3.us-east-1.amazonaws.com/test_mathieu_hello.mp3"
+)
+
+
+@pytest.mark.asyncio
+async def test_file_transcript_modal_processor_missing_url():
+    with patch("reflector.processors.file_transcript_modal.settings") as mock_settings:
+        mock_settings.TRANSCRIPT_URL = None
+        with pytest.raises(Exception, match="TRANSCRIPT_URL required"):
+            FileTranscriptModalProcessor(modal_api_key="test-api-key")
+
+
+@pytest.mark.asyncio
+async def test_file_diarization_modal_processor_missing_url():
+    with patch("reflector.processors.file_diarization_modal.settings") as mock_settings:
+        mock_settings.DIARIZATION_URL = None
+        with pytest.raises(Exception, match="DIARIZATION_URL required"):
+            FileDiarizationModalProcessor(modal_api_key="test-api-key")
+
+
+@pytest.mark.vcr()
+@pytest.mark.asyncio
+async def test_file_diarization_modal_processor(vcr):
+    """Test FileDiarizationModalProcessor using public audio URL and Modal API"""
+    from reflector.settings import settings
+
+    processor = FileDiarizationModalProcessor(
+        modal_api_key=settings.DIARIZATION_MODAL_API_KEY
+    )
+
+    test_input = FileDiarizationInput(audio_url=TEST_AUDIO_URL)
+    result = await processor._diarize(test_input)
+
+    # Verify the result structure
+    assert result is not None
+    assert hasattr(result, "diarization")
+    assert isinstance(result.diarization, list)
+
+    # Check structure of each diarization segment
+    for segment in result.diarization:
+        assert "start" in segment
+        assert "end" in segment
+        assert "speaker" in segment
+        assert isinstance(segment["start"], (int, float))
+        assert isinstance(segment["end"], (int, float))
+        assert isinstance(segment["speaker"], int)
+        # Basic sanity check - start should be before end
+        assert segment["start"] < segment["end"]
+
+
+@pytest.mark.vcr()
+@pytest.mark.asyncio
+async def test_file_transcript_modal_processor():
+    """Test FileTranscriptModalProcessor using public audio URL and Modal API"""
+    from reflector.settings import settings
+
+    processor = FileTranscriptModalProcessor(
+        modal_api_key=settings.TRANSCRIPT_MODAL_API_KEY
+    )
+
+    test_input = FileTranscriptInput(
+        audio_url=TEST_AUDIO_URL,
+        language="en",
+    )
+
+    # This will record the HTTP interaction on first run, replay on subsequent runs
+    result = await processor._transcript(test_input)
+
+    # Verify the result structure
+    assert result is not None
+    assert hasattr(result, "words")
+    assert isinstance(result.words, list)
+
+    # Check structure of each word if present
+    for word in result.words:
+        assert hasattr(word, "text")
+        assert hasattr(word, "start")
+        assert hasattr(word, "end")
+        assert isinstance(word.start, (int, float))
+        assert isinstance(word.end, (int, float))
+        assert isinstance(word.text, str)
+        # Basic sanity check - start should be before or equal to end
+        assert word.start <= word.end
+
+
+@pytest.mark.asyncio
+async def test_transcript_diarization_assembler_processor():
+    """Test TranscriptDiarizationAssemblerProcessor without VCR (no HTTP requests)"""
+    # Create test transcript with words
+    words = [
+        Word(text="Hello", start=0.0, end=1.0, speaker=0),
+        Word(text=" ", start=1.0, end=1.1, speaker=0),
+        Word(text="world", start=1.1, end=2.0, speaker=0),
+        Word(text=".", start=2.0, end=2.1, speaker=0),
+        Word(text=" ", start=2.1, end=2.2, speaker=0),
+        Word(text="How", start=2.2, end=2.8, speaker=0),
+        Word(text=" ", start=2.8, end=2.9, speaker=0),
+        Word(text="are", start=2.9, end=3.2, speaker=0),
+        Word(text=" ", start=3.2, end=3.3, speaker=0),
+        Word(text="you", start=3.3, end=3.8, speaker=0),
+        Word(text="?", start=3.8, end=3.9, speaker=0),
+    ]
+    transcript = Transcript(words=words)
+
+    # Create test diarization segments
+    diarization = [
+        DiarizationSegment(start=0.0, end=2.1, speaker=0),
+        DiarizationSegment(start=2.1, end=3.9, speaker=1),
+    ]
+
+    # Create processor and test input
+    processor = TranscriptDiarizationAssemblerProcessor()
+    test_input = TranscriptDiarizationAssemblerInput(
+        transcript=transcript, diarization=diarization
+    )
+
+    # Track emitted results
+    emitted_results = []
+
+    async def capture_result(result):
+        emitted_results.append(result)
+
+    processor.on(capture_result)
+
+    # Process the input
+    await processor.push(test_input)
+
+    # Verify result was emitted
+    assert len(emitted_results) == 1
+    result = emitted_results[0]
+
+    # Verify result structure
+    assert isinstance(result, Transcript)
+    assert len(result.words) == len(words)
+
+    # Verify speaker assignments were applied
+    # Words 0-3 (indices) should be speaker 0 (time 0.0-2.0)
+    # Words 4-10 (indices) should be speaker 1 (time 2.1-3.9)
+    for i in range(4):  # First 4 words (Hello, space, world, .)
+        assert (
+            result.words[i].speaker == 0
+        ), f"Word {i} '{result.words[i].text}' should be speaker 0, got {result.words[i].speaker}"
+
+    for i in range(4, 11):  # Remaining words (space, How, space, are, space, you, ?)
+        assert (
+            result.words[i].speaker == 1
+        ), f"Word {i} '{result.words[i].text}' should be speaker 1, got {result.words[i].speaker}"
+
+
+@pytest.mark.asyncio
+async def test_transcript_diarization_assembler_no_diarization():
+    """Test TranscriptDiarizationAssemblerProcessor with no diarization data"""
+    # Create test transcript
+    words = [Word(text="Hello", start=0.0, end=1.0, speaker=0)]
+    transcript = Transcript(words=words)
+
+    # Create processor and test input with empty diarization
+    processor = TranscriptDiarizationAssemblerProcessor()
+    test_input = TranscriptDiarizationAssemblerInput(
+        transcript=transcript, diarization=[]
+    )
+
+    # Track emitted results
+    emitted_results = []
+
+    async def capture_result(result):
+        emitted_results.append(result)
+
+    processor.on(capture_result)
+
+    # Process the input
+    await processor.push(test_input)
+
+    # Verify original transcript was returned unchanged
+    assert len(emitted_results) == 1
+    result = emitted_results[0]
+    assert result is transcript  # Should be the same object
+    assert result.words[0].speaker == 0  # Original speaker unchanged
+
+
+@pytest.mark.vcr()
+@pytest.mark.asyncio
+async def test_full_modal_pipeline_integration(vcr):
+    """Integration test: Transcription -> Diarization -> Assembly
+
+    This test demonstrates the full pipeline:
+    1. Run transcription via Modal
+    2. Run diarization via Modal
+    3. Assemble transcript with diarization
+    """
+    from reflector.settings import settings
+
+    # Step 1: Transcription
+    transcript_processor = FileTranscriptModalProcessor(
+        modal_api_key=settings.TRANSCRIPT_MODAL_API_KEY
+    )
+    transcript_input = FileTranscriptInput(audio_url=TEST_AUDIO_URL, language="en")
+    transcript = await transcript_processor._transcript(transcript_input)
+
+    # Step 2: Diarization
+    diarization_processor = FileDiarizationModalProcessor(
+        modal_api_key=settings.DIARIZATION_MODAL_API_KEY
+    )
+    diarization_input = FileDiarizationInput(audio_url=TEST_AUDIO_URL)
+    diarization_result = await diarization_processor._diarize(diarization_input)
+
+    # Step 3: Assembly
+    assembler = TranscriptDiarizationAssemblerProcessor()
+    assembly_input = TranscriptDiarizationAssemblerInput(
+        transcript=transcript, diarization=diarization_result.diarization
+    )
+
+    # Track assembled result
+    assembled_results = []
+
+    async def capture_result(result):
+        assembled_results.append(result)
+
+    assembler.on(capture_result)
+
+    await assembler.push(assembly_input)
+
+    # Verify the full pipeline worked
+    assert len(assembled_results) == 1
+    final_transcript = assembled_results[0]
+
+    # Verify the final transcript has the original words with updated speaker info
+    assert isinstance(final_transcript, Transcript)
+    assert len(final_transcript.words) == len(transcript.words)
+    assert len(final_transcript.words) > 0
+
+    # Verify some words have been assigned speakers from diarization
+    speakers_found = set(word.speaker for word in final_transcript.words)
+    assert len(speakers_found) > 0  # At least some speaker assignments
--- a/Show More
+++ b/Show More