file upload is file

2025-12-21 12:49:06 +00:00 · 2025-08-22 11:48:21 -04:00
282 changed files with 10995 additions and 34900 deletions
--- a/.github/workflows/db_migrations.yml
+++ b/.github/workflows/db_migrations.yml
@@ -2,8 +2,6 @@ name: Test Database Migrations
 on:
  push:
    branches:
      - main
    paths:
      - "server/migrations/**"
      - "server/reflector/db/**"
@@ -19,9 +17,6 @@ on:
 jobs:
  test-migrations:
    runs-on: ubuntu-latest
    concurrency:
      group: db-ubuntu-latest-${{ github.ref }}
      cancel-in-progress: true
    services:
      postgres:
        image: postgres:17
--- a/.github/workflows/docker-frontend.yml
+++ b/.github/workflows/docker-frontend.yml
@@ -1,57 +0,0 @@
 name: Build and Push Frontend Docker Image
 on:
  push:
    branches:
      - main
    paths:
      - 'www/**'
      - '.github/workflows/docker-frontend.yml'
  workflow_dispatch:
 env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}-frontend
 jobs:
  build-and-push:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
      - name: Log in to GitHub Container Registry
        uses: docker/login-action@v3
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
      - name: Extract metadata
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
          tags: |
            type=ref,event=branch
            type=sha,prefix={{branch}}-
            type=raw,value=latest,enable={{is_default_branch}}
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3
      - name: Build and push Docker image
        uses: docker/build-push-action@v5
        with:
          context: ./www
          file: ./www/Dockerfile
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          cache-from: type=gha
          cache-to: type=gha,mode=max
          platforms: linux/amd64,linux/arm64
--- a/.github/workflows/test_next_server.yml
+++ b/.github/workflows/test_next_server.yml
@@ -1,45 +0,0 @@
 name: Test Next Server
 on:
  pull_request:
    paths:
      - "www/**"
  push:
    branches:
      - main
    paths:
      - "www/**"
 jobs:
  test-next-server:
    runs-on: ubuntu-latest
    defaults:
      run:
        working-directory: ./www
    steps:
    - uses: actions/checkout@v4
    - name: Setup Node.js
      uses: actions/setup-node@v4
      with:
        node-version: '20'
    - name: Install pnpm
      uses: pnpm/action-setup@v4
      with:
        version: 8
    - name: Setup Node.js cache
      uses: actions/setup-node@v4
      with:
        node-version: '20'
        cache: 'pnpm'
        cache-dependency-path: './www/pnpm-lock.yaml'
    - name: Install dependencies
      run: pnpm install
    - name: Run tests
      run: pnpm test
--- a/.github/workflows/test_server.yml
+++ b/.github/workflows/test_server.yml
@@ -5,17 +5,12 @@ on:
    paths:
      - "server/**"
  push:
    branches:
      - main
    paths:
      - "server/**"
 jobs:
  pytest:
    runs-on: ubuntu-latest
    concurrency:
      group: pytest-${{ github.ref }}
      cancel-in-progress: true
    services:
      redis:
        image: redis:6
@@ -35,9 +30,6 @@ jobs:
  docker-amd64:
    runs-on: linux-amd64
    concurrency:
      group: docker-amd64-${{ github.ref }}
      cancel-in-progress: true
    steps:
      - uses: actions/checkout@v4
      - name: Set up Docker Buildx
@@ -53,9 +45,6 @@ jobs:
  docker-arm64:
    runs-on: linux-arm64
    concurrency:
      group: docker-arm64-${{ github.ref }}
      cancel-in-progress: true
    steps:
      - uses: actions/checkout@v4
      - name: Set up Docker Buildx
--- a/.gitignore
+++ b/.gitignore
@@ -14,7 +14,4 @@ data/
 www/REFACTOR.md
 www/reload-frontend
 server/test.sqlite
-CLAUDE.local.md
+CLAUDE.local.md
 www/.env.development
 www/.env.production
 .playwright-mcp
--- a/.gitleaksignore
+++ b/.gitleaksignore
@@ -1 +0,0 @@
 b9d891d3424f371642cb032ecfd0e2564470a72c:server/tests/test_transcripts_recording_deletion.py:generic-api-key:15
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -27,8 +27,3 @@ repos:
        files: ^server/
      - id: ruff-format
        files: ^server/
  - repo: https://github.com/gitleaks/gitleaks
    rev: v8.28.0
    hooks:
      - id: gitleaks
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,143 +1,5 @@
 # Changelog
 ## [0.14.0](https://github.com/Monadical-SAS/reflector/compare/v0.13.1...v0.14.0) (2025-10-08)
 ### Features
 * Add calendar event data to transcript webhook payload ([#689](https://github.com/Monadical-SAS/reflector/issues/689)) ([5f6910e](https://github.com/Monadical-SAS/reflector/commit/5f6910e5131b7f28f86c9ecdcc57fed8412ee3cd))
 * container build for www / github ([#672](https://github.com/Monadical-SAS/reflector/issues/672)) ([969bd84](https://github.com/Monadical-SAS/reflector/commit/969bd84fcc14851d1a101412a0ba115f1b7cde82))
 * docker-compose for production frontend ([#664](https://github.com/Monadical-SAS/reflector/issues/664)) ([5bf64b5](https://github.com/Monadical-SAS/reflector/commit/5bf64b5a41f64535e22849b4bb11734d4dbb4aae))
 ### Bug Fixes
 * restore feature boolean logic ([#671](https://github.com/Monadical-SAS/reflector/issues/671)) ([3660884](https://github.com/Monadical-SAS/reflector/commit/36608849ec64e953e3be456172502762e3c33df9))
 * security review ([#656](https://github.com/Monadical-SAS/reflector/issues/656)) ([5d98754](https://github.com/Monadical-SAS/reflector/commit/5d98754305c6c540dd194dda268544f6d88bfaf8))
 * update transcript list on reprocess ([#676](https://github.com/Monadical-SAS/reflector/issues/676)) ([9a71af1](https://github.com/Monadical-SAS/reflector/commit/9a71af145ee9b833078c78d0c684590ab12e9f0e))
 * upgrade nemo toolkit ([#678](https://github.com/Monadical-SAS/reflector/issues/678)) ([eef6dc3](https://github.com/Monadical-SAS/reflector/commit/eef6dc39037329b65804297786d852dddb0557f9))
 ## [0.13.1](https://github.com/Monadical-SAS/reflector/compare/v0.13.0...v0.13.1) (2025-09-22)
 ### Bug Fixes
 * TypeError on not all arguments converted during string formatting in logger ([#667](https://github.com/Monadical-SAS/reflector/issues/667)) ([565a629](https://github.com/Monadical-SAS/reflector/commit/565a62900f5a02fc946b68f9269a42190ed70ab6))
 ## [0.13.0](https://github.com/Monadical-SAS/reflector/compare/v0.12.1...v0.13.0) (2025-09-19)
 ### Features
 * room form edit with enter ([#662](https://github.com/Monadical-SAS/reflector/issues/662)) ([47716f6](https://github.com/Monadical-SAS/reflector/commit/47716f6e5ddee952609d2fa0ffabdfa865286796))
 ### Bug Fixes
 * invalid cleanup call ([#660](https://github.com/Monadical-SAS/reflector/issues/660)) ([0abcebf](https://github.com/Monadical-SAS/reflector/commit/0abcebfc9491f87f605f21faa3e53996fafedd9a))
 ## [0.12.1](https://github.com/Monadical-SAS/reflector/compare/v0.12.0...v0.12.1) (2025-09-17)
 ### Bug Fixes
 * production blocked because having existing meeting with room_id null ([#657](https://github.com/Monadical-SAS/reflector/issues/657)) ([870e860](https://github.com/Monadical-SAS/reflector/commit/870e8605171a27155a9cbee215eeccb9a8d6c0a2))
 ## [0.12.0](https://github.com/Monadical-SAS/reflector/compare/v0.11.0...v0.12.0) (2025-09-17)
 ### Features
 * calendar integration ([#608](https://github.com/Monadical-SAS/reflector/issues/608)) ([6f680b5](https://github.com/Monadical-SAS/reflector/commit/6f680b57954c688882c4ed49f40f161c52a00a24))
 * self-hosted gpu api ([#636](https://github.com/Monadical-SAS/reflector/issues/636)) ([ab859d6](https://github.com/Monadical-SAS/reflector/commit/ab859d65a6bded904133a163a081a651b3938d42))
 ### Bug Fixes
 * ignore player hotkeys for text inputs ([#646](https://github.com/Monadical-SAS/reflector/issues/646)) ([fa049e8](https://github.com/Monadical-SAS/reflector/commit/fa049e8d068190ce7ea015fd9fcccb8543f54a3f))
 ## [0.11.0](https://github.com/Monadical-SAS/reflector/compare/v0.10.0...v0.11.0) (2025-09-16)
 ### Features
 * remove profanity filter that was there for conference ([#652](https://github.com/Monadical-SAS/reflector/issues/652)) ([b42f7cf](https://github.com/Monadical-SAS/reflector/commit/b42f7cfc606783afcee792590efcc78b507468ab))
 ### Bug Fixes
 * zulip and consent handler on the file pipeline ([#645](https://github.com/Monadical-SAS/reflector/issues/645)) ([5f143fe](https://github.com/Monadical-SAS/reflector/commit/5f143fe3640875dcb56c26694254a93189281d17))
 * zulip stream and topic selection in share dialog ([#644](https://github.com/Monadical-SAS/reflector/issues/644)) ([c546e69](https://github.com/Monadical-SAS/reflector/commit/c546e69739e68bb74fbc877eb62609928e5b8de6))
 ## [0.10.0](https://github.com/Monadical-SAS/reflector/compare/v0.9.0...v0.10.0) (2025-09-11)
 ### Features
 * replace nextjs-config with environment variables ([#632](https://github.com/Monadical-SAS/reflector/issues/632)) ([369ecdf](https://github.com/Monadical-SAS/reflector/commit/369ecdff13f3862d926a9c0b87df52c9d94c4dde))
 ### Bug Fixes
 * anonymous users transcript permissions ([#621](https://github.com/Monadical-SAS/reflector/issues/621)) ([f81fe99](https://github.com/Monadical-SAS/reflector/commit/f81fe9948a9237b3e0001b2d8ca84f54d76878f9))
 * auth post ([#624](https://github.com/Monadical-SAS/reflector/issues/624)) ([cde99ca](https://github.com/Monadical-SAS/reflector/commit/cde99ca2716f84ba26798f289047732f0448742e))
 * auth post ([#626](https://github.com/Monadical-SAS/reflector/issues/626)) ([3b85ff3](https://github.com/Monadical-SAS/reflector/commit/3b85ff3bdf4fb053b103070646811bc990c0e70a))
 * auth post ([#627](https://github.com/Monadical-SAS/reflector/issues/627)) ([962038e](https://github.com/Monadical-SAS/reflector/commit/962038ee3f2a555dc3c03856be0e4409456e0996))
 * missing follow_redirects=True on modal endpoint ([#630](https://github.com/Monadical-SAS/reflector/issues/630)) ([fc363bd](https://github.com/Monadical-SAS/reflector/commit/fc363bd49b17b075e64f9186e5e0185abc325ea7))
 * sync backend and frontend token refresh logic ([#614](https://github.com/Monadical-SAS/reflector/issues/614)) ([5a5b323](https://github.com/Monadical-SAS/reflector/commit/5a5b3233820df9536da75e87ce6184a983d4713a))
 ## [0.9.0](https://github.com/Monadical-SAS/reflector/compare/v0.8.2...v0.9.0) (2025-09-06)
 ### Features
 * frontend openapi react query ([#606](https://github.com/Monadical-SAS/reflector/issues/606)) ([c4d2825](https://github.com/Monadical-SAS/reflector/commit/c4d2825c81f81ad8835629fbf6ea8c7383f8c31b))
 ### Bug Fixes
 * align whisper transcriber api with parakeet ([#602](https://github.com/Monadical-SAS/reflector/issues/602)) ([0663700](https://github.com/Monadical-SAS/reflector/commit/0663700a615a4af69a03c96c410f049e23ec9443))
 * kv use tls explicit ([#610](https://github.com/Monadical-SAS/reflector/issues/610)) ([08d88ec](https://github.com/Monadical-SAS/reflector/commit/08d88ec349f38b0d13e0fa4cb73486c8dfd31836))
 * source kind for file processing ([#601](https://github.com/Monadical-SAS/reflector/issues/601)) ([dc82f8b](https://github.com/Monadical-SAS/reflector/commit/dc82f8bb3bdf3ab3d4088e592a30fd63907319e1))
 * token refresh locking ([#613](https://github.com/Monadical-SAS/reflector/issues/613)) ([7f5a4c9](https://github.com/Monadical-SAS/reflector/commit/7f5a4c9ddc7fd098860c8bdda2ca3b57f63ded2f))
 ## [0.8.2](https://github.com/Monadical-SAS/reflector/compare/v0.8.1...v0.8.2) (2025-08-29)
 ### Bug Fixes
 * search-logspam ([#593](https://github.com/Monadical-SAS/reflector/issues/593)) ([695d1a9](https://github.com/Monadical-SAS/reflector/commit/695d1a957d4cd862753049f9beed88836cabd5ab))
 ## [0.8.1](https://github.com/Monadical-SAS/reflector/compare/v0.8.0...v0.8.1) (2025-08-29)
 ### Bug Fixes
 * make webhook secret/url allowing null ([#590](https://github.com/Monadical-SAS/reflector/issues/590)) ([84a3812](https://github.com/Monadical-SAS/reflector/commit/84a381220bc606231d08d6f71d4babc818fa3c75))
 ## [0.8.0](https://github.com/Monadical-SAS/reflector/compare/v0.7.3...v0.8.0) (2025-08-29)
 ### Features
 * **cleanup:** add automatic data retention for public instances ([#574](https://github.com/Monadical-SAS/reflector/issues/574)) ([6f0c7c1](https://github.com/Monadical-SAS/reflector/commit/6f0c7c1a5e751713366886c8e764c2009e12ba72))
 * **rooms:** add webhook for transcript completion ([#578](https://github.com/Monadical-SAS/reflector/issues/578)) ([88ed7cf](https://github.com/Monadical-SAS/reflector/commit/88ed7cfa7804794b9b54cad4c3facc8a98cf85fd))
 ### Bug Fixes
 * file pipeline status reporting and websocket updates ([#589](https://github.com/Monadical-SAS/reflector/issues/589)) ([9dfd769](https://github.com/Monadical-SAS/reflector/commit/9dfd76996f851cc52be54feea078adbc0816dc57))
 * Igor/evaluation ([#575](https://github.com/Monadical-SAS/reflector/issues/575)) ([124ce03](https://github.com/Monadical-SAS/reflector/commit/124ce03bf86044c18313d27228a25da4bc20c9c5))
 * optimize parakeet transcription batching algorithm ([#577](https://github.com/Monadical-SAS/reflector/issues/577)) ([7030e0f](https://github.com/Monadical-SAS/reflector/commit/7030e0f23649a8cf6c1eb6d5889684a41ce849ec))
 ## [0.7.3](https://github.com/Monadical-SAS/reflector/compare/v0.7.2...v0.7.3) (2025-08-22)
 ### Bug Fixes
 * cleaned repo, and get git-leaks clean ([359280d](https://github.com/Monadical-SAS/reflector/commit/359280dd340433ba4402ed69034094884c825e67))
 * restore previous behavior on live pipeline + audio downscaler ([#561](https://github.com/Monadical-SAS/reflector/issues/561)) ([9265d20](https://github.com/Monadical-SAS/reflector/commit/9265d201b590d23c628c5f19251b70f473859043))
 ## [0.7.2](https://github.com/Monadical-SAS/reflector/compare/v0.7.1...v0.7.2) (2025-08-21)
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -66,6 +66,7 @@ pnpm install
 # Copy configuration templates
 cp .env_template .env
 cp config-template.ts config.ts
 ```
 **Development:**
@@ -151,7 +152,7 @@ All endpoints prefixed `/v1/`:
 **Frontend** (`www/.env`):
 - `NEXTAUTH_URL`, `NEXTAUTH_SECRET` - Authentication configuration
- `REFLECTOR_API_URL` - Backend API endpoint
+- `NEXT_PUBLIC_REFLECTOR_API_URL` - Backend API endpoint
 - `REFLECTOR_DOMAIN_CONFIG` - Feature flags and domain settings
 ## Testing Strategy
--- a/CODER_BRIEFING.md
+++ b/CODER_BRIEFING.md
@@ -1,345 +0,0 @@
 # Multi-Provider Video Platform Implementation - Coder Briefing
 ## Your Mission
 Implement multi-provider video platform support in Reflector, allowing the system to work with both Whereby and Daily.co video conferencing providers. The goal is to abstract the current Whereby-only implementation and add Daily.co as a second provider, with the ability to switch between them via environment variables.
 **Branch:** `igor/dailico-2` (you're already on it)
 **Estimated Time:** 12-16 hours (senior engineer)
 **Complexity:** Medium-High (requires careful integration with existing codebase)
 ---
 ## What You Have
 ### 1. **PLAN.md** - Your Technical Specification (2,452 lines)
   - Complete step-by-step implementation guide
   - All code examples you need
   - Architecture diagrams and design rationale
   - Testing strategy and success metrics
   - **Read this first** to understand the overall approach
 ### 2. **IMPLEMENTATION_GUIDE.md** - Your Practical Guide
   - What to copy vs. adapt vs. rewrite
   - Common pitfalls and how to avoid them
   - Verification checklists for each phase
   - Decision trees for implementation choices
   - **Use this as your day-to-day reference**
 ### 3. **Reference Implementation** - `./reflector-dailyco-reference/`
   - Working implementation from 2.5 months ago
   - Good architecture and patterns
   - **BUT:** 91 commits behind current main, DO NOT merge directly
   - Use for inspiration and code patterns only
 ---
 ## Critical Context: Why Not Just Merge?
 The reference branch (`origin/igor/feat-dailyco`) was started on August 1, 2025 and is now severely diverged from main:
 - **91 commits behind main**
 - Main has 12x more changes (45,840 insertions vs 3,689)
 - Main added: calendar integration, webhooks, full-text search, React Query migration, security fixes
 - Reference removed: features that main still has and needs
 **Merging would be a disaster.** We're implementing fresh on current main, using the reference for validated patterns.
 ---
 ## High-Level Approach
 ### Phase 1: Analysis (2 hours)
 - Study current Whereby integration
 - Define abstraction requirements
 - Create standard data models
 ### Phase 2: Abstraction Layer (4-5 hours)
 - Build platform abstraction (base class, registry, factory)
 - Extract Whereby into the abstraction
 - Update database schema (add `platform` field)
 - Integrate into rooms.py **without breaking calendar/webhooks**
 ### Phase 3: Daily.co Implementation (4-5 hours)
 - Implement Daily.co client
 - Add webhook handler
 - Create frontend components (rewrite API calls for React Query)
 - Add recording processing
 ### Phase 4: Testing (2-3 hours)
 - Unit tests for platform abstraction
 - Integration tests for webhooks
 - Manual testing with both providers
 ---
 ## Key Files You'll Touch
 ### Backend (New)
 ```
 server/reflector/video_platforms/
 ├── __init__.py
 ├── base.py              ← Abstract base class
 ├── models.py            ← Platform, MeetingData, VideoPlatformConfig
 ├── registry.py          ← Platform registration system
 ├── factory.py           ← Client creation and config
 ├── whereby.py           ← Whereby client wrapper
 ├── daily.py             ← Daily.co client
 └── mock.py              ← Mock client for testing
 server/reflector/views/daily.py       ← Daily.co webhooks
 server/tests/test_video_platforms.py  ← Platform tests
 server/tests/test_daily_webhook.py    ← Webhook tests
 ```
 ### Backend (Modified - Careful!)
 ```
 server/reflector/settings.py          ← Add Daily.co settings
 server/reflector/db/rooms.py          ← Add platform field, PRESERVE calendar fields
 server/reflector/db/meetings.py       ← Add platform field
 server/reflector/views/rooms.py       ← Integrate abstraction, PRESERVE calendar/webhooks
 server/reflector/worker/process.py    ← Add process_recording_from_url task
 server/reflector/app.py               ← Register daily router
 server/env.example                    ← Document new env vars
 ```
 ### Frontend (New)
 ```
 www/app/[roomName]/components/
 ├── RoomContainer.tsx    ← Platform router
 ├── DailyRoom.tsx        ← Daily.co component (rewrite API calls!)
 └── WherebyRoom.tsx      ← Extract existing logic
 ```
 ### Frontend (Modified)
 ```
 www/app/[roomName]/page.tsx           ← Use RoomContainer
 www/package.json                      ← Add @daily-co/daily-js
 ```
 ### Database
 ```
 server/migrations/versions/XXXXXX_add_platform_support.py  ← Generate fresh migration
 ```
 ---
 ## Critical Warnings ⚠️
 ### 1. **DO NOT Copy Database Migrations**
 The reference migration has the wrong `down_revision` and is based on old schema.
 ```bash
 # Instead:
 cd server
 uv run alembic revision -m "add_platform_support"
 # Then edit the generated file
 ```
 ### 2. **DO NOT Remove Main's Features**
 Main has calendar integration, webhooks, ICS sync that reference doesn't have.
 When modifying `rooms.py`, only change meeting creation logic, preserve everything else.
 ### 3. **DO NOT Copy Frontend API Calls**
 Reference uses old OpenAPI client. Main uses React Query.
 Check how main currently makes API calls and replicate that pattern.
 ### 4. **DO NOT Copy package.json/migrations**
 These files are severely outdated in reference.
 ### 5. **Preserve Type Safety**
 Use `TYPE_CHECKING` imports to avoid circular dependencies:
 ```python
 from typing import TYPE_CHECKING
 if TYPE_CHECKING:
    from reflector.db.rooms import Room
 ```
 ---
 ## How to Start
 ### Day 1 Morning: Setup & Understanding (2-3 hours)
 ```bash
 # 1. Verify you're on the right branch
 git branch
 # Should show: igor/dailico-2
 # 2. Read the docs (in order)
 # - PLAN.md (skim to understand scope, read Phase 1 carefully)
 # - IMPLEMENTATION_GUIDE.md (read fully, bookmark it)
 # 3. Study current Whereby integration
 cat server/reflector/views/rooms.py | grep -A 20 "whereby"
 cat www/app/[roomName]/page.tsx
 # 4. Check reference implementation structure
 ls -la reflector-dailyco-reference/server/reflector/video_platforms/
 ```
 ### Day 1 Afternoon: Phase 1 Execution (2-3 hours)
 ```bash
 # 5. Copy video_platforms directory from reference
 cp -r reflector-dailyco-reference/server/reflector/video_platforms/ \
      server/reflector/
 # 6. Review and fix imports
 cd server
 uv run ruff check reflector/video_platforms/
 # 7. Add settings to settings.py (see PLAN.md Phase 2.7)
 # 8. Test imports work
 uv run python -c "from reflector.video_platforms import create_platform_client; print('OK')"
 ```
 ### Day 2: Phase 2 - Database & Integration (4-5 hours)
 ```bash
 # 9. Generate migration
 uv run alembic revision -m "add_platform_support"
 # Edit the file following PLAN.md Phase 2.8
 # 10. Update Room/Meeting models
 # Add platform field, PRESERVE all existing fields
 # 11. Integrate into rooms.py
 # Carefully modify meeting creation, preserve calendar/webhooks
 # 12. Add Daily.co webhook handler
 cp reflector-dailyco-reference/server/reflector/views/daily.py \
   server/reflector/views/
 # Register in app.py
 ```
 ### Day 3: Phase 3 - Frontend & Testing (4-5 hours)
 ```bash
 # 13. Create frontend components
 mkdir -p www/app/[roomName]/components
 # 14. Add Daily.co dependency
 cd www
 pnpm add @daily-co/daily-js@^0.81.0
 # 15. Create RoomContainer, DailyRoom, WherebyRoom
 # IMPORTANT: Rewrite API calls using React Query patterns
 # 16. Regenerate types
 pnpm openapi
 # 17. Copy and adapt tests
 cp reflector-dailyco-reference/server/tests/test_*.py server/tests/
 # 18. Run tests
 cd server
 REDIS_HOST=localhost \
 CELERY_BROKER_URL=redis://localhost:6379/1 \
 uv run pytest tests/test_video_platforms.py -v
 ```
 ---
 ## Verification Checklist
 After implementation, all of these must pass:
 **Backend:**
 - [ ] `cd server && uv run ruff check .` passes
 - [ ] `uv run alembic upgrade head` works cleanly
 - [ ] `uv run pytest tests/test_video_platforms.py` passes
 - [ ] Can import: `from reflector.video_platforms import create_platform_client`
 - [ ] Settings has all Daily.co variables
 **Frontend:**
 - [ ] `cd www && pnpm lint` passes
 - [ ] No TypeScript errors
 - [ ] `pnpm openapi` generates platform field
 - [ ] No `@ts-ignore` for platform field
 **Integration:**
 - [ ] Whereby meetings still work (existing flow unchanged)
 - [ ] Calendar/webhook features still work in rooms.py
 - [ ] env.example documents all new variables
 ---
 ## When You're Stuck
 ### Check These Resources:
 1. **PLAN.md** - Detailed code examples for your exact scenario
 2. **IMPLEMENTATION_GUIDE.md** - Common pitfalls section
 3. **Reference code** - See how it was solved before
 4. **Git diff** - Compare reference to your implementation
 ### Compare Files:
 ```bash
 # See what reference did
 diff reflector-dailyco-reference/server/reflector/views/rooms.py \
     server/reflector/views/rooms.py
 # See what changed in main since reference branch
 git log --oneline --since="2025-08-01" -- server/reflector/views/rooms.py
 ```
 ### Common Issues:
 - **Circular imports:** Use `TYPE_CHECKING` pattern
 - **Tests fail with postgres error:** Use `REDIS_HOST=localhost` env vars
 - **Frontend API calls broken:** Check current React Query patterns in main
 - **Migrations fail:** Ensure you generated fresh, not copied
 ---
 ## Success Looks Like
 When you're done:
 - ✅ All tests pass
 - ✅ Linting passes
 - ✅ Can create Whereby meetings (unchanged behavior)
 - ✅ Can create Daily.co meetings (with env vars)
 - ✅ Calendar/webhooks still work
 - ✅ Frontend has no TypeScript errors
 - ✅ Platform selection via environment variables works
 ---
 ## Communication
 If you need clarification on requirements, have questions about architecture decisions, or find issues with the spec, document them clearly with:
 - What you expected
 - What you found
 - Your proposed solution
 The PLAN.md document is comprehensive but you may find edge cases. Use your engineering judgment and document decisions.
 ---
 ## Final Notes
 **This is not a simple copy-paste job.** You're doing careful integration work where you need to:
 - Understand the abstraction pattern (PLAN.md)
 - Preserve all of main's features
 - Adapt reference code to current patterns
 - Think about edge cases and testing
 Take your time with Phase 2 (rooms.py integration) - that's where most bugs will come from if you accidentally break calendar/webhook features.
 **Good luck! You've got comprehensive specs, working reference code, and a clean starting point. You can do this.**
 ---
 ## Quick Reference
 ```bash
 # Your workspace
 ├── PLAN.md                        ← Complete technical spec (read first)
 ├── IMPLEMENTATION_GUIDE.md        ← Practical guide (bookmark this)
 ├── CODER_BRIEFING.md             ← This file
 └── reflector-dailyco-reference/   ← Reference implementation (inspiration only)
 # Key commands
 cd server && uv run ruff check .                    # Lint backend
 cd www && pnpm lint                                  # Lint frontend
 cd server && uv run alembic revision -m "..."       # Create migration
 cd www && pnpm openapi                              # Regenerate types
 cd server && uv run pytest -v                       # Run tests
 ```
--- a/IMPLEMENTATION_GUIDE.md
+++ b/IMPLEMENTATION_GUIDE.md
@@ -1,489 +0,0 @@
 # Daily.co Implementation Guide
 ## Overview
 Implement multi-provider video platform support (Whereby + Daily.co) following PLAN.md.
 ## Reference Code Location
 - **Reference branch:** `origin/igor/feat-dailyco` (on remote)
 - **Worktree location:** `./reflector-dailyco-reference/`
 - **Status:** Reference only - DO NOT merge or copy directly
 ## What Exists in Reference Branch (For Inspiration)
 ### ✅ Can Use As Reference (Well-Implemented)
 ```
 server/reflector/video_platforms/
 ├── base.py              ← Platform abstraction (good design, copy-safe)
 ├── models.py            ← Data models (copy-safe)
 ├── registry.py          ← Registry pattern (copy-safe)
 ├── factory.py           ← Factory pattern (needs settings updates)
 ├── whereby.py           ← Whereby client (needs adaptation)
 ├── daily.py             ← Daily.co client (needs adaptation)
 └── mock.py              ← Mock client (copy-safe for tests)
 server/reflector/views/daily.py       ← Webhook handler (needs adaptation)
 server/tests/test_video_platforms.py  ← Tests (good reference)
 server/tests/test_daily_webhook.py    ← Tests (good reference)
 www/app/[roomName]/components/
 ├── RoomContainer.tsx    ← Platform router (needs React Query)
 ├── DailyRoom.tsx        ← Daily component (needs React Query)
 └── WherebyRoom.tsx      ← Whereby extraction (needs React Query)
 ```
 ### ⚠️ Needs Significant Changes (Use Logic Only)
 - `server/reflector/db/rooms.py` - Reference removed calendar/webhook fields that main has
 - `server/reflector/db/meetings.py` - Same issue (missing user_id handling differences)
 - `server/reflector/views/rooms.py` - Main has calendar integration, webhooks, ICS sync
 - `server/reflector/worker/process.py` - Main has different recording flow
 - Migration files - Must regenerate against current main schema
 ### ❌ Do NOT Use (Outdated/Incompatible)
 - `package.json`/`pnpm-lock.yaml` - Main uses different dependency versions
 - Frontend API client calls - Main uses React Query (reference uses old OpenAPI client)
 - Database migrations - Must create new ones from scratch
 - Any files that delete features present in main (search, calendar, webhooks)
 ## Key Differences: Reference vs Current Main
 | Aspect | Reference Branch | Current Main | Action Required |
 |--------|------------------|--------------|-----------------|
 | **API client** | Old OpenAPI generated | React Query hooks | Rewrite all API calls |
 | **Database schema** | Simplified (removed features) | Has calendar, webhooks, full-text search | Merge carefully, preserve main features |
 | **Settings** | Aug 2025 structure | Current structure | Adapt carefully |
 | **Migrations** | Branched from Aug 1 | Current main (91+ commits ahead) | Regenerate from scratch |
 | **Frontend deps** | `@daily-co/daily-js@0.81.0` | Check current versions | Update to compatible versions |
 | **Package manager** | yarn | pnpm (maybe both?) | Use what main uses |
 ## Branch Divergence Analysis
 **The reference branch is 91 commits behind main and severely diverged:**
 - Reference: 8 commits, 3,689 insertions, 425 deletions
 - Main since divergence: 320 files changed, 45,840 insertions, 16,827 deletions
 - **Main has 12x more changes**
 **Major features in main that reference lacks:**
 1. Calendar integration (ICS sync with rooms)
 2. Self-hosted GPU API infrastructure
 3. Frontend OpenAPI React Query migration
 4. Full-text search (backend + frontend)
 5. Webhook system for room events
 6. Environment variable migration
 7. Security fixes and auth improvements
 8. Docker production frontend
 9. Meeting user ID removal (schema change)
 10. NextJS version upgrades
 **High conflict risk files:**
 - `server/reflector/views/rooms.py` - 12x more changes in main
 - `server/reflector/db/rooms.py` - Main added 7+ fields
 - `www/package.json` - NextJS major version bump
 - Database migrations - 20+ new migrations in main
 ## Implementation Approach
 ### Phase 1: Copy Clean Abstractions (1-2 hours)
 **Files to copy directly from reference:**
 ```bash
 # Core abstraction (review but mostly safe to copy)
 cp -r reflector-dailyco-reference/server/reflector/video_platforms/ \
      server/reflector/
 # BUT review each file for:
 # - Import paths (make sure they match current main)
 # - Settings references (adapt to current settings.py)
 # - Type imports (ensure no circular dependencies)
 ```
 **After copying, immediately:**
 ```bash
 cd server
 # Check for issues
 uv run ruff check reflector/video_platforms/
 # Fix any import errors or type issues
 ```
 ### Phase 2: Adapt to Current Main (2-3 hours)
 **2.1 Settings Integration**
 File: `server/reflector/settings.py`
 Add at the appropriate location (near existing Whereby settings):
 ```python
 # Daily.co API Integration (NEW)
 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
 # Platform Migration Feature Flags (NEW)
 DAILY_MIGRATION_ENABLED: bool = False  # Conservative default
 DAILY_MIGRATION_ROOM_IDS: list[str] = []
 DEFAULT_VIDEO_PLATFORM: Literal["whereby", "daily"] = "whereby"
 ```
 **2.2 Database Migration**
 ⚠️ **CRITICAL: Do NOT copy migration from reference**
 Generate new migration:
 ```bash
 cd server
 uv run alembic revision -m "add_platform_support"
 ```
 Edit the generated migration file to add `platform` column:
 ```python
 def upgrade():
    with op.batch_alter_table("room", schema=None) as batch_op:
        batch_op.add_column(
            sa.Column("platform", sa.String(), nullable=False, server_default="whereby")
        )
    with op.batch_alter_table("meeting", schema=None) as batch_op:
        batch_op.add_column(
            sa.Column("platform", sa.String(), nullable=False, server_default="whereby")
        )
 ```
 **2.3 Update Database Models**
 File: `server/reflector/db/rooms.py`
 Add platform field (preserve all existing fields from main):
 ```python
 from typing import TYPE_CHECKING
 if TYPE_CHECKING:
    from reflector.video_platforms.models import Platform
 class Room:
    # ... ALL existing fields from main (calendar, webhooks, etc.) ...
    # NEW: Platform field
    platform: "Platform" = sqlalchemy.Column(
        sqlalchemy.String,
        nullable=False,
        server_default="whereby",
    )
 ```
 File: `server/reflector/db/meetings.py`
 Same approach - add platform field, preserve everything from main.
 **2.4 Integrate Platform Abstraction into rooms.py**
 ⚠️ **This is the most delicate part - main has calendar/webhook features**
 File: `server/reflector/views/rooms.py`
 Strategy:
 1. Add imports at top
 2. Modify meeting creation logic only
 3. Preserve all calendar/webhook/ICS logic from main
 ```python
 # Add imports
 from reflector.video_platforms import (
    create_platform_client,
    get_platform_for_room,
 )
 # In create_meeting endpoint:
 # OLD: Direct Whereby API calls
 # NEW: Platform abstraction
 # Find the meeting creation section and replace:
 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=meeting_data.end_date,
    room=room,
 )
 # Then create Meeting record with meeting_data.platform, meeting_data.meeting_id, etc.
 ```
 **2.5 Add Daily.co Webhook Handler**
 Copy from reference, minimal changes needed:
 ```bash
 cp reflector-dailyco-reference/server/reflector/views/daily.py \
   server/reflector/views/
 ```
 Register in `server/reflector/app.py`:
 ```python
 from reflector.views import daily
 app.include_router(daily.router, prefix="/v1/daily", tags=["daily"])
 ```
 **2.6 Add Recording Processing Task**
 File: `server/reflector/worker/process.py`
 Add the `process_recording_from_url` task from reference (copy the function).
 ### Phase 3: Frontend Adaptation (3-4 hours)
 **3.1 Determine Current API Client Pattern**
 First, check how main currently makes API calls:
 ```bash
 cd www
 grep -r "api\." app/ | head -20
 # Look for patterns like: api.v1Something()
 ```
 **3.2 Create Components**
 Copy component structure from reference but **rewrite all API calls**:
 ```bash
 mkdir -p www/app/[roomName]/components
 ```
 Files to create:
 - `RoomContainer.tsx` - Platform router (mostly copy-safe, just fix imports)
 - `DailyRoom.tsx` - Needs React Query API calls
 - `WherebyRoom.tsx` - Extract current room page logic
 **Example React Query pattern** (adapt to your actual API):
 ```typescript
 import { api } from '@/app/api/client'
 // In DailyRoom.tsx
 const handleConsent = async () => {
  try {
    await api.v1MeetingAudioConsent({
      path: { meeting_id: meeting.id },
      body: { consent: true },
    })
    // ...
  } catch (error) {
    // ...
  }
 }
 ```
 **3.3 Add Daily.co Dependency**
 Check current package manager:
 ```bash
 cd www
 ls package-lock.json yarn.lock pnpm-lock.yaml
 ```
 Then install:
 ```bash
 # If using pnpm
 pnpm add @daily-co/daily-js@^0.81.0
 # If using yarn
 yarn add @daily-co/daily-js@^0.81.0
 ```
 **3.4 Update TypeScript Types**
 After backend changes, regenerate types:
 ```bash
 cd www
 pnpm openapi  # or yarn openapi
 ```
 This should pick up the new `platform` field on Meeting type.
 ### Phase 4: Testing (2-3 hours)
 **4.1 Copy Test Structure**
 ```bash
 cp reflector-dailyco-reference/server/tests/test_video_platforms.py \
   server/tests/
 cp reflector-dailyco-reference/server/tests/test_daily_webhook.py \
   server/tests/
 ```
 **4.2 Fix Test Imports and Fixtures**
 Update imports to match current test infrastructure:
 - Check `server/tests/conftest.py` for fixture patterns
 - Update database access patterns if changed
 - Fix any import errors
 **4.3 Run Tests**
 ```bash
 cd server
 # Run with environment variables for Mac
 REDIS_HOST=localhost \
 CELERY_BROKER_URL=redis://localhost:6379/1 \
 CELERY_RESULT_BACKEND=redis://localhost:6379/1 \
 uv run pytest tests/test_video_platforms.py -v
 ```
 ### Phase 5: Environment Configuration
 **Update `server/env.example`:**
 Add at the end:
 ```bash
 # Daily.co API Integration
 DAILY_API_KEY=your-daily-api-key
 DAILY_WEBHOOK_SECRET=your-daily-webhook-secret
 DAILY_SUBDOMAIN=your-subdomain
 AWS_DAILY_S3_BUCKET=your-daily-bucket
 AWS_DAILY_S3_REGION=us-west-2
 AWS_DAILY_ROLE_ARN=arn:aws:iam::ACCOUNT:role/DailyRecording
 # Platform Selection
 DAILY_MIGRATION_ENABLED=false           # Master switch
 DAILY_MIGRATION_ROOM_IDS=[]            # Specific room IDs
 DEFAULT_VIDEO_PLATFORM=whereby          # Default platform
 ```
 ## Decision Tree: Copy vs Adapt vs Rewrite
 ```
 ┌─ Is it pure abstraction logic? (base.py, registry.py, models.py)
 │  YES → Copy directly, review imports
 │  NO  → Continue ↓
 │
 ├─ Does it touch database models?
 │  YES → Adapt carefully, preserve main's fields
 │  NO  → Continue ↓
 │
 ├─ Does it make API calls on frontend?
 │  YES → Rewrite using React Query
 │  NO  → Continue ↓
 │
 ├─ Is it a database migration?
 │  YES → Generate fresh from current schema
 │  NO  → Continue ↓
 │
 └─ Does it touch rooms.py or core business logic?
   YES → Merge carefully, preserve calendar/webhooks
   NO  → Safe to adapt from reference
 ```
 ## Verification Checklist
 After each phase, verify:
 **Phase 1 (Abstraction Layer):**
 - [ ] `uv run ruff check server/reflector/video_platforms/` passes
 - [ ] No circular import errors
 - [ ] Can import `from reflector.video_platforms import create_platform_client`
 **Phase 2 (Backend Integration):**
 - [ ] `uv run ruff check server/` passes
 - [ ] Migration file generated (not copied)
 - [ ] Room and Meeting models have platform field
 - [ ] rooms.py still has calendar/webhook features
 **Phase 3 (Frontend):**
 - [ ] `pnpm lint` passes
 - [ ] No TypeScript errors
 - [ ] No `@ts-ignore` for platform field
 - [ ] API calls use React Query patterns
 **Phase 4 (Testing):**
 - [ ] Tests can be collected: `pytest tests/test_video_platforms.py --collect-only`
 - [ ] Database fixtures work
 - [ ] Mock platform works
 **Phase 5 (Config):**
 - [ ] env.example has Daily.co variables
 - [ ] settings.py has all new variables
 - [ ] No duplicate variable definitions
 ## Common Pitfalls
 ### 1. Database Schema Conflicts
 **Problem:** Reference removed fields that main has (calendar, webhooks)
 **Solution:** Always preserve main's fields, only add platform field
 ### 2. Migration Conflicts
 **Problem:** Reference migration has wrong `down_revision`
 **Solution:** Always generate fresh migration from current main
 ### 3. Frontend API Calls
 **Problem:** Reference uses old API client patterns
 **Solution:** Check current main's API usage, replicate that pattern
 ### 4. Import Errors
 **Problem:** Circular imports with TYPE_CHECKING
 **Solution:** Use `if TYPE_CHECKING:` for Room/Meeting imports in video_platforms
 ### 5. Test Database Issues
 **Problem:** Tests fail with "could not translate host name 'postgres'"
 **Solution:** Use environment variables: `REDIS_HOST=localhost DATABASE_URL=...`
 ### 6. Preserved Features Broken
 **Problem:** Calendar/webhook features stop working
 **Solution:** Carefully review rooms.py diff, only change meeting creation, not calendar logic
 ## File Modification Summary
 **New files (can copy):**
 - `server/reflector/video_platforms/*.py` (entire directory)
 - `server/reflector/views/daily.py`
 - `server/tests/test_video_platforms.py`
 - `server/tests/test_daily_webhook.py`
 - `www/app/[roomName]/components/RoomContainer.tsx`
 - `www/app/[roomName]/components/DailyRoom.tsx`
 - `www/app/[roomName]/components/WherebyRoom.tsx`
 **Modified files (careful merging):**
 - `server/reflector/settings.py` - Add Daily.co settings
 - `server/reflector/db/rooms.py` - Add platform field
 - `server/reflector/db/meetings.py` - Add platform field
 - `server/reflector/views/rooms.py` - Integrate platform abstraction
 - `server/reflector/worker/process.py` - Add process_recording_from_url
 - `server/reflector/app.py` - Register daily router
 - `server/env.example` - Add Daily.co variables
 - `www/app/[roomName]/page.tsx` - Use RoomContainer
 - `www/package.json` - Add @daily-co/daily-js
 **Generated files (do not copy):**
 - `server/migrations/versions/XXXXXX_add_platform_support.py` - Generate fresh
 ## Success Metrics
 Implementation is complete when:
 - [ ] All tests pass (including new platform tests)
 - [ ] Linting passes (ruff, pnpm lint)
 - [ ] Migration applies cleanly: `uv run alembic upgrade head`
 - [ ] Can create Whereby meeting (existing flow unchanged)
 - [ ] Can create Daily.co meeting (with env vars set)
 - [ ] Frontend loads without TypeScript errors
 - [ ] No features from main were accidentally removed
 ## Getting Help
 **Reference documentation locations:**
 - Implementation plan: `PLAN.md`
 - Reference implementation: `./reflector-dailyco-reference/`
 - Current main codebase: `./ ` (current directory)
 **Compare implementations:**
 ```bash
 # Compare specific files
 diff reflector-dailyco-reference/server/reflector/video_platforms/base.py \
     server/reflector/video_platforms/base.py
 # See what changed in rooms.py between reference branch point and now
 git log --oneline --since="2025-08-01" -- server/reflector/views/rooms.py
 ```
 **Key insight:** The reference branch validates the approach and provides working code patterns, but you're implementing fresh against current main to avoid merge conflicts and preserve all new features.
--- a/PLAN.md
+++ b/PLAN.md
--- a/README.md
+++ b/README.md
@@ -1,60 +1,43 @@
 <div align="center">
 <img width="100" alt="image" src="https://github.com/user-attachments/assets/66fb367b-2c89-4516-9912-f47ac59c6a7f"/>
 # Reflector
-Reflector is an AI-powered audio transcription and meeting analysis platform that provides real-time transcription, speaker diarization, translation and summarization for audio content and live meetings. It works 100% with local models (whisper/parakeet, pyannote, seamless-m4t, and your local llm like phi-4).
+Reflector Audio Management and Analysis is a cutting-edge web application under development by Monadical. It utilizes AI to record meetings, providing a permanent record with transcripts, translations, and automated summaries.
-[![Tests](https://github.com/monadical-sas/reflector/actions/workflows/test_server.yml/badge.svg?branch=main&event=push)](https://github.com/monadical-sas/reflector/actions/workflows/test_server.yml)
+[![Tests](https://github.com/monadical-sas/reflector/actions/workflows/pytests.yml/badge.svg?branch=main&event=push)](https://github.com/monadical-sas/reflector/actions/workflows/pytests.yml)
 [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://opensource.org/licenses/MIT)
 </div>
-</div>
+
 ## Screenshots
 <table>
  <tr>
    <td>
-      <a href="https://github.com/user-attachments/assets/21f5597c-2930-4899-a154-f7bd61a59e97">
+      <a href="https://github.com/user-attachments/assets/3a976930-56c1-47ef-8c76-55d3864309e3">
-        <img width="700" alt="image" src="https://github.com/user-attachments/assets/21f5597c-2930-4899-a154-f7bd61a59e97" />
+        <img width="700" alt="image" src="https://github.com/user-attachments/assets/3a976930-56c1-47ef-8c76-55d3864309e3" />
      </a>
    </td>
    <td>
-      <a href="https://github.com/user-attachments/assets/f6b9399a-5e51-4bae-b807-59128d0a940c">
+      <a href="https://github.com/user-attachments/assets/bfe3bde3-08af-4426-a9a1-11ad5cd63b33">
-        <img width="700" alt="image" src="https://github.com/user-attachments/assets/f6b9399a-5e51-4bae-b807-59128d0a940c" />
+        <img width="700" alt="image" src="https://github.com/user-attachments/assets/bfe3bde3-08af-4426-a9a1-11ad5cd63b33" />
      </a>
    </td>
    <td>
-      <a href="https://github.com/user-attachments/assets/a42ce460-c1fd-4489-a995-270516193897">
+      <a href="https://github.com/user-attachments/assets/7b60c9d0-efe4-474f-a27b-ea13bd0fabdc">
-        <img width="700" alt="image" src="https://github.com/user-attachments/assets/a42ce460-c1fd-4489-a995-270516193897" />
+        <img width="700" alt="image" src="https://github.com/user-attachments/assets/7b60c9d0-efe4-474f-a27b-ea13bd0fabdc" />
      </a>
    </td>
    <td>
      <a href="https://github.com/user-attachments/assets/21929f6d-c309-42fe-9c11-f1299e50fbd4">
        <img width="700" alt="image" src="https://github.com/user-attachments/assets/21929f6d-c309-42fe-9c11-f1299e50fbd4" />
      </a>
    </td>
  </tr>
 </table>
 ## What is Reflector?
 Reflector is a web application that utilizes local models to process audio content, providing:
 - **Real-time Transcription**: Convert speech to text using [Whisper](https://github.com/openai/whisper) (multi-language) or [Parakeet](https://huggingface.co/nvidia/parakeet-tdt-0.6b-v2) (English) models
 - **Speaker Diarization**: Identify and label different speakers using [Pyannote](https://github.com/pyannote/pyannote-audio) 3.1
 - **Live Translation**: Translate audio content in real-time to many languages with [Facebook Seamless-M4T](https://github.com/facebookresearch/seamless_communication)
 - **Topic Detection & Summarization**: Extract key topics and generate concise summaries using LLMs
 - **Meeting Recording**: Create permanent records of meetings with searchable transcripts
 Currently we provide [modal.com](https://modal.com/) gpu template to deploy.
 ## Background
 The project architecture consists of three primary components:
 - **Back-End**: Python server that offers an API and data persistence, found in `server/`.
 - **Front-End**: NextJS React project hosted on Vercel, located in `www/`.
- **GPU implementation**: Providing services such as speech-to-text transcription, topic generation, automated summaries, and translations.
+- **Back-End**: Python server that offers an API and data persistence, found in `server/`.
 - **GPU implementation**: Providing services such as speech-to-text transcription, topic generation, automated summaries, and translations. Most reliable option is Modal deployment
-It also uses authentik for authentication if activated.
+It also uses authentik for authentication if activated, and Vercel for deployment and configuration of the front-end.
 ## Contribution Guidelines
@@ -89,8 +72,6 @@ Note: We currently do not have instructions for Windows users.
 ## Installation
 *Note: we're working toward better installation, theses instructions are not accurate for now*
 ### Frontend
 Start with `cd www`.
@@ -99,10 +80,11 @@ Start with `cd www`.
 ```bash
 pnpm install
-cp .env.example .env
+cp .env_template .env
 cp config-template.ts config.ts
 ```
-Then, fill in the environment variables in `.env` as needed. If you are unsure on how to proceed, ask in Zulip.
+Then, fill in the environment variables in `.env` and the configuration in `config.ts` as needed. If you are unsure on how to proceed, ask in Zulip.
 **Run in development mode**
@@ -167,41 +149,3 @@ You can manually process an audio file by calling the process tool:
 ```bash
 uv run python -m reflector.tools.process path/to/audio.wav
 ```
 ## Build-time env variables
 Next.js projects are more used to NEXT_PUBLIC_ prefixed buildtime vars. We don't have those for the reason we need to serve a ccustomizable prebuild docker container.
 Instead, all the variables are runtime. Variables needed to the frontend are served to the frontend app at initial render.
 It also means there's no static prebuild and no static files to serve for js/html.
 ## Feature Flags
 Reflector uses environment variable-based feature flags to control application functionality. These flags allow you to enable or disable features without code changes.
 ### Available Feature Flags
 | Feature Flag | Environment Variable |
 |-------------|---------------------|
 | `requireLogin` | `FEATURE_REQUIRE_LOGIN` |
 | `privacy` | `FEATURE_PRIVACY` |
 | `browse` | `FEATURE_BROWSE` |
 | `sendToZulip` | `FEATURE_SEND_TO_ZULIP` |
 | `rooms` | `FEATURE_ROOMS` |
 ### Setting Feature Flags
 Feature flags are controlled via environment variables using the pattern `FEATURE_{FEATURE_NAME}` where `{FEATURE_NAME}` is the SCREAMING_SNAKE_CASE version of the feature name.
 **Examples:**
 ```bash
 # Enable user authentication requirement
 FEATURE_REQUIRE_LOGIN=true
 # Disable browse functionality
 FEATURE_BROWSE=false
 # Enable Zulip integration
 FEATURE_SEND_TO_ZULIP=true
 ```
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -6,7 +6,6 @@ services:
      - 1250:1250
    volumes:
      - ./server/:/app/
      - /app/.venv
    env_file:
      - ./server/.env
    environment:
@@ -17,7 +16,6 @@ services:
      context: server
    volumes:
      - ./server/:/app/
      - /app/.venv
    env_file:
      - ./server/.env
    environment:
@@ -28,7 +26,6 @@ services:
      context: server
    volumes:
      - ./server/:/app/
      - /app/.venv
    env_file:
      - ./server/.env
    environment:
@@ -39,7 +36,7 @@ services:
    ports:
      - 6379:6379
  web:
-    image: node:22-alpine
+    image: node:18
    ports:
      - "3000:3000"
    command: sh -c "corepack enable && pnpm install && pnpm dev"
@@ -50,8 +47,6 @@ services:
      - /app/node_modules
    env_file:
      - ./www/.env.local
    environment:
      - NODE_ENV=development
  postgres:
    image: postgres:17
--- a/docker-compose.prod.yml
+++ b/docker-compose.prod.yml
@@ -1,39 +0,0 @@
 # Production Docker Compose configuration for Frontend
 # Usage: docker compose -f docker-compose.prod.yml up -d
 services:
  web:
    build:
      context: ./www
      dockerfile: Dockerfile
    image: reflector-frontend:latest
    environment:
      - KV_URL=${KV_URL:-redis://redis:6379}
      - SITE_URL=${SITE_URL}
      - API_URL=${API_URL}
      - WEBSOCKET_URL=${WEBSOCKET_URL}
      - NEXTAUTH_URL=${NEXTAUTH_URL:-http://localhost:3000}
      - NEXTAUTH_SECRET=${NEXTAUTH_SECRET:-changeme-in-production}
      - AUTHENTIK_ISSUER=${AUTHENTIK_ISSUER}
      - AUTHENTIK_CLIENT_ID=${AUTHENTIK_CLIENT_ID}
      - AUTHENTIK_CLIENT_SECRET=${AUTHENTIK_CLIENT_SECRET}
      - AUTHENTIK_REFRESH_TOKEN_URL=${AUTHENTIK_REFRESH_TOKEN_URL}
      - SENTRY_DSN=${SENTRY_DSN}
      - SENTRY_IGNORE_API_RESOLUTION_ERROR=${SENTRY_IGNORE_API_RESOLUTION_ERROR:-1}
    depends_on:
      - redis
    restart: unless-stopped
  redis:
    image: redis:7.2-alpine
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 30s
      timeout: 3s
      retries: 3
    volumes:
      - redis_data:/data
 volumes:
  redis_data:
--- a/gpu/modal_deployments/.gitignore
+++ b/gpu/modal_deployments/.gitignore
@@ -1,33 +0,0 @@
 # OS / Editor
 .DS_Store
 .vscode/
 .idea/
 # Python
 __pycache__/
 *.py[cod]
 *$py.class
 # Logs
 *.log
 # Env and secrets
 .env
 .env.*
 *.env
 *.secret
 # Build / dist
 build/
 dist/
 .eggs/
 *.egg-info/
 # Coverage / test
 .pytest_cache/
 .coverage*
 htmlcov/
 # Modal local state (if any)
 modal_mounts/
 .modal_cache/
--- a/gpu/modal_deployments/reflector_transcriber.py
+++ b/gpu/modal_deployments/reflector_transcriber.py
@@ -1,608 +0,0 @@
 import os
 import sys
 import threading
 import uuid
 from typing import Generator, Mapping, NamedTuple, NewType, TypedDict
 from urllib.parse import urlparse
 import modal
 MODEL_NAME = "large-v2"
 MODEL_COMPUTE_TYPE: str = "float16"
 MODEL_NUM_WORKERS: int = 1
 MINUTES = 60  # seconds
 SAMPLERATE = 16000
 UPLOADS_PATH = "/uploads"
 CACHE_PATH = "/models"
 SUPPORTED_FILE_EXTENSIONS = ["mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm"]
 VAD_CONFIG = {
    "batch_max_duration": 30.0,
    "silence_padding": 0.5,
    "window_size": 512,
 }
 WhisperUniqFilename = NewType("WhisperUniqFilename", str)
 AudioFileExtension = NewType("AudioFileExtension", str)
 app = modal.App("reflector-transcriber")
 model_cache = modal.Volume.from_name("models", create_if_missing=True)
 upload_volume = modal.Volume.from_name("whisper-uploads", create_if_missing=True)
 class TimeSegment(NamedTuple):
    """Represents a time segment with start and end times."""
    start: float
    end: float
 class AudioSegment(NamedTuple):
    """Represents an audio segment with timing and audio data."""
    start: float
    end: float
    audio: any
 class TranscriptResult(NamedTuple):
    """Represents a transcription result with text and word timings."""
    text: str
    words: list["WordTiming"]
 class WordTiming(TypedDict):
    """Represents a word with its timing information."""
    word: str
    start: float
    end: float
 def download_model():
    from faster_whisper import download_model
    model_cache.reload()
    download_model(MODEL_NAME, cache_dir=CACHE_PATH)
    model_cache.commit()
 image = (
    modal.Image.debian_slim(python_version="3.12")
    .env(
        {
            "HF_HUB_ENABLE_HF_TRANSFER": "1",
            "LD_LIBRARY_PATH": (
                "/usr/local/lib/python3.12/site-packages/nvidia/cudnn/lib/:"
                "/opt/conda/lib/python3.12/site-packages/nvidia/cublas/lib/"
            ),
        }
    )
    .apt_install("ffmpeg")
    .pip_install(
        "huggingface_hub==0.27.1",
        "hf-transfer==0.1.9",
        "torch==2.5.1",
        "faster-whisper==1.1.1",
        "fastapi==0.115.12",
        "requests",
        "librosa==0.10.1",
        "numpy<2",
        "silero-vad==5.1.0",
    )
    .run_function(download_model, volumes={CACHE_PATH: model_cache})
 )
 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[WhisperUniqFilename, 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 = WhisperUniqFilename(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.5s of silence if audio is shorter than the silence_padding window.
    Whisper does not require this strictly, but aligning behavior with Parakeet
    avoids edge-case crashes on extremely short inputs and makes comparisons easier.
    """
    import numpy as np
    audio_duration = len(audio_array) / sample_rate
    if audio_duration < VAD_CONFIG["silence_padding"]:
        silence_samples = int(sample_rate * VAD_CONFIG["silence_padding"])
        silence = np.zeros(silence_samples, dtype=np.float32)
        return np.concatenate([audio_array, silence])
    return audio_array
@app.cls(
    gpu="A10G",
    timeout=5 * MINUTES,
    scaledown_window=5 * MINUTES,
    image=image,
    volumes={CACHE_PATH: model_cache, UPLOADS_PATH: upload_volume},
 )
@modal.concurrent(max_inputs=10)
 class TranscriberWhisperLive:
    """Live transcriber class for small audio segments (A10G).
    Mirrors the Parakeet live class API but uses Faster-Whisper under the hood.
    """
    @modal.enter()
    def enter(self):
        import faster_whisper
        import torch
        self.lock = threading.Lock()
        self.use_gpu = torch.cuda.is_available()
        self.device = "cuda" if self.use_gpu else "cpu"
        self.model = faster_whisper.WhisperModel(
            MODEL_NAME,
            device=self.device,
            compute_type=MODEL_COMPUTE_TYPE,
            num_workers=MODEL_NUM_WORKERS,
            download_root=CACHE_PATH,
            local_files_only=True,
        )
        print(f"Model is on device: {self.device}")
    @modal.method()
    def transcribe_segment(
        self,
        filename: str,
        language: str = "en",
    ):
        """Transcribe a single uploaded audio file by filename."""
        upload_volume.reload()
        file_path = f"{UPLOADS_PATH}/{filename}"
        if not os.path.exists(file_path):
            raise FileNotFoundError(f"File not found: {file_path}")
        with self.lock:
            with NoStdStreams():
                segments, _ = self.model.transcribe(
                    file_path,
                    language=language,
                    beam_size=5,
                    word_timestamps=True,
                    vad_filter=True,
                    vad_parameters={"min_silence_duration_ms": 500},
                )
        segments = list(segments)
        text = "".join(segment.text for segment in segments).strip()
        words = [
            {
                "word": word.word,
                "start": round(float(word.start), 2),
                "end": round(float(word.end), 2),
            }
            for segment in segments
            for word in segment.words
        ]
        return {"text": text, "words": words}
    @modal.method()
    def transcribe_batch(
        self,
        filenames: list[str],
        language: str = "en",
    ):
        """Transcribe multiple uploaded audio files and return per-file results."""
        upload_volume.reload()
        results = []
        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}")
            with self.lock:
                with NoStdStreams():
                    segments, _ = self.model.transcribe(
                        file_path,
                        language=language,
                        beam_size=5,
                        word_timestamps=True,
                        vad_filter=True,
                        vad_parameters={"min_silence_duration_ms": 500},
                    )
            segments = list(segments)
            text = "".join(seg.text for seg in segments).strip()
            words = [
                {
                    "word": w.word,
                    "start": round(float(w.start), 2),
                    "end": round(float(w.end), 2),
                }
                for seg in segments
                for w in seg.words
            ]
            results.append(
                {
                    "filename": filename,
                    "text": text,
                    "words": words,
                }
            )
        return results
@app.cls(
    gpu="L40S",
    timeout=15 * MINUTES,
    image=image,
    volumes={CACHE_PATH: model_cache, UPLOADS_PATH: upload_volume},
 )
 class TranscriberWhisperFile:
    """File transcriber for larger/longer audio, using VAD-driven batching (L40S)."""
    @modal.enter()
    def enter(self):
        import faster_whisper
        import torch
        from silero_vad import load_silero_vad
        self.lock = threading.Lock()
        self.use_gpu = torch.cuda.is_available()
        self.device = "cuda" if self.use_gpu else "cpu"
        self.model = faster_whisper.WhisperModel(
            MODEL_NAME,
            device=self.device,
            compute_type=MODEL_COMPUTE_TYPE,
            num_workers=MODEL_NUM_WORKERS,
            download_root=CACHE_PATH,
            local_files_only=True,
        )
        self.vad_model = load_silero_vad(onnx=False)
    @modal.method()
    def transcribe_segment(
        self, filename: str, timestamp_offset: float = 0.0, language: str = "en"
    ):
        import librosa
        import numpy as np
        from silero_vad import VADIterator
        def vad_segments(
            audio_array,
            sample_rate: int = SAMPLERATE,
            window_size: int = VAD_CONFIG["window_size"],
        ) -> Generator[TimeSegment, None, None]:
            """Generate speech segments as TimeSegment using Silero VAD."""
            iterator = VADIterator(self.vad_model, sampling_rate=sample_rate)
            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 = iterator(chunk)
                if not speech:
                    continue
                if "start" in speech:
                    start = speech["start"]
                    continue
                if "end" in speech and start is not None:
                    end = speech["end"]
                    yield TimeSegment(
                        start / float(SAMPLERATE), end / float(SAMPLERATE)
                    )
                    start = None
            iterator.reset_states()
        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, _sr = librosa.load(file_path, sr=SAMPLERATE, mono=True)
        # Batch segments up to ~30s windows by merging contiguous VAD segments
        merged_batches: list[TimeSegment] = []
        batch_start = None
        batch_end = None
        max_duration = VAD_CONFIG["batch_max_duration"]
        for segment in vad_segments(audio_array):
            seg_start, seg_end = segment.start, segment.end
            if batch_start is None:
                batch_start, batch_end = seg_start, seg_end
                continue
            if seg_end - batch_start <= max_duration:
                batch_end = seg_end
            else:
                merged_batches.append(TimeSegment(batch_start, batch_end))
                batch_start, batch_end = seg_start, seg_end
        if batch_start is not None and batch_end is not None:
            merged_batches.append(TimeSegment(batch_start, batch_end))
        all_text = []
        all_words = []
        for segment in merged_batches:
            start_time, end_time = segment.start, segment.end
            s_idx = int(start_time * SAMPLERATE)
            e_idx = int(end_time * SAMPLERATE)
            segment = audio_array[s_idx:e_idx]
            segment = pad_audio(segment, SAMPLERATE)
            with self.lock:
                segments, _ = self.model.transcribe(
                    segment,
                    language=language,
                    beam_size=5,
                    word_timestamps=True,
                    vad_filter=True,
                    vad_parameters={"min_silence_duration_ms": 500},
                )
            segments = list(segments)
            text = "".join(seg.text for seg in segments).strip()
            words = [
                {
                    "word": w.word,
                    "start": round(float(w.start) + start_time + timestamp_offset, 2),
                    "end": round(float(w.end) + start_time + timestamp_offset, 2),
                }
                for seg in segments
                for w in seg.words
            ]
            if text:
                all_text.append(text)
            all_words.extend(words)
        return {"text": " ".join(all_text), "words": all_words}
 def detect_audio_format(url: str, headers: dict) -> str:
    from urllib.parse import urlparse
    from fastapi import HTTPException
    url_path = urlparse(url).path
    for ext in SUPPORTED_FILE_EXTENSIONS:
        if url_path.lower().endswith(f".{ext}"):
            return ext
    content_type = headers.get("content-type", "").lower()
    if "audio/mpeg" in content_type or "audio/mp3" in content_type:
        return "mp3"
    if "audio/wav" in content_type:
        return "wav"
    if "audio/mp4" in content_type:
        return "mp4"
    raise HTTPException(
        status_code=400,
        detail=(
            f"Unsupported audio format for URL. Supported extensions: {', '.join(SUPPORTED_FILE_EXTENSIONS)}"
        ),
    )
 def download_audio_to_volume(audio_file_url: str) -> tuple[str, str]:
    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 = 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
@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():
    from fastapi import (
        Body,
        Depends,
        FastAPI,
        Form,
        HTTPException,
        UploadFile,
        status,
    )
    from fastapi.security import OAuth2PasswordBearer
    transcriber_live = TranscriberWhisperLive()
    transcriber_file = TranscriberWhisperFile()
    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(dict):
        pass
    @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),
    ):
        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
        uploaded_filenames: list[str] = []
        for upload_file in upload_files:
            audio_suffix = upload_file.filename.split(".")[-1]
            if audio_suffix not in SUPPORTED_FILE_EXTENSIONS:
                raise HTTPException(
                    status_code=400,
                    detail=(
                        f"Unsupported audio format. Supported extensions: {', '.join(SUPPORTED_FILE_EXTENSIONS)}"
                    ),
                )
            unique_filename = f"{uuid.uuid4()}.{audio_suffix}"
            file_path = f"{UPLOADS_PATH}/{unique_filename}"
            with open(file_path, "wb") as f:
                content = upload_file.file.read()
                f.write(content)
            uploaded_filenames.append(unique_filename)
        upload_volume.commit()
        try:
            if batch and len(upload_files) > 1:
                func = transcriber_live.transcribe_batch.spawn(
                    filenames=uploaded_filenames,
                    language=language,
                )
                results = func.get()
                return {"results": results}
            results = []
            for filename in uploaded_filenames:
                func = transcriber_live.transcribe_segment.spawn(
                    filename=filename,
                    language=language,
                )
                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}"
                    os.remove(file_path)
                except Exception:
                    pass
            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"),
        timestamp_offset: float = Body(0.0),
    ):
        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,
                language=language,
            )
            result = func.get()
            return result
        finally:
            try:
                file_path = f"{UPLOADS_PATH}/{unique_filename}"
                os.remove(file_path)
                upload_volume.commit()
            except Exception:
                pass
    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/gpu/self_hosted/.env.example
+++ b/gpu/self_hosted/.env.example
@@ -1,2 +0,0 @@
 REFLECTOR_GPU_APIKEY=
 HF_TOKEN=
--- a/gpu/self_hosted/.gitignore
+++ b/gpu/self_hosted/.gitignore
@@ -1,38 +0,0 @@
 cache/
 # OS / Editor
 .DS_Store
 .vscode/
 .idea/
 # Python
 __pycache__/
 *.py[cod]
 *$py.class
 # Env and secrets
 .env
 *.env
 *.secret
 HF_TOKEN
 REFLECTOR_GPU_APIKEY
 # Virtual env / uv
 .venv/
 venv/
 ENV/
 uv/
 # Build / dist
 build/
 dist/
 .eggs/
 *.egg-info/
 # Coverage / test
 .pytest_cache/
 .coverage*
 htmlcov/
 # Logs
 *.log
--- a/gpu/self_hosted/Dockerfile
+++ b/gpu/self_hosted/Dockerfile
@@ -1,46 +0,0 @@
 FROM python:3.12-slim
 ENV PYTHONUNBUFFERED=1 \
    UV_LINK_MODE=copy \
    UV_NO_CACHE=1
 WORKDIR /tmp
 RUN apt-get update \
 && apt-get install -y \
    ffmpeg \
    curl \
    ca-certificates \
    gnupg \
    wget \
 && apt-get clean
 # Add NVIDIA CUDA repo for Debian 12 (bookworm) and install cuDNN 9 for CUDA 12
 ADD https://developer.download.nvidia.com/compute/cuda/repos/debian12/x86_64/cuda-keyring_1.1-1_all.deb /cuda-keyring.deb
 RUN dpkg -i /cuda-keyring.deb \
 && rm /cuda-keyring.deb \
 && apt-get update \
 && apt-get install -y --no-install-recommends \
    cuda-cudart-12-6 \
    libcublas-12-6 \
    libcudnn9-cuda-12 \
    libcudnn9-dev-cuda-12 \
 && apt-get clean \
 && rm -rf /var/lib/apt/lists/*
 ADD https://astral.sh/uv/install.sh /uv-installer.sh
 RUN sh /uv-installer.sh && rm /uv-installer.sh
 ENV PATH="/root/.local/bin/:$PATH"
 ENV LD_LIBRARY_PATH="/usr/local/cuda/lib64:/usr/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH"
 RUN mkdir -p /app
 WORKDIR /app
 COPY pyproject.toml uv.lock /app/
 COPY ./app /app/app
 COPY ./main.py /app/
 COPY ./runserver.sh /app/
 EXPOSE 8000
 CMD ["sh", "/app/runserver.sh"]
--- a/gpu/self_hosted/README.md
+++ b/gpu/self_hosted/README.md
@@ -1,73 +0,0 @@
 # Self-hosted Model API
 Run transcription, translation, and diarization services compatible with Reflector's GPU Model API. Works on CPU or GPU.
 Environment variables
 - REFLECTOR_GPU_APIKEY: Optional Bearer token. If unset, auth is disabled.
 - HF_TOKEN: Optional. Required for diarization to download pyannote pipelines
 Requirements
 - FFmpeg must be installed and on PATH (used for URL-based and segmented transcription)
 - Python 3.12+
 - NVIDIA GPU optional. If available, it will be used automatically
 Local run
 Set env vars in self_hosted/.env file
 uv sync
 uv run uvicorn main:app --host 0.0.0.0 --port 8000
 Authentication
 - If REFLECTOR_GPU_APIKEY is set, include header: Authorization: Bearer <key>
 Endpoints
 - POST /v1/audio/transcriptions
  - multipart/form-data
  - fields: file (single file) OR files[] (multiple files), language, batch (true/false)
  - response: single { text, words, filename } or { results: [ ... ] }
 - POST /v1/audio/transcriptions-from-url
  - application/json
  - body: { audio_file_url, language, timestamp_offset }
  - response: { text, words }
 - POST /translate
  - text: query parameter
  - body (application/json): { source_language, target_language }
  - response: { text: { <src>: original, <tgt>: translated } }
 - POST /diarize
  - query parameters: audio_file_url, timestamp (optional)
  - requires HF_TOKEN to be set (for pyannote)
  - response: { diarization: [ { start, end, speaker } ] }
 OpenAPI docs
 - Visit /docs when the server is running
 Docker
 - Not yet provided in this directory. A Dockerfile will be added later. For now, use Local run above
 Conformance tests
 # From this directory
 TRANSCRIPT_URL=http://localhost:8000 \
 TRANSCRIPT_API_KEY=dev-key \
 uv run -m pytest -m model_api --no-cov ../../server/tests/test_model_api_transcript.py
 TRANSLATION_URL=http://localhost:8000 \
 TRANSLATION_API_KEY=dev-key \
 uv run -m pytest -m model_api --no-cov ../../server/tests/test_model_api_translation.py
 DIARIZATION_URL=http://localhost:8000 \
 DIARIZATION_API_KEY=dev-key \
 uv run -m pytest -m model_api --no-cov ../../server/tests/test_model_api_diarization.py
--- a/gpu/self_hosted/app/auth.py
+++ b/gpu/self_hosted/app/auth.py
@@ -1,19 +0,0 @@
 import os
 from fastapi import Depends, HTTPException, status
 from fastapi.security import OAuth2PasswordBearer
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
 def apikey_auth(apikey: str = Depends(oauth2_scheme)):
    required_key = os.environ.get("REFLECTOR_GPU_APIKEY")
    if not required_key:
        return
    if apikey == required_key:
        return
    raise HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="Invalid API key",
        headers={"WWW-Authenticate": "Bearer"},
    )
--- a/gpu/self_hosted/app/config.py
+++ b/gpu/self_hosted/app/config.py
@@ -1,12 +0,0 @@
 from pathlib import Path
 SUPPORTED_FILE_EXTENSIONS = ["mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm"]
 SAMPLE_RATE = 16000
 VAD_CONFIG = {
    "batch_max_duration": 30.0,
    "silence_padding": 0.5,
    "window_size": 512,
 }
 # App-level paths
 UPLOADS_PATH = Path("/tmp/whisper-uploads")
--- a/gpu/self_hosted/app/factory.py
+++ b/gpu/self_hosted/app/factory.py
@@ -1,30 +0,0 @@
 from contextlib import asynccontextmanager
 from fastapi import FastAPI
 from .routers.diarization import router as diarization_router
 from .routers.transcription import router as transcription_router
 from .routers.translation import router as translation_router
 from .services.transcriber import WhisperService
 from .services.diarizer import PyannoteDiarizationService
 from .utils import ensure_dirs
@asynccontextmanager
 async def lifespan(app: FastAPI):
    ensure_dirs()
    whisper_service = WhisperService()
    whisper_service.load()
    app.state.whisper = whisper_service
    diarization_service = PyannoteDiarizationService()
    diarization_service.load()
    app.state.diarizer = diarization_service
    yield
 def create_app() -> FastAPI:
    app = FastAPI(lifespan=lifespan)
    app.include_router(transcription_router)
    app.include_router(translation_router)
    app.include_router(diarization_router)
    return app
--- a/gpu/self_hosted/app/routers/diarization.py
+++ b/gpu/self_hosted/app/routers/diarization.py
@@ -1,30 +0,0 @@
 from typing import List
 from fastapi import APIRouter, Depends, Request
 from pydantic import BaseModel
 from ..auth import apikey_auth
 from ..services.diarizer import PyannoteDiarizationService
 from ..utils import download_audio_file
 router = APIRouter(tags=["diarization"])
 class DiarizationSegment(BaseModel):
    start: float
    end: float
    speaker: int
 class DiarizationResponse(BaseModel):
    diarization: List[DiarizationSegment]
@router.post(
    "/diarize", dependencies=[Depends(apikey_auth)], response_model=DiarizationResponse
 )
 def diarize(request: Request, audio_file_url: str, timestamp: float = 0.0):
    with download_audio_file(audio_file_url) as (file_path, _ext):
        file_path = str(file_path)
        diarizer: PyannoteDiarizationService = request.app.state.diarizer
        return diarizer.diarize_file(file_path, timestamp=timestamp)
--- a/gpu/self_hosted/app/routers/transcription.py
+++ b/gpu/self_hosted/app/routers/transcription.py
@@ -1,109 +0,0 @@
 import uuid
 from typing import Optional, Union
 from fastapi import APIRouter, Body, Depends, Form, HTTPException, Request, UploadFile
 from pydantic import BaseModel
 from pathlib import Path
 from ..auth import apikey_auth
 from ..config import SUPPORTED_FILE_EXTENSIONS, UPLOADS_PATH
 from ..services.transcriber import MODEL_NAME
 from ..utils import cleanup_uploaded_files, download_audio_file
 router = APIRouter(prefix="/v1/audio", tags=["transcription"])
 class WordTiming(BaseModel):
    word: str
    start: float
    end: float
 class TranscriptResult(BaseModel):
    text: str
    words: list[WordTiming]
    filename: Optional[str] = None
 class TranscriptBatchResponse(BaseModel):
    results: list[TranscriptResult]
@router.post(
    "/transcriptions",
    dependencies=[Depends(apikey_auth)],
    response_model=Union[TranscriptResult, TranscriptBatchResponse],
 )
 def transcribe(
    request: Request,
    file: UploadFile = None,
    files: list[UploadFile] | None = None,
    model: str = Form(MODEL_NAME),
    language: str = Form("en"),
    batch: bool = Form(False),
 ):
    service = request.app.state.whisper
    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
    uploaded_paths: list[Path] = []
    with cleanup_uploaded_files(uploaded_paths):
        for upload_file in upload_files:
            audio_suffix = upload_file.filename.split(".")[-1].lower()
            if audio_suffix not in SUPPORTED_FILE_EXTENSIONS:
                raise HTTPException(
                    status_code=400,
                    detail=(
                        f"Unsupported audio format. Supported extensions: {', '.join(SUPPORTED_FILE_EXTENSIONS)}"
                    ),
                )
            unique_filename = f"{uuid.uuid4()}.{audio_suffix}"
            file_path = UPLOADS_PATH / unique_filename
            with open(file_path, "wb") as f:
                content = upload_file.file.read()
                f.write(content)
            uploaded_paths.append(file_path)
        if batch and len(upload_files) > 1:
            results = []
            for path in uploaded_paths:
                result = service.transcribe_file(str(path), language=language)
                result["filename"] = path.name
                results.append(result)
            return {"results": results}
        results = []
        for path in uploaded_paths:
            result = service.transcribe_file(str(path), language=language)
            result["filename"] = path.name
            results.append(result)
        return {"results": results} if len(results) > 1 else results[0]
@router.post(
    "/transcriptions-from-url",
    dependencies=[Depends(apikey_auth)],
    response_model=TranscriptResult,
 )
 def transcribe_from_url(
    request: Request,
    audio_file_url: str = Body(..., description="URL of the audio file to transcribe"),
    model: str = Body(MODEL_NAME),
    language: str = Body("en"),
    timestamp_offset: float = Body(0.0),
 ):
    service = request.app.state.whisper
    with download_audio_file(audio_file_url) as (file_path, _ext):
        file_path = str(file_path)
        result = service.transcribe_vad_url_segment(
            file_path=file_path, timestamp_offset=timestamp_offset, language=language
        )
        return result
--- a/gpu/self_hosted/app/routers/translation.py
+++ b/gpu/self_hosted/app/routers/translation.py
@@ -1,28 +0,0 @@
 from typing import Dict
 from fastapi import APIRouter, Body, Depends
 from pydantic import BaseModel
 from ..auth import apikey_auth
 from ..services.translator import TextTranslatorService
 router = APIRouter(tags=["translation"])
 translator = TextTranslatorService()
 class TranslationResponse(BaseModel):
    text: Dict[str, str]
@router.post(
    "/translate",
    dependencies=[Depends(apikey_auth)],
    response_model=TranslationResponse,
 )
 def translate(
    text: str,
    source_language: str = Body("en"),
    target_language: str = Body("fr"),
 ):
    return translator.translate(text, source_language, target_language)
--- a/gpu/self_hosted/app/services/diarizer.py
+++ b/gpu/self_hosted/app/services/diarizer.py
@@ -1,42 +0,0 @@
 import os
 import threading
 import torch
 import torchaudio
 from pyannote.audio import Pipeline
 class PyannoteDiarizationService:
    def __init__(self):
        self._pipeline = None
        self._device = "cpu"
        self._lock = threading.Lock()
    def load(self):
        self._device = "cuda" if torch.cuda.is_available() else "cpu"
        self._pipeline = Pipeline.from_pretrained(
            "pyannote/speaker-diarization-3.1",
            use_auth_token=os.environ.get("HF_TOKEN"),
        )
        self._pipeline.to(torch.device(self._device))
    def diarize_file(self, file_path: str, timestamp: float = 0.0) -> dict:
        if self._pipeline is None:
            self.load()
        waveform, sample_rate = torchaudio.load(file_path)
        with self._lock:
            diarization = self._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:])
                    if speaker and speaker[-2:].isdigit()
                    else 0,
                }
            )
        return {"diarization": words}
--- a/gpu/self_hosted/app/services/transcriber.py
+++ b/gpu/self_hosted/app/services/transcriber.py
@@ -1,208 +0,0 @@
 import os
 import shutil
 import subprocess
 import threading
 from typing import Generator
 import faster_whisper
 import librosa
 import numpy as np
 import torch
 from fastapi import HTTPException
 from silero_vad import VADIterator, load_silero_vad
 from ..config import SAMPLE_RATE, VAD_CONFIG
 # Whisper configuration (service-local defaults)
 MODEL_NAME = "large-v2"
 # None delegates compute type to runtime: float16 on CUDA, int8 on CPU
 MODEL_COMPUTE_TYPE = None
 MODEL_NUM_WORKERS = 1
 CACHE_PATH = os.path.join(os.path.expanduser("~"), ".cache", "reflector-whisper")
 from ..utils import NoStdStreams
 class WhisperService:
    def __init__(self):
        self.model = None
        self.device = "cpu"
        self.lock = threading.Lock()
    def load(self):
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        compute_type = MODEL_COMPUTE_TYPE or (
            "float16" if self.device == "cuda" else "int8"
        )
        self.model = faster_whisper.WhisperModel(
            MODEL_NAME,
            device=self.device,
            compute_type=compute_type,
            num_workers=MODEL_NUM_WORKERS,
            download_root=CACHE_PATH,
        )
    def pad_audio(self, audio_array, sample_rate: int = SAMPLE_RATE):
        audio_duration = len(audio_array) / sample_rate
        if audio_duration < VAD_CONFIG["silence_padding"]:
            silence_samples = int(sample_rate * VAD_CONFIG["silence_padding"])
            silence = np.zeros(silence_samples, dtype=np.float32)
            return np.concatenate([audio_array, silence])
        return audio_array
    def enforce_word_timing_constraints(self, words: list[dict]) -> list[dict]:
        if len(words) <= 1:
            return words
        enforced: list[dict] = []
        for i, word in enumerate(words):
            current = dict(word)
            if i < len(words) - 1:
                next_start = words[i + 1]["start"]
                if current["end"] > next_start:
                    current["end"] = next_start
            enforced.append(current)
        return enforced
    def transcribe_file(self, file_path: str, language: str = "en") -> dict:
        input_for_model: str | "object" = file_path
        try:
            audio_array, _sample_rate = librosa.load(
                file_path, sr=SAMPLE_RATE, mono=True
            )
            if len(audio_array) / float(SAMPLE_RATE) < VAD_CONFIG["silence_padding"]:
                input_for_model = self.pad_audio(audio_array, SAMPLE_RATE)
        except Exception:
            pass
        with self.lock:
            with NoStdStreams():
                segments, _ = self.model.transcribe(
                    input_for_model,
                    language=language,
                    beam_size=5,
                    word_timestamps=True,
                    vad_filter=True,
                    vad_parameters={"min_silence_duration_ms": 500},
                )
        segments = list(segments)
        text = "".join(segment.text for segment in segments).strip()
        words = [
            {
                "word": word.word,
                "start": round(float(word.start), 2),
                "end": round(float(word.end), 2),
            }
            for segment in segments
            for word in segment.words
        ]
        words = self.enforce_word_timing_constraints(words)
        return {"text": text, "words": words}
    def transcribe_vad_url_segment(
        self, file_path: str, timestamp_offset: float = 0.0, language: str = "en"
    ) -> dict:
        def load_audio_via_ffmpeg(input_path: str, sample_rate: int) -> np.ndarray:
            ffmpeg_bin = shutil.which("ffmpeg") or "ffmpeg"
            cmd = [
                ffmpeg_bin,
                "-nostdin",
                "-threads",
                "1",
                "-i",
                input_path,
                "-f",
                "f32le",
                "-acodec",
                "pcm_f32le",
                "-ac",
                "1",
                "-ar",
                str(sample_rate),
                "pipe:1",
            ]
            try:
                proc = subprocess.run(
                    cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True
                )
            except Exception as e:
                raise HTTPException(status_code=400, detail=f"ffmpeg failed: {e}")
            audio = np.frombuffer(proc.stdout, dtype=np.float32)
            return audio
        def vad_segments(
            audio_array,
            sample_rate: int = SAMPLE_RATE,
            window_size: int = VAD_CONFIG["window_size"],
        ) -> Generator[tuple[float, float], None, None]:
            vad_model = load_silero_vad(onnx=False)
            iterator = VADIterator(vad_model, sampling_rate=sample_rate)
            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 = iterator(chunk)
                if not speech:
                    continue
                if "start" in speech:
                    start = speech["start"]
                    continue
                if "end" in speech and start is not None:
                    end = speech["end"]
                    yield (start / float(SAMPLE_RATE), end / float(SAMPLE_RATE))
                    start = None
            iterator.reset_states()
        audio_array = load_audio_via_ffmpeg(file_path, SAMPLE_RATE)
        merged_batches: list[tuple[float, float]] = []
        batch_start = None
        batch_end = None
        max_duration = VAD_CONFIG["batch_max_duration"]
        for seg_start, seg_end in vad_segments(audio_array):
            if batch_start is None:
                batch_start, batch_end = seg_start, seg_end
                continue
            if seg_end - batch_start <= max_duration:
                batch_end = seg_end
            else:
                merged_batches.append((batch_start, batch_end))
                batch_start, batch_end = seg_start, seg_end
        if batch_start is not None and batch_end is not None:
            merged_batches.append((batch_start, batch_end))
        all_text = []
        all_words = []
        for start_time, end_time in merged_batches:
            s_idx = int(start_time * SAMPLE_RATE)
            e_idx = int(end_time * SAMPLE_RATE)
            segment = audio_array[s_idx:e_idx]
            segment = self.pad_audio(segment, SAMPLE_RATE)
            with self.lock:
                segments, _ = self.model.transcribe(
                    segment,
                    language=language,
                    beam_size=5,
                    word_timestamps=True,
                    vad_filter=True,
                    vad_parameters={"min_silence_duration_ms": 500},
                )
            segments = list(segments)
            text = "".join(seg.text for seg in segments).strip()
            words = [
                {
                    "word": w.word,
                    "start": round(float(w.start) + start_time + timestamp_offset, 2),
                    "end": round(float(w.end) + start_time + timestamp_offset, 2),
                }
                for seg in segments
                for w in seg.words
            ]
            if text:
                all_text.append(text)
            all_words.extend(words)
        all_words = self.enforce_word_timing_constraints(all_words)
        return {"text": " ".join(all_text), "words": all_words}
--- a/gpu/self_hosted/app/services/translator.py
+++ b/gpu/self_hosted/app/services/translator.py
@@ -1,44 +0,0 @@
 import threading
 from transformers import MarianMTModel, MarianTokenizer, pipeline
 class TextTranslatorService:
    """Simple text-to-text translator using HuggingFace MarianMT models.
    This mirrors the modal translator API shape but uses text translation only.
    """
    def __init__(self):
        self._pipeline = None
        self._lock = threading.Lock()
    def load(self, source_language: str = "en", target_language: str = "fr"):
        # Pick a default MarianMT model pair if available; fall back to Helsinki-NLP en->fr
        model_name = self._resolve_model_name(source_language, target_language)
        tokenizer = MarianTokenizer.from_pretrained(model_name)
        model = MarianMTModel.from_pretrained(model_name)
        self._pipeline = pipeline("translation", model=model, tokenizer=tokenizer)
    def _resolve_model_name(self, src: str, tgt: str) -> str:
        # Minimal mapping; extend as needed
        pair = (src.lower(), tgt.lower())
        mapping = {
            ("en", "fr"): "Helsinki-NLP/opus-mt-en-fr",
            ("fr", "en"): "Helsinki-NLP/opus-mt-fr-en",
            ("en", "es"): "Helsinki-NLP/opus-mt-en-es",
            ("es", "en"): "Helsinki-NLP/opus-mt-es-en",
            ("en", "de"): "Helsinki-NLP/opus-mt-en-de",
            ("de", "en"): "Helsinki-NLP/opus-mt-de-en",
        }
        return mapping.get(pair, "Helsinki-NLP/opus-mt-en-fr")
    def translate(self, text: str, source_language: str, target_language: str) -> dict:
        if self._pipeline is None:
            self.load(source_language, target_language)
        with self._lock:
            results = self._pipeline(
                text, src_lang=source_language, tgt_lang=target_language
            )
        translated = results[0]["translation_text"] if results else ""
        return {"text": {source_language: text, target_language: translated}}
--- a/gpu/self_hosted/app/utils.py
+++ b/gpu/self_hosted/app/utils.py
@@ -1,107 +0,0 @@
 import logging
 import os
 import sys
 import uuid
 from contextlib import contextmanager
 from typing import Mapping
 from urllib.parse import urlparse
 from pathlib import Path
 import requests
 from fastapi import HTTPException
 from .config import SUPPORTED_FILE_EXTENSIONS, UPLOADS_PATH
 logger = logging.getLogger(__name__)
 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()
 def ensure_dirs():
    UPLOADS_PATH.mkdir(parents=True, exist_ok=True)
 def detect_audio_format(url: str, headers: Mapping[str, str]) -> str:
    url_path = urlparse(url).path
    for ext in SUPPORTED_FILE_EXTENSIONS:
        if url_path.lower().endswith(f".{ext}"):
            return ext
    content_type = headers.get("content-type", "").lower()
    if "audio/mpeg" in content_type or "audio/mp3" in content_type:
        return "mp3"
    if "audio/wav" in content_type:
        return "wav"
    if "audio/mp4" in content_type:
        return "mp4"
    raise HTTPException(
        status_code=400,
        detail=(
            f"Unsupported audio format for URL. Supported extensions: {', '.join(SUPPORTED_FILE_EXTENSIONS)}"
        ),
    )
 def download_audio_to_uploads(audio_file_url: str) -> tuple[Path, str]:
    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 = f"{uuid.uuid4()}.{audio_suffix}"
    file_path: Path = UPLOADS_PATH / unique_filename
    with open(file_path, "wb") as f:
        f.write(response.content)
    return file_path, audio_suffix
@contextmanager
 def download_audio_file(audio_file_url: str):
    """Download an audio file to UPLOADS_PATH and remove it after use.
    Yields (file_path: Path, audio_suffix: str).
    """
    file_path, audio_suffix = download_audio_to_uploads(audio_file_url)
    try:
        yield file_path, audio_suffix
    finally:
        try:
            file_path.unlink(missing_ok=True)
        except Exception as e:
            logger.error("Error deleting temporary file %s: %s", file_path, e)
@contextmanager
 def cleanup_uploaded_files(file_paths: list[Path]):
    """Ensure provided file paths are removed after use.
    The provided list can be populated inside the context; all present entries
    at exit will be deleted.
    """
    try:
        yield file_paths
    finally:
        for path in list(file_paths):
            try:
                path.unlink(missing_ok=True)
            except Exception as e:
                logger.error("Error deleting temporary file %s: %s", path, e)
--- a/gpu/self_hosted/compose.yml
+++ b/gpu/self_hosted/compose.yml
@@ -1,10 +0,0 @@
 services:
  reflector_gpu:
    build:
      context: .
    ports:
      - "8000:8000"
    env_file:
      - .env
    volumes:
      - ./cache:/root/.cache
--- a/gpu/self_hosted/main.py
+++ b/gpu/self_hosted/main.py
@@ -1,3 +0,0 @@
 from app.factory import create_app
 app = create_app()
--- a/gpu/self_hosted/pyproject.toml
+++ b/gpu/self_hosted/pyproject.toml
@@ -1,19 +0,0 @@
 [project]
 name = "reflector-gpu"
 version = "0.1.0"
 description = "Self-hosted GPU service for speech transcription, diarization, and translation via FastAPI."
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
    "fastapi[standard]>=0.116.1",
    "uvicorn[standard]>=0.30.0",
    "torch>=2.3.0",
    "faster-whisper>=1.1.0",
    "librosa==0.10.1",
    "numpy<2",
    "silero-vad==5.1.0",
    "transformers>=4.35.0",
    "sentencepiece",
    "pyannote.audio==3.1.0",
    "torchaudio>=2.3.0",
 ]
--- a/gpu/self_hosted/runserver.sh
+++ b/gpu/self_hosted/runserver.sh
@@ -1,17 +0,0 @@
 #!/bin/sh
 set -e
 export PATH="/root/.local/bin:$PATH"
 cd /app
 # Install Python dependencies at runtime (first run or when FORCE_SYNC=1)
 if [ ! -d "/app/.venv" ] || [ "$FORCE_SYNC" = "1" ]; then
  echo "[startup] Installing Python dependencies with uv..."
  uv sync --compile-bytecode --locked
 else
  echo "[startup] Using existing virtual environment at /app/.venv"
 fi
 exec uv run uvicorn main:app --host 0.0.0.0 --port 8000
--- a/gpu/self_hosted/uv.lock
+++ b/gpu/self_hosted/uv.lock
--- a/server/DAILYCO_TEST.md
+++ b/server/DAILYCO_TEST.md
@@ -1,613 +0,0 @@
 # Daily.co Integration Test Plan
 ## ✅ IMPLEMENTATION STATUS: Real Transcription Active
 **This test validates Daily.co multitrack recording integration with REAL transcription/diarization.**
 The implementation includes complete audio processing pipeline:
 - **Multitrack recordings** from Daily.co S3 (separate audio stream per participant)
 - **PyAV-based audio mixdown** with PTS-based track alignment
 - **Real transcription** via Modal GPU backend (Whisper)
 - **Real diarization** via Modal GPU backend (speaker identification)
 - **Per-track transcription** with timestamp synchronization
 - **Complete database entities** (recording, transcript, topics, participants, words)
 **Processing pipeline** (`PipelineMainMultitrack`):
 1. Download all audio tracks from Daily.co S3
 2. Align tracks by PTS (presentation timestamp) to handle late joiners
 3. Mix tracks into single audio file for unified playback
 4. Transcribe each track individually with proper offset handling
 5. Perform diarization on mixed audio
 6. Generate topics, summaries, and word-level timestamps
 7. Convert audio to MP3 and generate waveform visualization
 **Note:** A stub processor (`process_daily_recording`) exists for testing webhook flow without GPU costs, but the production code path uses `process_multitrack_recording` with full ML pipeline.
 ---
 ## Prerequisites
 **1. Environment Variables** (check in `.env.development.local`):
 ```bash
 # Daily.co API Configuration
 DAILY_API_KEY=<key>
 DAILY_SUBDOMAIN=monadical
 DAILY_WEBHOOK_SECRET=<base64-encoded-secret>
 AWS_DAILY_S3_BUCKET=reflector-dailyco-local
 AWS_DAILY_S3_REGION=us-east-1
 AWS_DAILY_ROLE_ARN=arn:aws:iam::950402358378:role/DailyCo
 DAILY_MIGRATION_ENABLED=true
 DAILY_MIGRATION_ROOM_IDS=["552640fd-16f2-4162-9526-8cf40cd2357e"]
 # Transcription/Diarization Backend (Required for real processing)
 DIARIZATION_BACKEND=modal
 DIARIZATION_MODAL_API_KEY=<modal-api-key>
 # TRANSCRIPTION_BACKEND is not explicitly set (uses default/modal)
 ```
 **2. Services Running:**
 ```bash
 docker compose ps  # server, postgres, redis, worker, beat should be UP
 ```
 **IMPORTANT:** Worker and beat services MUST be running for transcription processing:
 ```bash
 docker compose up -d worker beat
 ```
 **3. ngrok Tunnel for Webhooks:**
 ```bash
 # Start ngrok (if not already running)
 ngrok http 1250 --log=stdout > /tmp/ngrok.log 2>&1 &
 # Get public URL
 curl -s http://localhost:4040/api/tunnels | python3 -c "import sys, json; data=json.load(sys.stdin); print(data['tunnels'][0]['public_url'])"
 ```
 **Current ngrok URL:** `https://0503947384a3.ngrok-free.app` (as of last registration)
 **4. Webhook Created:**
 ```bash
 cd server
 uv run python scripts/recreate_daily_webhook.py https://0503947384a3.ngrok-free.app/v1/daily/webhook
 # Verify: "Created webhook <uuid> (state: ACTIVE)"
 ```
 **Current webhook status:** ✅ ACTIVE (webhook ID: dad5ad16-ceca-488e-8fc5-dae8650b51d0)
 ---
 ## Test 1: Database Configuration
 **Check room platform:**
 ```bash
 docker-compose exec -T postgres psql -U reflector -d reflector -c \
  "SELECT id, name, platform, recording_type FROM room WHERE name = 'test2';"
 ```
 **Expected:**
 ```
 id: 552640fd-16f2-4162-9526-8cf40cd2357e
 name: test2
 platform: whereby  # DB value (overridden by env var DAILY_MIGRATION_ROOM_IDS)
 recording_type: cloud
 ```
 **Clear old meetings:**
 ```bash
 docker-compose exec -T postgres psql -U reflector -d reflector -c \
  "UPDATE meeting SET is_active = false WHERE room_id = '552640fd-16f2-4162-9526-8cf40cd2357e';"
 ```
 ---
 ## Test 2: Meeting Creation with Auto-Recording
 **Create meeting:**
 ```bash
 curl -s -X POST http://localhost:1250/v1/rooms/test2/meeting \
  -H "Content-Type: application/json" \
  -d '{"allow_duplicated":false}' | python3 -m json.tool
 ```
 **Expected Response:**
 ```json
 {
  "room_name": "test2-YYYYMMDDHHMMSS",  // Includes "test2" prefix!
  "room_url": "https://monadical.daily.co/test2-...?t=<JWT_TOKEN>",  // Has token!
  "platform": "daily",
  "recording_type": "cloud"  // DB value (Whereby-specific)
 }
 ```
 **Decode token to verify auto-recording:**
 ```bash
 # Extract token from room_url, decode JWT payload
 echo "<token>" | python3 -c "
 import sys, json, base64
 token = sys.stdin.read().strip()
 payload = token.split('.')[1] + '=' * (4 - len(token.split('.')[1]) % 4)
 print(json.dumps(json.loads(base64.b64decode(payload)), indent=2))
 "
 ```
 **Expected token payload:**
 ```json
 {
  "r": "test2-YYYYMMDDHHMMSS",  // Room name
  "sr": true,  // start_recording: true ✅
  "d": "...",  // Domain ID
  "iat": 1234567890
 }
 ```
 ---
 ## Test 3: Daily.co API Verification
 **Check room configuration:**
 ```bash
 ROOM_NAME="<from previous step>"
 curl -s -X GET "https://api.daily.co/v1/rooms/$ROOM_NAME" \
  -H "Authorization: Bearer $DAILY_API_KEY" | python3 -m json.tool
 ```
 **Expected config:**
 ```json
 {
  "config": {
    "enable_recording": "raw-tracks",  // ✅
    "recordings_bucket": {
      "bucket_name": "reflector-dailyco-local",
      "bucket_region": "us-east-1",
      "assume_role_arn": "arn:aws:iam::950402358378:role/DailyCo"
    }
  }
 }
 ```
 ---
 ## Test 4: Browser UI Test (Playwright MCP)
 **Using Claude Code MCP tools:**
 **Load room:**
 ```
 Use: mcp__playwright__browser_navigate
 Input: {"url": "http://localhost:3000/test2"}
 Then wait 12 seconds for iframe to load
 ```
 **Verify Daily.co iframe loaded:**
 ```
 Use: mcp__playwright__browser_snapshot
 Expected in snapshot:
 - iframe element with src containing "monadical.daily.co"
 - Daily.co pre-call UI visible
 ```
 **Take screenshot:**
 ```
 Use: mcp__playwright__browser_take_screenshot
 Input: {"filename": "test2-before-join.png"}
 Expected: Daily.co pre-call UI with "Join" button visible
 ```
 **Join meeting:**
 ```
 Note: Daily.co iframe interaction requires clicking inside iframe.
 Use: mcp__playwright__browser_click
 Input: {"element": "Join button in Daily.co iframe", "ref": "<ref-from-snapshot>"}
 Then wait 5 seconds for call to connect
 ```
 **Verify in-call:**
 ```
 Use: mcp__playwright__browser_take_screenshot
 Input: {"filename": "test2-in-call.png"}
 Expected: "Waiting for others to join" or participant video visible
 ```
 **Leave meeting:**
 ```
 Use: mcp__playwright__browser_click
 Input: {"element": "Leave button in Daily.co iframe", "ref": "<ref-from-snapshot>"}
 ```
 ---
 **Alternative: JavaScript snippets (for manual testing):**
 ```javascript
 await page.goto('http://localhost:3000/test2');
 await new Promise(f => setTimeout(f, 12000));  // Wait for load
 // Verify iframe
 const iframes = document.querySelectorAll('iframe');
 // Expected: 1 iframe with src containing "monadical.daily.co"
 // Screenshot
 await page.screenshot({ path: 'test2-before-join.png' });
 // Join
 await page.locator('iframe').contentFrame().getByRole('button', { name: 'Join' }).click();
 await new Promise(f => setTimeout(f, 5000));
 // In-call screenshot
 await page.screenshot({ path: 'test2-in-call.png' });
 // Leave
 await page.locator('iframe').contentFrame().getByRole('button', { name: 'Leave' }).click();
 ```
 ---
 ## Test 5: Webhook Verification
 **Check server logs for webhooks:**
 ```bash
 docker-compose logs --since 15m server 2>&1 | grep -i "participant joined\|recording started"
 ```
 **Expected logs:**
 ```
 [info] Participant joined | meeting_id=... | num_clients=1 | recording_type=cloud | recording_trigger=automatic-2nd-participant
 [info] Recording started | meeting_id=... | recording_id=... | platform=daily
 ```
 **Check Daily.co webhook delivery logs:**
 ```bash
 curl -s -X GET "https://api.daily.co/v1/logs/webhooks?limit=20" \
  -H "Authorization: Bearer $DAILY_API_KEY" | python3 -c "
 import sys, json
 logs = json.load(sys.stdin)
 for log in logs[:10]:
    req = json.loads(log['request'])
    room = req.get('payload', {}).get('room') or req.get('payload', {}).get('room_name', 'N/A')
    print(f\"{req['type']:30s} | room: {room:30s} | status: {log['status']}\")
 "
 ```
 **Expected output:**
 ```
 participant.joined             | room: test2-YYYYMMDDHHMMSS       | status: 200
 recording.started              | room: test2-YYYYMMDDHHMMSS       | status: 200
 participant.left               | room: test2-YYYYMMDDHHMMSS       | status: 200
 recording.ready-to-download    | room: test2-YYYYMMDDHHMMSS       | status: 200
 ```
 **Check database updated:**
 ```bash
 docker-compose exec -T postgres psql -U reflector -d reflector -c \
  "SELECT room_name, num_clients FROM meeting WHERE room_name LIKE 'test2-%' ORDER BY end_date DESC LIMIT 1;"
 ```
 **Expected:**
 ```
 room_name: test2-YYYYMMDDHHMMSS
 num_clients: 0  // After participant left
 ```
 ---
 ## Test 6: Recording in S3
 **List recent recordings:**
 ```bash
 curl -s -X GET "https://api.daily.co/v1/recordings" \
  -H "Authorization: Bearer $DAILY_API_KEY" | python3 -c "
 import sys, json
 data = json.load(sys.stdin)
 for rec in data.get('data', [])[:5]:
    if 'test2-' in rec.get('room_name', ''):
        print(f\"Room: {rec['room_name']}\")
        print(f\"Status: {rec['status']}\")
        print(f\"Duration: {rec.get('duration', 0)}s\")
        print(f\"S3 key: {rec.get('s3key', 'N/A')}\")
        print(f\"Tracks: {len(rec.get('tracks', []))} files\")
        for track in rec.get('tracks', []):
            print(f\"  - {track['type']}: {track['s3Key'].split('/')[-1]} ({track['size']} bytes)\")
        print()
 "
 ```
 **Expected output:**
 ```
 Room: test2-20251009192341
 Status: finished
 Duration: ~30-120s
 S3 key: monadical/test2-20251009192341/1760037914930
 Tracks: 2 files
  - audio: 1760037914930-<uuid>-cam-audio-1760037915265 (~400 KB)
  - video: 1760037914930-<uuid>-cam-video-1760037915269 (~10-30 MB)
 ```
 **Verify S3 path structure:**
 - `monadical/` - Daily.co subdomain
 - `test2-20251009192341/` - Reflector room name + timestamp
 - `<timestamp>-<participant-uuid>-<media-type>-<track-start>.webm` - Individual track files
 ---
 ## Test 7: Database Check - Recording and Transcript
 **Check recording created:**
 ```bash
 docker-compose exec -T postgres psql -U reflector -d reflector -c \
  "SELECT id, bucket_name, object_key, status, meeting_id, recorded_at
   FROM recording
   ORDER BY recorded_at DESC LIMIT 1;"
 ```
 **Expected:**
 ```
 id: <recording-id-from-webhook>
 bucket_name: reflector-dailyco-local
 object_key: monadical/test2-<timestamp>/<recording-timestamp>-<uuid>-cam-audio-<track-start>.webm
 status: completed
 meeting_id: <meeting-id>
 recorded_at: <recent-timestamp>
 ```
 **Check transcript created:**
 ```bash
 docker compose exec -T postgres psql -U reflector -d reflector -c \
  "SELECT id, title, status, duration, recording_id, meeting_id, room_id
   FROM transcript
   ORDER BY created_at DESC LIMIT 1;"
 ```
 **Expected (REAL transcription):**
 ```
 id: <transcript-id>
 title: <AI-generated title based on actual conversation content>
 status: uploaded  (audio file processed and available)
 duration: <actual meeting duration in seconds>
 recording_id: <same-as-recording-id-above>
 meeting_id: <meeting-id>
 room_id: 552640fd-16f2-4162-9526-8cf40cd2357e
 ```
 **Note:** Title and content will reflect the ACTUAL conversation, not mock data. Processing time depends on recording length and GPU backend availability (Modal).
 **Verify audio file exists:**
 ```bash
 ls -lh data/<transcript-id>/upload.webm
 ```
 **Expected:**
 ```
 -rw-r--r-- 1 user staff ~100-200K Oct 10 18:48 upload.webm
 ```
 **Check transcript topics (REAL transcription):**
 ```bash
 TRANSCRIPT_ID=$(docker compose exec -T postgres psql -U reflector -d reflector -t -c \
  "SELECT id FROM transcript ORDER BY created_at DESC LIMIT 1;")
 docker compose exec -T postgres psql -U reflector -d reflector -c \
  "SELECT
     jsonb_array_length(topics) as num_topics,
     jsonb_array_length(participants) as num_participants,
     short_summary,
     title
   FROM transcript
   WHERE id = '$TRANSCRIPT_ID';"
 ```
 **Expected (REAL data):**
 ```
 num_topics: <varies based on conversation>
 num_participants: <actual number of participants who spoke>
 short_summary: <AI-generated summary of actual conversation>
 title: <AI-generated title based on content>
 ```
 **Check topics contain actual transcription:**
 ```bash
 docker compose exec -T postgres psql -U reflector -d reflector -c \
  "SELECT topics->0->'title', topics->0->'summary', topics->0->'transcript'
   FROM transcript
   ORDER BY created_at DESC LIMIT 1;" | head -20
 ```
 **Expected output:** Will contain the ACTUAL transcribed conversation from the Daily.co meeting, not mock data.
 **Check participants:**
 ```bash
 docker compose exec -T postgres psql -U reflector -d reflector -c \
  "SELECT participants FROM transcript ORDER BY created_at DESC LIMIT 1;" \
  | python3 -c "import sys, json; data=json.loads(sys.stdin.read()); print(json.dumps(data, indent=2))"
 ```
 **Expected (REAL diarization):**
 ```json
 [
  {
    "id": "<uuid>",
    "speaker": 0,
    "name": "Speaker 1"
  },
  {
    "id": "<uuid>",
    "speaker": 1,
    "name": "Speaker 2"
  }
 ]
 ```
 **Note:** Speaker names will be generic ("Speaker 1", "Speaker 2", etc.) as determined by the diarization backend. Number of participants depends on how many actually spoke during the meeting.
 **Check word-level data:**
 ```bash
 docker compose exec -T postgres psql -U reflector -d reflector -c \
  "SELECT jsonb_array_length(topics->0->'words') as num_words_first_topic
   FROM transcript
   ORDER BY created_at DESC LIMIT 1;"
 ```
 **Expected:**
 ```
 num_words_first_topic: <varies based on actual conversation length and topic chunking>
 ```
 **Verify speaker diarization in words:**
 ```bash
 docker compose exec -T postgres psql -U reflector -d reflector -c \
  "SELECT
     topics->0->'words'->0->>'text' as first_word,
     topics->0->'words'->0->>'speaker' as speaker,
     topics->0->'words'->0->>'start' as start_time,
     topics->0->'words'->0->>'end' as end_time
   FROM transcript
   ORDER BY created_at DESC LIMIT 1;"
 ```
 **Expected (REAL transcription):**
 ```
 first_word: <actual first word from transcription>
 speaker: 0, 1, 2, ... (actual speaker ID from diarization)
 start_time: <actual timestamp in seconds>
 end_time: <actual end timestamp>
 ```
 **Note:** All timestamps and speaker IDs are from real transcription/diarization, synchronized across tracks.
 ---
 ## Test 8: Recording Type Verification
 **Check what Daily.co received:**
 ```bash
 curl -s -X GET "https://api.daily.co/v1/rooms/test2-<timestamp>" \
  -H "Authorization: Bearer $DAILY_API_KEY" | python3 -m json.tool | grep "enable_recording"
 ```
 **Expected:**
 ```json
 "enable_recording": "raw-tracks"
 ```
 **NOT:** `"enable_recording": "cloud"` (that would be wrong - we want raw tracks)
 ---
 ## Troubleshooting
 ### Issue: No webhooks received
 **Check webhook state:**
 ```bash
 curl -s -X GET "https://api.daily.co/v1/webhooks" \
  -H "Authorization: Bearer $DAILY_API_KEY" | python3 -m json.tool
 ```
 **If state is FAILED:**
 ```bash
 cd server
 uv run python scripts/recreate_daily_webhook.py https://<ngrok-url>/v1/daily/webhook
 ```
 ### Issue: Webhooks return 422
 **Check server logs:**
 ```bash
 docker-compose logs --tail=50 server | grep "Failed to parse webhook event"
 ```
 **Common cause:** Event structure mismatch. Daily.co events use:
 ```json
 {
  "version": "1.0.0",
  "type": "participant.joined",
  "payload": {...},  // NOT "data"
  "event_ts": 123.456  // NOT "ts"
 }
 ```
 ### Issue: Recording not starting
 1. **Check token has `sr: true`:**
   - Decode JWT token from room_url query param
   - Should contain `"sr": true`
 2. **Check Daily.co room config:**
   - `enable_recording` must be set (not false)
   - For raw-tracks: must be exactly `"raw-tracks"`
 3. **Check participant actually joined:**
   - Logs should show "Participant joined"
   - Must click "Join" button, not just pre-call screen
 ### Issue: Recording in S3 but wrong format
 **Daily.co recording types:**
 - `"cloud"` → Single MP4 file (`download_link` in webhook)
 - `"raw-tracks"` → Multiple WebM files (`tracks` array in webhook)
 - `"raw-tracks-audio-only"` → Only audio WebM files
 **Current implementation:** Always uses `"raw-tracks"` (better for transcription)
 ---
 ## Quick Validation Commands
 **One-liner to verify everything:**
 ```bash
 # 1. Check room exists
 docker-compose exec -T postgres psql -U reflector -d reflector -c \
  "SELECT name, platform FROM room WHERE name = 'test2';" && \
 # 2. Create meeting
 MEETING=$(curl -s -X POST http://localhost:1250/v1/rooms/test2/meeting \
  -H "Content-Type: application/json" -d '{"allow_duplicated":false}') && \
 echo "$MEETING" | python3 -c "import sys,json; m=json.load(sys.stdin); print(f'Room: {m[\"room_name\"]}\nURL: {m[\"room_url\"][:80]}...')" && \
 # 3. Check Daily.co config
 ROOM_NAME=$(echo "$MEETING" | python3 -c "import sys,json; print(json.load(sys.stdin)['room_name'])") && \
 curl -s -X GET "https://api.daily.co/v1/rooms/$ROOM_NAME" \
  -H "Authorization: Bearer $DAILY_API_KEY" | python3 -c "import sys,json; print(f'Recording: {json.load(sys.stdin)[\"config\"][\"enable_recording\"]}')"
 ```
 **Expected output:**
 ```
 name: test2, platform: whereby
 Room: test2-20251009192341
 URL: https://monadical.daily.co/test2-20251009192341?t=eyJhbGc...
 Recording: raw-tracks
 ```
 ---
 ## Success Criteria Checklist
 - [x] Room name includes Reflector room prefix (`test2-...`)
 - [x] Meeting URL contains JWT token (`?t=...`)
 - [x] Token has `sr: true` (auto-recording enabled)
 - [x] Daily.co room config: `enable_recording: "raw-tracks"`
 - [x] Browser loads Daily.co interface (not Whereby)
 - [x] Recording auto-starts when participant joins
 - [x] Webhooks received: participant.joined, recording.started, participant.left, recording.ready-to-download
 - [x] Recording status: `finished`
 - [x] S3 contains 2 files: audio (.webm) and video (.webm)
 - [x] S3 path: `monadical/test2-{timestamp}/{recording-start-ts}-{participant-uuid}-cam-{audio|video}-{track-start-ts}`
 - [x] Database `num_clients` increments/decrements correctly
 - [x] **Database recording entry created** with correct S3 path and status `completed`
 - [ ] **Database transcript entry created** with status `uploaded`
 - [ ] **Audio file downloaded** to `data/{transcript_id}/upload.webm`
 - [ ] **Transcript has REAL data**: AI-generated title based on conversation
 - [ ] **Transcript has topics** generated from actual content
 - [ ] **Transcript has participants** with proper speaker diarization
 - [ ] **Topics contain word-level data** with accurate timestamps and speaker IDs
 - [ ] **Total duration** matches actual meeting length
 - [ ] **MP3 and waveform files generated** by file processing pipeline
 - [ ] **Frontend transcript page loads** without "Failed to load audio" error
 - [ ] **Audio player functional** with working playback and waveform visualization
 - [ ] **Multitrack processing completed** without errors in worker logs
 - [ ] **Modal GPU backends accessible** (transcription and diarization)
--- a/server/Dockerfile
+++ b/server/Dockerfile
@@ -6,7 +6,7 @@ ENV PYTHONUNBUFFERED=1 \
 # builder install base dependencies
 WORKDIR /tmp
-RUN apt-get update && apt-get install -y curl ffmpeg && apt-get clean
+RUN apt-get update && apt-get install -y curl && apt-get clean
 ADD https://astral.sh/uv/install.sh /uv-installer.sh
 RUN sh /uv-installer.sh && rm /uv-installer.sh
 ENV PATH="/root/.local/bin/:$PATH"
--- a/server/docs/data_retention.md
+++ b/server/docs/data_retention.md
@@ -1,95 +0,0 @@
 # Data Retention and Cleanup
 ## Overview
 For public instances of Reflector, a data retention policy is automatically enforced to delete anonymous user data after a configurable period (default: 7 days). This ensures compliance with privacy expectations and prevents unbounded storage growth.
 ## Configuration
 ### Environment Variables
 - `PUBLIC_MODE` (bool): Must be set to `true` to enable automatic cleanup
 - `PUBLIC_DATA_RETENTION_DAYS` (int): Number of days to retain anonymous data (default: 7)
 ### What Gets Deleted
 When data reaches the retention period, the following items are automatically removed:
 1. **Transcripts** from anonymous users (where `user_id` is NULL):
   - Database records
   - Local files (audio.wav, audio.mp3, audio.json waveform)
   - Storage files (cloud storage if configured)
 ## Automatic Cleanup
 ### Celery Beat Schedule
 When `PUBLIC_MODE=true`, a Celery beat task runs daily at 3 AM to clean up old data:
 ```python
 # Automatically scheduled when PUBLIC_MODE=true
 "cleanup_old_public_data": {
    "task": "reflector.worker.cleanup.cleanup_old_public_data",
    "schedule": crontab(hour=3, minute=0),  # Daily at 3 AM
 }
 ```
 ### Running the Worker
 Ensure both Celery worker and beat scheduler are running:
 ```bash
 # Start Celery worker
 uv run celery -A reflector.worker.app worker --loglevel=info
 # Start Celery beat scheduler (in another terminal)
 uv run celery -A reflector.worker.app beat
 ```
 ## Manual Cleanup
 For testing or manual intervention, use the cleanup tool:
 ```bash
 # Delete data older than 7 days (default)
 uv run python -m reflector.tools.cleanup_old_data
 # Delete data older than 30 days
 uv run python -m reflector.tools.cleanup_old_data --days 30
 ```
 Note: The manual tool uses the same implementation as the Celery worker task to ensure consistency.
 ## Important Notes
 1. **User Data Deletion**: Only anonymous data (where `user_id` is NULL) is deleted. Authenticated user data is preserved.
 2. **Storage Cleanup**: The system properly cleans up both local files and cloud storage when configured.
 3. **Error Handling**: If individual deletions fail, the cleanup continues and logs errors. Failed deletions are reported in the task output.
 4. **Public Instance Only**: The automatic cleanup task only runs when `PUBLIC_MODE=true` to prevent accidental data loss in private deployments.
 ## Testing
 Run the cleanup tests:
 ```bash
 uv run pytest tests/test_cleanup.py -v
 ```
 ## Monitoring
 Check Celery logs for cleanup task execution:
 ```bash
 # Look for cleanup task logs
 grep "cleanup_old_public_data" celery.log
 grep "Starting cleanup of old public data" celery.log
 ```
 Task statistics are logged after each run:
 - Number of transcripts deleted
 - Number of meetings deleted
 - Number of orphaned recordings deleted
 - Any errors encountered
--- a/server/docs/gpu/api-transcription.md
+++ b/server/docs/gpu/api-transcription.md
@@ -1,194 +0,0 @@
 ## Reflector GPU Transcription API (Specification)
 This document defines the Reflector GPU transcription API that all implementations must adhere to. Current implementations include NVIDIA Parakeet (NeMo) and Whisper (faster-whisper), both deployed on Modal.com. The API surface and response shapes are OpenAI/Whisper-compatible, so clients can switch implementations by changing only the base URL.
 ### Base URL and Authentication
 - Example base URLs (Modal web endpoints):
  - Parakeet: `https://<account>--reflector-transcriber-parakeet-web.modal.run`
  - Whisper: `https://<account>--reflector-transcriber-web.modal.run`
 - All endpoints are served under `/v1` and require a Bearer token:
 ```
 Authorization: Bearer <REFLECTOR_GPU_APIKEY>
 ```
 Note: To switch implementations, deploy the desired variant and point `TRANSCRIPT_URL` to its base URL. The API is identical.
 ### Supported file types
 `mp3, mp4, mpeg, mpga, m4a, wav, webm`
 ### Models and languages
 - Parakeet (NVIDIA NeMo): default `nvidia/parakeet-tdt-0.6b-v2`
  - Language support: only `en`. Other languages return HTTP 400.
 - Whisper (faster-whisper): default `large-v2` (or deployment-specific)
  - Language support: multilingual (per Whisper model capabilities).
 Note: The `model` parameter is accepted by all implementations for interface parity. Some backends may treat it as informational.
 ### Endpoints
 #### POST /v1/audio/transcriptions
 Transcribe one or more uploaded audio files.
 Request: multipart/form-data
 - `file` (File) — optional. Single file to transcribe.
 - `files` (File[]) — optional. One or more files to transcribe.
 - `model` (string) — optional. Defaults to the implementation-specific model (see above).
 - `language` (string) — optional, defaults to `en`.
  - Parakeet: only `en` is accepted; other values return HTTP 400
  - Whisper: model-dependent; typically multilingual
 - `batch` (boolean) — optional, defaults to `false`.
 Notes:
 - Provide either `file` or `files`, not both. If neither is provided, HTTP 400.
 - `batch` requires `files`; using `batch=true` without `files` returns HTTP 400.
 - Response shape for multiple files is the same regardless of `batch`.
 - Files sent to this endpoint are processed in a single pass (no VAD/chunking). This is intended for short clips (roughly ≤ 30s; depends on GPU memory/model). For longer audio, prefer `/v1/audio/transcriptions-from-url` which supports VAD-based chunking.
 Responses
 Single file 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"
 }
 ```
 Multiple files response:
 ```json
 {
  "results": [
    {"filename": "a1.mp3", "text": "...", "words": [...]},
    {"filename": "a2.mp3", "text": "...", "words": [...]}]
 }
 ```
 Notes:
 - Word objects always include keys: `word`, `start`, `end`.
 - Some implementations may include a trailing space in `word` to match Whisper tokenization behavior; clients should trim if needed.
 Example curl (single file):
 ```bash
 curl -X POST \
  -H "Authorization: Bearer $REFLECTOR_GPU_APIKEY" \
  -F "file=@/path/to/audio.mp3" \
  -F "language=en" \
  "$BASE_URL/v1/audio/transcriptions"
 ```
 Example curl (multiple files, batch):
 ```bash
 curl -X POST \
  -H "Authorization: Bearer $REFLECTOR_GPU_APIKEY" \
  -F "files=@/path/a1.mp3" -F "files=@/path/a2.mp3" \
  -F "batch=true" -F "language=en" \
  "$BASE_URL/v1/audio/transcriptions"
 ```
 #### POST /v1/audio/transcriptions-from-url
 Transcribe a single remote audio file by URL.
 Request: application/json
 Body parameters:
 - `audio_file_url` (string) — required. URL of the audio file to transcribe.
 - `model` (string) — optional. Defaults to the implementation-specific model (see above).
 - `language` (string) — optional, defaults to `en`. Parakeet only accepts `en`.
 - `timestamp_offset` (number) — optional, defaults to `0.0`. Added to each word's `start`/`end` in the response.
 ```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",
  "words": [
    { "word": "hello", "start": 10.0, "end": 10.5 },
    { "word": "world", "start": 10.5, "end": 11.0 }
  ]
 }
 ```
 Notes:
 - `timestamp_offset` is added to each word’s `start`/`end` in the response.
 - Implementations may perform VAD-based chunking and batching for long-form audio; word timings are adjusted accordingly.
 Example curl:
 ```bash
 curl -X POST \
  -H "Authorization: Bearer $REFLECTOR_GPU_APIKEY" \
  -H "Content-Type: application/json" \
  -d '{
        "audio_file_url": "https://example.com/audio.mp3",
        "language": "en",
        "timestamp_offset": 0
      }' \
  "$BASE_URL/v1/audio/transcriptions-from-url"
 ```
 ### Error handling
 - 400 Bad Request
  - Parakeet: `language` other than `en`
  - Missing required parameters (`file`/`files` for upload; `audio_file_url` for URL endpoint)
  - Unsupported file extension
 - 401 Unauthorized
  - Missing or invalid Bearer token
 - 404 Not Found
  - `audio_file_url` does not exist
 ### Implementation details
 - GPUs: A10G for small-file/live, L40S for large-file URL transcription (subject to deployment)
 - VAD chunking and segment batching; word timings adjusted and overlapping ends constrained
 - Pads very short segments (< 0.5s) to avoid model crashes on some backends
 ### Server configuration (Reflector API)
 Set the Reflector server to use the Modal backend and point `TRANSCRIPT_URL` to your chosen deployment:
 ```
 TRANSCRIPT_BACKEND=modal
 TRANSCRIPT_URL=https://<account>--reflector-transcriber-parakeet-web.modal.run
 TRANSCRIPT_MODAL_API_KEY=<REFLECTOR_GPU_APIKEY>
 ```
 ### Conformance tests
 Use the pytest-based conformance tests to validate any new implementation (including self-hosted) against this spec:
 ```
 TRANSCRIPT_URL=https://<your-deployment-base> \
 TRANSCRIPT_MODAL_API_KEY=your-api-key \
 uv run -m pytest -m model_api --no-cov server/tests/test_model_api_transcript.py
 ```
--- a/server/docs/webhook.md
+++ b/server/docs/webhook.md
@@ -1,233 +0,0 @@
 # Reflector Webhook Documentation
 ## Overview
 Reflector supports webhook notifications to notify external systems when transcript processing is completed. Webhooks can be configured per room and are triggered automatically after a transcript is successfully processed.
 ## Configuration
 Webhooks are configured at the room level with two fields:
 - `webhook_url`: The HTTPS endpoint to receive webhook notifications
 - `webhook_secret`: Optional secret key for HMAC signature verification (auto-generated if not provided)
 ## Events
 ### `transcript.completed`
 Triggered when a transcript has been fully processed, including transcription, diarization, summarization, topic detection and calendar event integration.
 ### `test`
 A test event that can be triggered manually to verify webhook configuration.
 ## Webhook Request Format
 ### Headers
 All webhook requests include the following headers:
 | Header | Description | Example |
 |--------|-------------|---------|
 | `Content-Type` | Always `application/json` | `application/json` |
 | `User-Agent` | Identifies Reflector as the source | `Reflector-Webhook/1.0` |
 | `X-Webhook-Event` | The event type | `transcript.completed` or `test` |
 | `X-Webhook-Retry` | Current retry attempt number | `0`, `1`, `2`... |
 | `X-Webhook-Signature` | HMAC signature (if secret configured) | `t=1735306800,v1=abc123...` |
 ### Signature Verification
 If a webhook secret is configured, Reflector includes an HMAC-SHA256 signature in the `X-Webhook-Signature` header to verify the webhook authenticity.
 The signature format is: `t={timestamp},v1={signature}`
 To verify the signature:
 1. Extract the timestamp and signature from the header
 2. Create the signed payload: `{timestamp}.{request_body}`
 3. Compute HMAC-SHA256 of the signed payload using your webhook secret
 4. Compare the computed signature with the received signature
 Example verification (Python):
 ```python
 import hmac
 import hashlib
 def verify_webhook_signature(payload: bytes, signature_header: str, secret: str) -> bool:
    # Parse header: "t=1735306800,v1=abc123..."
    parts = dict(part.split("=") for part in signature_header.split(","))
    timestamp = parts["t"]
    received_signature = parts["v1"]
    # Create signed payload
    signed_payload = f"{timestamp}.{payload.decode('utf-8')}"
    # Compute expected signature
    expected_signature = hmac.new(
        secret.encode("utf-8"),
        signed_payload.encode("utf-8"),
        hashlib.sha256
    ).hexdigest()
    # Compare signatures
    return hmac.compare_digest(expected_signature, received_signature)
 ```
 ## Event Payloads
 ### `transcript.completed` Event
 This event includes a convenient URL for accessing the transcript:
 - `frontend_url`: Direct link to view the transcript in the web interface
 ```json
 {
  "event": "transcript.completed",
  "event_id": "transcript.completed-abc-123-def-456",
  "timestamp": "2025-08-27T12:34:56.789012Z",
  "transcript": {
    "id": "abc-123-def-456",
    "room_id": "room-789",
    "created_at": "2025-08-27T12:00:00Z",
    "duration": 1800.5,
    "title": "Q3 Product Planning Meeting",
    "short_summary": "Team discussed Q3 product roadmap, prioritizing mobile app features and API improvements.",
    "long_summary": "The product team met to finalize the Q3 roadmap. Key decisions included...",
    "webvtt": "WEBVTT\n\n00:00:00.000 --> 00:00:05.000\n<v Speaker 1>Welcome everyone to today's meeting...",
    "topics": [
      {
        "title": "Introduction and Agenda",
        "summary": "Meeting kickoff with agenda review",
        "timestamp": 0.0,
        "duration": 120.0,
        "webvtt": "WEBVTT\n\n00:00:00.000 --> 00:00:05.000\n<v Speaker 1>Welcome everyone..."
      },
      {
        "title": "Mobile App Features Discussion",
        "summary": "Team reviewed proposed mobile app features for Q3",
        "timestamp": 120.0,
        "duration": 600.0,
        "webvtt": "WEBVTT\n\n00:02:00.000 --> 00:02:10.000\n<v Speaker 2>Let's talk about the mobile app..."
      }
    ],
    "participants": [
      {
        "id": "participant-1",
        "name": "John Doe",
        "speaker": "Speaker 1"
      },
      {
        "id": "participant-2",
        "name": "Jane Smith",
        "speaker": "Speaker 2"
      }
    ],
    "source_language": "en",
    "target_language": "en",
    "status": "completed",
    "frontend_url": "https://app.reflector.com/transcripts/abc-123-def-456"
  },
  "room": {
    "id": "room-789",
    "name": "Product Team Room"
  },
  "calendar_event": {
    "id": "calendar-event-123",
    "ics_uid": "event-123",
    "title": "Q3 Product Planning Meeting",
    "start_time": "2025-08-27T12:00:00Z",
    "end_time": "2025-08-27T12:30:00Z",
    "description": "Team discussed Q3 product roadmap, prioritizing mobile app features and API improvements.",
    "location": "Conference Room 1",
    "attendees": [
      {
        "id": "participant-1",
        "name": "John Doe",
        "speaker": "Speaker 1"
      },
      {
        "id": "participant-2",
        "name": "Jane Smith",
        "speaker": "Speaker 2"
      }
    ]
  }
 }
 ```
 ### `test` Event
 ```json
 {
  "event": "test",
  "event_id": "test.2025-08-27T12:34:56.789012Z",
  "timestamp": "2025-08-27T12:34:56.789012Z",
  "message": "This is a test webhook from Reflector",
  "room": {
    "id": "room-789",
    "name": "Product Team Room"
  }
 }
 ```
 ## Retry Policy
 Webhooks are delivered with automatic retry logic to handle transient failures. When a webhook delivery fails due to server errors or network issues, Reflector will automatically retry the delivery multiple times over an extended period.
 ### Retry Mechanism
 Reflector implements an exponential backoff strategy for webhook retries:
 - **Initial retry delay**: 60 seconds after the first failure
 - **Exponential backoff**: Each subsequent retry waits approximately twice as long as the previous one
 - **Maximum retry interval**: 1 hour (backoff is capped at this duration)
 - **Maximum retry attempts**: 30 attempts total
 - **Total retry duration**: Retries continue for approximately 24 hours
 ### How Retries Work
 When a webhook fails, Reflector will:
 1. Wait 60 seconds, then retry (attempt #1)
 2. If it fails again, wait ~2 minutes, then retry (attempt #2)
 3. Continue doubling the wait time up to a maximum of 1 hour between attempts
 4. Keep retrying at 1-hour intervals until successful or 30 attempts are exhausted
 The `X-Webhook-Retry` header indicates the current retry attempt number (0 for the initial attempt, 1 for first retry, etc.), allowing your endpoint to track retry attempts.
 ### Retry Behavior by HTTP Status Code
 | Status Code | Behavior |
 |-------------|----------|
 | 2xx (Success) | No retry, webhook marked as delivered |
 | 4xx (Client Error) | No retry, request is considered permanently failed |
 | 5xx (Server Error) | Automatic retry with exponential backoff |
 | Network/Timeout Error | Automatic retry with exponential backoff |
 **Important Notes:**
 - Webhooks timeout after 30 seconds. If your endpoint takes longer to respond, it will be considered a timeout error and retried.
 - During the retry period (~24 hours), you may receive the same webhook multiple times if your endpoint experiences intermittent failures.
 - There is no mechanism to manually retry failed webhooks after the retry period expires.
 ## Testing Webhooks
 You can test your webhook configuration before processing transcripts:
 ```http
 POST /v1/rooms/{room_id}/webhook/test
 ```
 Response:
 ```json
 {
  "success": true,
  "status_code": 200,
  "message": "Webhook test successful",
  "response_preview": "OK"
 }
 ```
 Or in case of failure:
 ```json
 {
  "success": false,
  "error": "Webhook request timed out (10 seconds)"
 }
 ```
--- a/server/env.example
+++ b/server/env.example
@@ -27,7 +27,7 @@ AUTH_JWT_AUDIENCE=
 #TRANSCRIPT_MODAL_API_KEY=xxxxx
 TRANSCRIPT_BACKEND=modal
-TRANSCRIPT_URL=https://monadical-sas--reflector-transcriber-parakeet-web.modal.run
+TRANSCRIPT_URL=https://monadical-sas--reflector-transcriber-web.modal.run
 TRANSCRIPT_MODAL_API_KEY=
 ## =======================================================
@@ -71,27 +71,3 @@ DIARIZATION_URL=https://monadical-sas--reflector-diarizer-web.modal.run
 ## Sentry DSN configuration
 #SENTRY_DSN=
 ## =======================================================
 ## Video Platform Configuration
 ## =======================================================
 ## Whereby
 #WHEREBY_API_KEY=your-whereby-api-key
 #WHEREBY_WEBHOOK_SECRET=your-whereby-webhook-secret
 #AWS_WHEREBY_ACCESS_KEY_ID=your-aws-key
 #AWS_WHEREBY_ACCESS_KEY_SECRET=your-aws-secret
 #AWS_PROCESS_RECORDING_QUEUE_URL=https://sqs.us-west-2.amazonaws.com/...
 ## Daily.co
 #DAILY_API_KEY=your-daily-api-key
 #DAILY_WEBHOOK_SECRET=your-daily-webhook-secret
 #DAILY_SUBDOMAIN=your-subdomain
 #AWS_DAILY_S3_BUCKET=your-daily-bucket
 #AWS_DAILY_S3_REGION=us-west-2
 #AWS_DAILY_ROLE_ARN=arn:aws:iam::ACCOUNT:role/DailyRecording
 ## Platform Selection
 #DAILY_MIGRATION_ENABLED=false           # Enable Daily.co support
 #DAILY_MIGRATION_ROOM_IDS=[]            # Specific rooms to use Daily
 #DEFAULT_VIDEO_PLATFORM=whereby          # Default platform for new rooms
--- a/server/gpu/modal_deployments/README.md
+++ b/server/gpu/modal_deployments/README.md
--- a/server/gpu/modal_deployments/reflector_diarizer.py
+++ b/server/gpu/modal_deployments/reflector_diarizer.py
--- a/server/gpu/modal_deployments/reflector_transcriber.py
+++ b/server/gpu/modal_deployments/reflector_transcriber.py
@@ -0,0 +1,161 @@
 import os
 import tempfile
 import threading
 import modal
 from pydantic import BaseModel
 MODELS_DIR = "/models"
 MODEL_NAME = "large-v2"
 MODEL_COMPUTE_TYPE: str = "float16"
 MODEL_NUM_WORKERS: int = 1
 MINUTES = 60  # seconds
 volume = modal.Volume.from_name("models", create_if_missing=True)
 app = modal.App("reflector-transcriber")
 def download_model():
    from faster_whisper import download_model
    volume.reload()
    download_model(MODEL_NAME, cache_dir=MODELS_DIR)
    volume.commit()
 image = (
    modal.Image.debian_slim(python_version="3.12")
    .pip_install(
        "huggingface_hub==0.27.1",
        "hf-transfer==0.1.9",
        "torch==2.5.1",
        "faster-whisper==1.1.1",
    )
    .env(
        {
            "HF_HUB_ENABLE_HF_TRANSFER": "1",
            "LD_LIBRARY_PATH": (
                "/usr/local/lib/python3.12/site-packages/nvidia/cudnn/lib/:"
                "/opt/conda/lib/python3.12/site-packages/nvidia/cublas/lib/"
            ),
        }
    )
    .run_function(download_model, volumes={MODELS_DIR: volume})
 )
@app.cls(
    gpu="A10G",
    timeout=5 * MINUTES,
    scaledown_window=5 * MINUTES,
    allow_concurrent_inputs=6,
    image=image,
    volumes={MODELS_DIR: volume},
 )
 class Transcriber:
    @modal.enter()
    def enter(self):
        import faster_whisper
        import torch
        self.lock = threading.Lock()
        self.use_gpu = torch.cuda.is_available()
        self.device = "cuda" if self.use_gpu else "cpu"
        self.model = faster_whisper.WhisperModel(
            MODEL_NAME,
            device=self.device,
            compute_type=MODEL_COMPUTE_TYPE,
            num_workers=MODEL_NUM_WORKERS,
            download_root=MODELS_DIR,
            local_files_only=True,
        )
    @modal.method()
    def transcribe_segment(
        self,
        audio_data: str,
        audio_suffix: str,
        language: str,
    ):
        with tempfile.NamedTemporaryFile("wb+", suffix=f".{audio_suffix}") as fp:
            fp.write(audio_data)
            with self.lock:
                segments, _ = self.model.transcribe(
                    fp.name,
                    language=language,
                    beam_size=5,
                    word_timestamps=True,
                    vad_filter=True,
                    vad_parameters={"min_silence_duration_ms": 500},
                )
            segments = list(segments)
            text = "".join(segment.text for segment in segments)
            words = [
                {"word": word.word, "start": word.start, "end": word.end}
                for segment in segments
                for word in segment.words
            ]
            return {"text": text, "words": words}
@app.function(
    scaledown_window=60,
    timeout=60,
    allow_concurrent_inputs=40,
    secrets=[
        modal.Secret.from_name("reflector-gpu"),
    ],
    volumes={MODELS_DIR: volume},
 )
@modal.asgi_app()
 def web():
    from fastapi import Body, Depends, FastAPI, HTTPException, UploadFile, status
    from fastapi.security import OAuth2PasswordBearer
    from typing_extensions import Annotated
    transcriber = Transcriber()
    app = FastAPI()
    oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
    supported_file_types = ["mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm"]
    def apikey_auth(apikey: str = Depends(oauth2_scheme)):
        if apikey != os.environ["REFLECTOR_GPU_APIKEY"]:
            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,
        model: str = "whisper-1",
        language: Annotated[str, Body(...)] = "en",
    ) -> TranscriptResponse:
        audio_data = file.file.read()
        audio_suffix = file.filename.split(".")[-1]
        assert audio_suffix in supported_file_types
        func = transcriber.transcribe_segment.spawn(
            audio_data=audio_data,
            audio_suffix=audio_suffix,
            language=language,
        )
        result = func.get()
        return result
    return app
--- a/server/gpu/modal_deployments/reflector_transcriber_parakeet.py
+++ b/server/gpu/modal_deployments/reflector_transcriber_parakeet.py
@@ -3,7 +3,7 @@ import os
 import sys
 import threading
 import uuid
-from typing import Generator, Mapping, NamedTuple, NewType, TypedDict
+from typing import Mapping, NewType
 from urllib.parse import urlparse
 import modal
@@ -14,7 +14,10 @@ SAMPLERATE = 16000
 UPLOADS_PATH = "/uploads"
 CACHE_PATH = "/cache"
 VAD_CONFIG = {
-    "batch_max_duration": 30.0,
+    "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,
 }
@@ -22,37 +25,6 @@ VAD_CONFIG = {
 ParakeetUniqFilename = NewType("ParakeetUniqFilename", str)
 AudioFileExtension = NewType("AudioFileExtension", str)
 class TimeSegment(NamedTuple):
    """Represents a time segment with start and end times."""
    start: float
    end: float
 class AudioSegment(NamedTuple):
    """Represents an audio segment with timing and audio data."""
    start: float
    end: float
    audio: any
 class TranscriptResult(NamedTuple):
    """Represents a transcription result with text and word timings."""
    text: str
    words: list["WordTiming"]
 class WordTiming(TypedDict):
    """Represents a word with its timing information."""
    word: str
    start: float
    end: float
 app = modal.App("reflector-transcriber-parakeet")
 # Volume for caching model weights
@@ -77,7 +49,7 @@ image = (
    .pip_install(
        "hf_transfer==0.1.9",
        "huggingface_hub[hf-xet]==0.31.2",
-        "nemo_toolkit[asr]==2.5.0",
+        "nemo_toolkit[asr]==2.3.0",
        "cuda-python==12.8.0",
        "fastapi==0.115.12",
        "numpy<2",
@@ -198,14 +170,12 @@ class TranscriberParakeetLive:
                (output,) = self.model.transcribe([padded_audio], timestamps=True)
        text = output.text.strip()
-        words: list[WordTiming] = [
+        words = [
-            WordTiming(
+            {
-                # XXX the space added here is to match the output of whisper
+                "word": word_info["word"],
-                # whisper add space to each words, while parakeet don't
+                "start": round(word_info["start"], 2),
-                word=word_info["word"] + " ",
+                "end": round(word_info["end"], 2),
-                start=round(word_info["start"], 2),
+            }
                end=round(word_info["end"], 2),
            )
            for word_info in output.timestamp["word"]
        ]
@@ -241,12 +211,12 @@ class TranscriberParakeetLive:
        for i, (filename, output) in enumerate(zip(filenames, outputs)):
            text = output.text.strip()
-            words: list[WordTiming] = [
+            words = [
-                WordTiming(
+                {
-                    word=word_info["word"] + " ",
+                    "word": word_info["word"],
-                    start=round(word_info["start"], 2),
+                    "start": round(word_info["start"], 2),
-                    end=round(word_info["end"], 2),
+                    "end": round(word_info["end"], 2),
-                )
+                }
                for word_info in output.timestamp["word"]
            ]
@@ -301,9 +271,7 @@ class TranscriberParakeetFile:
            audio_array, sample_rate = librosa.load(file_path, sr=SAMPLERATE, mono=True)
            return audio_array
-        def vad_segment_generator(
+        def vad_segment_generator(audio_array):
            audio_array,
        ) -> Generator[TimeSegment, None, None]:
            """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"]
@@ -329,121 +297,107 @@ class TranscriberParakeetFile:
                    start_time = start / float(SAMPLERATE)
                    end_time = end / float(SAMPLERATE)
-                    yield TimeSegment(start_time, end_time)
+                    # 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 batch_speech_segments(
+        def vad_segment_filter(segments):
-            segments: Generator[TimeSegment, None, None], max_duration: int
+            """Filter VAD segments by duration and chunk large segments"""
-        ) -> Generator[TimeSegment, None, None]:
+            min_dur = VAD_CONFIG["min_segment_duration"]
-            """
+            max_dur = VAD_CONFIG["max_segment_duration"]
            Input segments:
              [0-2] [3-5] [6-8] [10-11] [12-15] [17-19] [20-22]
-                                  ↓ (max_duration=10)
+            for start_time, end_time, audio_segment in segments:
                segment_duration = end_time - start_time
-              Output batches:
+                # Skip very small segments
-              [0-8]           [10-19]          [20-22]
+                if segment_duration < min_dur:
            Note: silences are kept for better transcription, previous implementation was
            passing segments separatly, but the output was less accurate.
            """
            batch_start_time = None
            batch_end_time = None
            for segment in segments:
                start_time, end_time = segment.start, segment.end
                if batch_start_time is None or batch_end_time is None:
                    batch_start_time = start_time
                    batch_end_time = end_time
                    continue
-                total_duration = end_time - batch_start_time
+                # If segment is within max duration, yield as-is
-
+                if segment_duration <= max_dur:
-                if total_duration <= max_duration:
+                    yield (start_time, end_time, audio_segment)
                    batch_end_time = end_time
                    continue
-                yield TimeSegment(batch_start_time, batch_end_time)
+                # Chunk large segments into smaller pieces
-                batch_start_time = start_time
+                chunk_samples = int(max_dur * SAMPLERATE)
-                batch_end_time = end_time
+                current_start = start_time
-            if batch_start_time is None or batch_end_time is None:
+                for chunk_offset in range(0, len(audio_segment), chunk_samples):
-                return
+                    chunk_audio = audio_segment[
                        chunk_offset : chunk_offset + chunk_samples
                    ]
                    if len(chunk_audio) == 0:
                        break
-            yield TimeSegment(batch_start_time, batch_end_time)
+                    chunk_duration = len(chunk_audio) / float(SAMPLERATE)
                    chunk_end = current_start + chunk_duration
-        def batch_segment_to_audio_segment(
+                    # Only yield chunks that meet minimum duration
-            segments: Generator[TimeSegment, None, None],
+                    if chunk_duration >= min_dur:
-            audio_array,
+                        yield (current_start, chunk_end, chunk_audio)
        ) -> Generator[AudioSegment, None, None]:
            """Extract audio segments and apply padding for Parakeet compatibility.
-            Uses pad_audio to ensure segments are at least 0.5s long, preventing
+                    current_start = chunk_end
            Parakeet crashes. This padding may cause slight timing overlaps between
            segments, which are corrected by enforce_word_timing_constraints.
            """
            for segment in segments:
                start_time, end_time = segment.start, segment.end
                start_sample = int(start_time * SAMPLERATE)
                end_sample = int(end_time * SAMPLERATE)
                audio_segment = audio_array[start_sample:end_sample]
-                padded_segment = pad_audio(audio_segment, SAMPLERATE)
+        def batch_segments(segments, max_files=10, max_duration=5.0):
            batch = []
            batch_duration = 0.0
-                yield AudioSegment(start_time, end_time, padded_segment)
+            for start_time, end_time, audio_segment in segments:
                segment_duration = end_time - start_time
-        def transcribe_batch(model, audio_segments: list) -> list:
+                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 enforce_word_timing_constraints(
            words: list[WordTiming],
        ) -> list[WordTiming]:
            """Enforce that word end times don't exceed the start time of the next word.
            Due to silence padding added in batch_segment_to_audio_segment for better
            transcription accuracy, word timings from different segments may overlap.
            This function ensures there are no overlaps by adjusting end times.
            """
            if len(words) <= 1:
                return words
            enforced_words = []
            for i, word in enumerate(words):
                enforced_word = word.copy()
                if i < len(words) - 1:
                    next_start = words[i + 1]["start"]
                    if enforced_word["end"] > next_start:
                        enforced_word["end"] = next_start
                enforced_words.append(enforced_word)
            return enforced_words
        def emit_results(
-            results: list,
+            results,
-            segments_info: list[AudioSegment],
+            segments_info,
-        ) -> Generator[TranscriptResult, None, None]:
+            batch_index,
            total_batches,
        ):
            """Yield transcribed text and word timings from model output, adjusting timestamps to absolute positions."""
-            for i, (output, segment) in enumerate(zip(results, segments_info)):
+            for i, (output, (start_time, end_time, _)) in enumerate(
-                start_time, end_time = segment.start, segment.end
+                zip(results, segments_info)
            ):
                text = output.text.strip()
-                words: list[WordTiming] = [
+                words = [
-                    WordTiming(
+                    {
-                        word=word_info["word"] + " ",
+                        "word": word_info["word"],
-                        start=round(
+                        "start": round(
                            word_info["start"] + start_time + timestamp_offset, 2
                        ),
-                        end=round(word_info["end"] + start_time + timestamp_offset, 2),
+                        "end": round(
-                    )
+                            word_info["end"] + start_time + timestamp_offset, 2
                        ),
                    }
                    for word_info in output.timestamp["word"]
                ]
-                yield TranscriptResult(text, words)
+                yield text, words
        upload_volume.reload()
@@ -453,31 +407,41 @@ class TranscriberParakeetFile:
        audio_array = load_and_convert_audio(file_path)
        total_duration = len(audio_array) / float(SAMPLERATE)
        processed_duration = 0.0
-        all_text_parts: list[str] = []
+        all_text_parts = []
-        all_words: list[WordTiming] = []
+        all_words = []
        raw_segments = vad_segment_generator(audio_array)
-        speech_segments = batch_speech_segments(
+        filtered_segments = vad_segment_filter(raw_segments)
-            raw_segments,
+        batches = batch_segments(
            filtered_segments,
            VAD_CONFIG["batch_max_files"],
            VAD_CONFIG["batch_max_duration"],
        )
        audio_segments = batch_segment_to_audio_segment(speech_segments, audio_array)
-        for batch in audio_segments:
+        batch_index = 0
-            audio_segment = batch.audio
+        total_batches = max(
-            results = transcribe_batch(self.model, [audio_segment])
+            1, int(total_duration / VAD_CONFIG["batch_max_duration"]) + 1
        )
-            for result in emit_results(
+        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,
                batch_index,
                total_batches,
            ):
-                if not result.text:
+                if not text:
                    continue
-                all_text_parts.append(result.text)
+                all_text_parts.append(text)
-                all_words.extend(result.words)
+                all_words.extend(words)
-        all_words = enforce_word_timing_constraints(all_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}
--- a/server/gpu/modal_deployments/reflector_translator.py
+++ b/server/gpu/modal_deployments/reflector_translator.py
--- a/server/migrations/versions/0194f65cd6d3_add_webhook_fields_to_rooms.py
+++ b/server/migrations/versions/0194f65cd6d3_add_webhook_fields_to_rooms.py
@@ -1,36 +0,0 @@
 """Add webhook fields to rooms
 Revision ID: 0194f65cd6d3
 Revises: 5a8907fd1d78
 Create Date: 2025-08-27 09:03:19.610995
 """
 from typing import Sequence, Union
 import sqlalchemy as sa
 from alembic import op
 # revision identifiers, used by Alembic.
 revision: str = "0194f65cd6d3"
 down_revision: Union[str, None] = "5a8907fd1d78"
 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("room", schema=None) as batch_op:
        batch_op.add_column(sa.Column("webhook_url", sa.String(), nullable=True))
        batch_op.add_column(sa.Column("webhook_secret", sa.String(), nullable=True))
    # ### 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("webhook_secret")
        batch_op.drop_column("webhook_url")
    # ### end Alembic commands ###
--- a/server/migrations/versions/0ce521cda2ee_remove_user_id_from_meeting_table.py
+++ b/server/migrations/versions/0ce521cda2ee_remove_user_id_from_meeting_table.py
@@ -1,36 +0,0 @@
 """remove user_id from meeting table
 Revision ID: 0ce521cda2ee
 Revises: 6dec9fb5b46c
 Create Date: 2025-09-10 12:40:55.688899
 """
 from typing import Sequence, Union
 import sqlalchemy as sa
 from alembic import op
 # revision identifiers, used by Alembic.
 revision: str = "0ce521cda2ee"
 down_revision: Union[str, None] = "6dec9fb5b46c"
 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.drop_column("user_id")
    # ### end Alembic commands ###
 def downgrade() -> 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("user_id", sa.VARCHAR(), autoincrement=False, nullable=True)
        )
    # ### end Alembic commands ###
--- a/server/migrations/versions/1e49625677e4_add_platform_support.py
+++ b/server/migrations/versions/1e49625677e4_add_platform_support.py
@@ -1,50 +0,0 @@
 """add_platform_support
 Revision ID: 1e49625677e4
 Revises: dc035ff72fd5
 Create Date: 2025-10-08 13:17:29.943612
 """
 from typing import Sequence, Union
 import sqlalchemy as sa
 from alembic import op
 # revision identifiers, used by Alembic.
 revision: str = "1e49625677e4"
 down_revision: Union[str, None] = "dc035ff72fd5"
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 def upgrade() -> None:
    """Add platform field with default 'whereby' for backward compatibility."""
    with op.batch_alter_table("room", schema=None) as batch_op:
        batch_op.add_column(
            sa.Column(
                "platform",
                sa.String(),
                nullable=False,
                server_default="whereby",
            )
        )
    with op.batch_alter_table("meeting", schema=None) as batch_op:
        batch_op.add_column(
            sa.Column(
                "platform",
                sa.String(),
                nullable=False,
                server_default="whereby",
            )
        )
 def downgrade() -> None:
    """Remove platform field."""
    with op.batch_alter_table("meeting", schema=None) as batch_op:
        batch_op.drop_column("platform")
    with op.batch_alter_table("room", schema=None) as batch_op:
        batch_op.drop_column("platform")
--- a/server/migrations/versions/2ae3db106d4e_clean_up_orphaned_room_id_references_in_.py
+++ b/server/migrations/versions/2ae3db106d4e_clean_up_orphaned_room_id_references_in_.py
@@ -1,32 +0,0 @@
 """clean up orphaned room_id references in meeting table
 Revision ID: 2ae3db106d4e
 Revises: def1b5867d4c
 Create Date: 2025-09-11 10:35:15.759967
 """
 from typing import Sequence, Union
 from alembic import op
 # revision identifiers, used by Alembic.
 revision: str = "2ae3db106d4e"
 down_revision: Union[str, None] = "def1b5867d4c"
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 def upgrade() -> None:
    # Set room_id to NULL for meetings that reference non-existent rooms
    op.execute("""
        UPDATE meeting
        SET room_id = NULL
        WHERE room_id IS NOT NULL
          AND room_id NOT IN (SELECT id FROM room WHERE id IS NOT NULL)
    """)
 def downgrade() -> None:
    # Cannot restore orphaned references - no operation needed
    pass
--- a/server/migrations/versions/5a8907fd1d78_add_cascade_delete_to_meeting_consent_.py
+++ b/server/migrations/versions/5a8907fd1d78_add_cascade_delete_to_meeting_consent_.py
@@ -1,50 +0,0 @@
 """add cascade delete to meeting consent foreign key
 Revision ID: 5a8907fd1d78
 Revises: 0ab2d7ffaa16
 Create Date: 2025-08-26 17:26:50.945491
 """
 from typing import Sequence, Union
 from alembic import op
 # revision identifiers, used by Alembic.
 revision: str = "5a8907fd1d78"
 down_revision: Union[str, None] = "0ab2d7ffaa16"
 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_consent", schema=None) as batch_op:
        batch_op.drop_constraint(
            batch_op.f("meeting_consent_meeting_id_fkey"), type_="foreignkey"
        )
        batch_op.create_foreign_key(
            batch_op.f("meeting_consent_meeting_id_fkey"),
            "meeting",
            ["meeting_id"],
            ["id"],
            ondelete="CASCADE",
        )
    # ### end Alembic commands ###
 def downgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
    with op.batch_alter_table("meeting_consent", schema=None) as batch_op:
        batch_op.drop_constraint(
            batch_op.f("meeting_consent_meeting_id_fkey"), type_="foreignkey"
        )
        batch_op.create_foreign_key(
            batch_op.f("meeting_consent_meeting_id_fkey"),
            "meeting",
            ["meeting_id"],
            ["id"],
        )
    # ### end Alembic commands ###
--- a/server/migrations/versions/6025e9b2bef2_remove_one_active_meeting_per_room_.py
+++ b/server/migrations/versions/6025e9b2bef2_remove_one_active_meeting_per_room_.py
@@ -1,53 +0,0 @@
 """remove_one_active_meeting_per_room_constraint
 Revision ID: 6025e9b2bef2
 Revises: 2ae3db106d4e
 Create Date: 2025-08-18 18:45:44.418392
 """
 from typing import Sequence, Union
 import sqlalchemy as sa
 from alembic import op
 # revision identifiers, used by Alembic.
 revision: str = "6025e9b2bef2"
 down_revision: Union[str, None] = "2ae3db106d4e"
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 def upgrade() -> None:
    # Remove the unique constraint that prevents multiple active meetings per room
    # This is needed to support calendar integration with overlapping meetings
    # Check if index exists before trying to drop it
    from alembic import context
    if context.get_context().dialect.name == "postgresql":
        conn = op.get_bind()
        result = conn.execute(
            sa.text(
                "SELECT 1 FROM pg_indexes WHERE indexname = 'idx_one_active_meeting_per_room'"
            )
        )
        if result.fetchone():
            op.drop_index("idx_one_active_meeting_per_room", table_name="meeting")
    else:
        # For SQLite, just try to drop it
        try:
            op.drop_index("idx_one_active_meeting_per_room", table_name="meeting")
        except:
            pass
 def downgrade() -> None:
    # Restore the unique constraint
    op.create_index(
        "idx_one_active_meeting_per_room",
        "meeting",
        ["room_id"],
        unique=True,
        postgresql_where=sa.text("is_active = true"),
        sqlite_where=sa.text("is_active = 1"),
    )
--- a/server/migrations/versions/61882a919591_webhook_url_and_secret_null_by_default.py
+++ b/server/migrations/versions/61882a919591_webhook_url_and_secret_null_by_default.py
@@ -1,28 +0,0 @@
 """webhook url and secret null by default
 Revision ID: 61882a919591
 Revises: 0194f65cd6d3
 Create Date: 2025-08-29 11:46:36.738091
 """
 from typing import Sequence, Union
 # revision identifiers, used by Alembic.
 revision: str = "61882a919591"
 down_revision: Union[str, None] = "0194f65cd6d3"
 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! ###
    pass
    # ### end Alembic commands ###
 def downgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
    pass
    # ### end Alembic commands ###
--- a/server/migrations/versions/6dec9fb5b46c_make_meeting_room_id_required_and_add_.py
+++ b/server/migrations/versions/6dec9fb5b46c_make_meeting_room_id_required_and_add_.py
@@ -1,35 +0,0 @@
 """make meeting room_id required and add foreign key
 Revision ID: 6dec9fb5b46c
 Revises: 61882a919591
 Create Date: 2025-09-10 10:47:06.006819
 """
 from typing import Sequence, Union
 from alembic import op
 # revision identifiers, used by Alembic.
 revision: str = "6dec9fb5b46c"
 down_revision: Union[str, None] = "61882a919591"
 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.create_foreign_key(
            None, "room", ["room_id"], ["id"], ondelete="CASCADE"
        )
    # ### end Alembic commands ###
 def downgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
    with op.batch_alter_table("meeting", schema=None) as batch_op:
        batch_op.drop_constraint("meeting_room_id_fkey", type_="foreignkey")
    # ### end Alembic commands ###
--- a/server/migrations/versions/d4a1c446458c_add_grace_period_fields_to_meeting.py
+++ b/server/migrations/versions/d4a1c446458c_add_grace_period_fields_to_meeting.py
@@ -1,34 +0,0 @@
 """add_grace_period_fields_to_meeting
 Revision ID: d4a1c446458c
 Revises: 6025e9b2bef2
 Create Date: 2025-08-18 18:50:37.768052
 """
 from typing import Sequence, Union
 import sqlalchemy as sa
 from alembic import op
 # revision identifiers, used by Alembic.
 revision: str = "d4a1c446458c"
 down_revision: Union[str, None] = "6025e9b2bef2"
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 def upgrade() -> None:
    # Add fields to track when participants left for grace period logic
    op.add_column(
        "meeting", sa.Column("last_participant_left_at", sa.DateTime(timezone=True))
    )
    op.add_column(
        "meeting",
        sa.Column("grace_period_minutes", sa.Integer, server_default=sa.text("15")),
    )
 def downgrade() -> None:
    op.drop_column("meeting", "grace_period_minutes")
    op.drop_column("meeting", "last_participant_left_at")
--- a/server/migrations/versions/d8e204bbf615_add_calendar.py
+++ b/server/migrations/versions/d8e204bbf615_add_calendar.py
@@ -1,129 +0,0 @@
 """add calendar
 Revision ID: d8e204bbf615
 Revises: d4a1c446458c
 Create Date: 2025-09-10 19:56:22.295756
 """
 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 = "d8e204bbf615"
 down_revision: Union[str, None] = "d4a1c446458c"
 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! ###
    op.create_table(
        "calendar_event",
        sa.Column("id", sa.String(), nullable=False),
        sa.Column("room_id", sa.String(), nullable=False),
        sa.Column("ics_uid", sa.Text(), nullable=False),
        sa.Column("title", sa.Text(), nullable=True),
        sa.Column("description", sa.Text(), nullable=True),
        sa.Column("start_time", sa.DateTime(timezone=True), nullable=False),
        sa.Column("end_time", sa.DateTime(timezone=True), nullable=False),
        sa.Column("attendees", postgresql.JSONB(astext_type=sa.Text()), nullable=True),
        sa.Column("location", sa.Text(), nullable=True),
        sa.Column("ics_raw_data", sa.Text(), nullable=True),
        sa.Column("last_synced", sa.DateTime(timezone=True), nullable=False),
        sa.Column(
            "is_deleted", sa.Boolean(), server_default=sa.text("false"), nullable=False
        ),
        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
        sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
        sa.ForeignKeyConstraint(
            ["room_id"],
            ["room.id"],
            name="fk_calendar_event_room_id",
            ondelete="CASCADE",
        ),
        sa.PrimaryKeyConstraint("id"),
        sa.UniqueConstraint("room_id", "ics_uid", name="uq_room_calendar_event"),
    )
    with op.batch_alter_table("calendar_event", schema=None) as batch_op:
        batch_op.create_index(
            "idx_calendar_event_deleted",
            ["is_deleted"],
            unique=False,
            postgresql_where=sa.text("NOT is_deleted"),
        )
        batch_op.create_index(
            "idx_calendar_event_room_start", ["room_id", "start_time"], unique=False
        )
    with op.batch_alter_table("meeting", schema=None) as batch_op:
        batch_op.add_column(sa.Column("calendar_event_id", sa.String(), nullable=True))
        batch_op.add_column(
            sa.Column(
                "calendar_metadata",
                postgresql.JSONB(astext_type=sa.Text()),
                nullable=True,
            )
        )
        batch_op.create_index(
            "idx_meeting_calendar_event", ["calendar_event_id"], unique=False
        )
        batch_op.create_foreign_key(
            "fk_meeting_calendar_event_id",
            "calendar_event",
            ["calendar_event_id"],
            ["id"],
            ondelete="SET NULL",
        )
    with op.batch_alter_table("room", schema=None) as batch_op:
        batch_op.add_column(sa.Column("ics_url", sa.Text(), nullable=True))
        batch_op.add_column(
            sa.Column(
                "ics_fetch_interval", sa.Integer(), server_default="300", nullable=True
            )
        )
        batch_op.add_column(
            sa.Column(
                "ics_enabled",
                sa.Boolean(),
                server_default=sa.text("false"),
                nullable=False,
            )
        )
        batch_op.add_column(
            sa.Column("ics_last_sync", sa.DateTime(timezone=True), nullable=True)
        )
        batch_op.add_column(sa.Column("ics_last_etag", sa.Text(), nullable=True))
        batch_op.create_index("idx_room_ics_enabled", ["ics_enabled"], unique=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_index("idx_room_ics_enabled")
        batch_op.drop_column("ics_last_etag")
        batch_op.drop_column("ics_last_sync")
        batch_op.drop_column("ics_enabled")
        batch_op.drop_column("ics_fetch_interval")
        batch_op.drop_column("ics_url")
    with op.batch_alter_table("meeting", schema=None) as batch_op:
        batch_op.drop_constraint("fk_meeting_calendar_event_id", type_="foreignkey")
        batch_op.drop_index("idx_meeting_calendar_event")
        batch_op.drop_column("calendar_metadata")
        batch_op.drop_column("calendar_event_id")
    with op.batch_alter_table("calendar_event", schema=None) as batch_op:
        batch_op.drop_index("idx_calendar_event_room_start")
        batch_op.drop_index(
            "idx_calendar_event_deleted", postgresql_where=sa.text("NOT is_deleted")
        )
    op.drop_table("calendar_event")
    # ### end Alembic commands ###
--- a/server/migrations/versions/dc035ff72fd5_remove_grace_period_fields.py
+++ b/server/migrations/versions/dc035ff72fd5_remove_grace_period_fields.py
@@ -1,43 +0,0 @@
 """remove_grace_period_fields
 Revision ID: dc035ff72fd5
 Revises: d8e204bbf615
 Create Date: 2025-09-11 10:36:45.197588
 """
 from typing import Sequence, Union
 import sqlalchemy as sa
 from alembic import op
 # revision identifiers, used by Alembic.
 revision: str = "dc035ff72fd5"
 down_revision: Union[str, None] = "d8e204bbf615"
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 def upgrade() -> None:
    # Remove grace period columns from meeting table
    op.drop_column("meeting", "last_participant_left_at")
    op.drop_column("meeting", "grace_period_minutes")
 def downgrade() -> None:
    # Add back grace period columns to meeting table
    op.add_column(
        "meeting",
        sa.Column(
            "last_participant_left_at", sa.DateTime(timezone=True), nullable=True
        ),
    )
    op.add_column(
        "meeting",
        sa.Column(
            "grace_period_minutes",
            sa.Integer(),
            server_default=sa.text("15"),
            nullable=True,
        ),
    )
--- a/server/migrations/versions/def1b5867d4c_make_meeting_room_id_nullable_but_keep_.py
+++ b/server/migrations/versions/def1b5867d4c_make_meeting_room_id_nullable_but_keep_.py
@@ -1,34 +0,0 @@
 """make meeting room_id nullable but keep foreign key
 Revision ID: def1b5867d4c
 Revises: 0ce521cda2ee
 Create Date: 2025-09-11 09:42:18.697264
 """
 from typing import Sequence, Union
 import sqlalchemy as sa
 from alembic import op
 # revision identifiers, used by Alembic.
 revision: str = "def1b5867d4c"
 down_revision: Union[str, None] = "0ce521cda2ee"
 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("room_id", existing_type=sa.VARCHAR(), nullable=True)
    # ### end Alembic commands ###
 def downgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
    with op.batch_alter_table("meeting", schema=None) as batch_op:
        batch_op.alter_column("room_id", existing_type=sa.VARCHAR(), nullable=False)
    # ### end Alembic commands ###
--- a/server/pyproject.toml
+++ b/server/pyproject.toml
@@ -12,6 +12,7 @@ dependencies = [
    "requests>=2.31.0",
    "aiortc>=1.5.0",
    "sortedcontainers>=2.4.0",
    "loguru>=0.7.0",
    "pydantic-settings>=2.0.2",
    "structlog>=23.1.0",
    "uvicorn[standard]>=0.23.1",
@@ -26,6 +27,7 @@ dependencies = [
    "prometheus-fastapi-instrumentator>=6.1.0",
    "sentencepiece>=0.1.99",
    "protobuf>=4.24.3",
    "profanityfilter>=2.0.6",
    "celery>=5.3.4",
    "redis>=5.0.1",
    "python-jose[cryptography]>=3.3.0",
@@ -38,7 +40,6 @@ dependencies = [
    "llama-index-llms-openai-like>=0.4.0",
    "pytest-env>=1.1.5",
    "webvtt-py>=0.5.0",
    "icalendar>=6.0.0",
 ]
 [dependency-groups]
@@ -112,14 +113,13 @@ source = ["reflector"]
 [tool.pytest_env]
 ENVIRONMENT = "pytest"
 DATABASE_URL = "postgresql://test_user:test_password@localhost:15432/reflector_test"
 AUTH_BACKEND = "jwt"
 [tool.pytest.ini_options]
 addopts = "-ra -q --disable-pytest-warnings --cov --cov-report html -v"
 testpaths = ["tests"]
 asyncio_mode = "auto"
 markers = [
-    "model_api: tests for the unified model-serving HTTP API (backend- and hardware-agnostic)",
+    "gpu_modal: mark test to run only with GPU Modal endpoints (deselect with '-m \"not gpu_modal\"')",
 ]
 [tool.ruff.lint]
@@ -131,7 +131,7 @@ select = [
 [tool.ruff.lint.per-file-ignores]
 "reflector/processors/summary/summary_builder.py" = ["E501"]
-"gpu/modal_deployments/**.py" = ["PLC0415"]
+"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
@@ -27,7 +26,6 @@ from reflector.views.transcripts_upload import router as transcripts_upload_rout
 from reflector.views.transcripts_webrtc import router as transcripts_webrtc_router
 from reflector.views.transcripts_websocket import router as transcripts_websocket_router
 from reflector.views.user import router as user_router
 from reflector.views.user_websocket import router as user_ws_router
 from reflector.views.whereby import router as whereby_router
 from reflector.views.zulip import router as zulip_router
@@ -67,12 +65,6 @@ app.add_middleware(
    allow_headers=["*"],
 )
@app.get("/health")
 async def health():
    return {"status": "healthy"}
 # metrics
 instrumentator = Instrumentator(
    excluded_handlers=["/docs", "/metrics"],
@@ -92,10 +84,8 @@ app.include_router(transcripts_websocket_router, prefix="/v1")
 app.include_router(transcripts_webrtc_router, prefix="/v1")
 app.include_router(transcripts_process_router, prefix="/v1")
 app.include_router(user_router, prefix="/v1")
 app.include_router(user_ws_router, prefix="/v1")
 app.include_router(zulip_router, prefix="/v1")
 app.include_router(whereby_router, prefix="/v1")
 app.include_router(daily_router, prefix="/v1/daily")
 add_pagination(app)
 # prepare celery
--- a/server/reflector/asynctask.py
+++ b/server/reflector/asynctask.py
@@ -1,27 +0,0 @@
 import asyncio
 import functools
 from reflector.db import get_database
 def asynctask(f):
    @functools.wraps(f)
    def wrapper(*args, **kwargs):
        async def run_with_db():
            database = get_database()
            await database.connect()
            try:
                return await f(*args, **kwargs)
            finally:
                await database.disconnect()
        coro = run_with_db()
        try:
            loop = asyncio.get_running_loop()
        except RuntimeError:
            loop = None
        if loop and loop.is_running():
            return loop.run_until_complete(coro)
        return asyncio.run(coro)
    return wrapper
--- a/server/reflector/auth/auth_jwt.py
+++ b/server/reflector/auth/auth_jwt.py
@@ -67,8 +67,7 @@ def current_user(
    try:
        payload = jwtauth.verify_token(token)
        sub = payload["sub"]
-        email = payload["email"]
+        return UserInfo(sub=sub)
        return UserInfo(sub=sub, email=email)
    except JWTError as e:
        logger.error(f"JWT error: {e}")
        raise HTTPException(status_code=401, detail="Invalid authentication")
--- a/server/reflector/db/init.py
+++ b/server/reflector/db/init.py
@@ -24,7 +24,6 @@ def get_database() -> databases.Database:
 # import models
 import reflector.db.calendar_events  # noqa
 import reflector.db.meetings  # noqa
 import reflector.db.recordings  # noqa
 import reflector.db.rooms  # noqa
--- a/server/reflector/db/calendar_events.py
+++ b/server/reflector/db/calendar_events.py
@@ -1,187 +0,0 @@
 from datetime import datetime, timedelta, timezone
 from typing import Any
 import sqlalchemy as sa
 from pydantic import BaseModel, Field
 from sqlalchemy.dialects.postgresql import JSONB
 from reflector.db import get_database, metadata
 from reflector.utils import generate_uuid4
 calendar_events = sa.Table(
    "calendar_event",
    metadata,
    sa.Column("id", sa.String, primary_key=True),
    sa.Column(
        "room_id",
        sa.String,
        sa.ForeignKey("room.id", ondelete="CASCADE", name="fk_calendar_event_room_id"),
        nullable=False,
    ),
    sa.Column("ics_uid", sa.Text, nullable=False),
    sa.Column("title", sa.Text),
    sa.Column("description", sa.Text),
    sa.Column("start_time", sa.DateTime(timezone=True), nullable=False),
    sa.Column("end_time", sa.DateTime(timezone=True), nullable=False),
    sa.Column("attendees", JSONB),
    sa.Column("location", sa.Text),
    sa.Column("ics_raw_data", sa.Text),
    sa.Column("last_synced", sa.DateTime(timezone=True), nullable=False),
    sa.Column("is_deleted", sa.Boolean, nullable=False, server_default=sa.false()),
    sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
    sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
    sa.UniqueConstraint("room_id", "ics_uid", name="uq_room_calendar_event"),
    sa.Index("idx_calendar_event_room_start", "room_id", "start_time"),
    sa.Index(
        "idx_calendar_event_deleted",
        "is_deleted",
        postgresql_where=sa.text("NOT is_deleted"),
    ),
 )
 class CalendarEvent(BaseModel):
    id: str = Field(default_factory=generate_uuid4)
    room_id: str
    ics_uid: str
    title: str | None = None
    description: str | None = None
    start_time: datetime
    end_time: datetime
    attendees: list[dict[str, Any]] | None = None
    location: str | None = None
    ics_raw_data: str | None = None
    last_synced: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
    is_deleted: bool = False
    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
 class CalendarEventController:
    async def get_by_room(
        self,
        room_id: str,
        include_deleted: bool = False,
        start_after: datetime | None = None,
        end_before: datetime | None = None,
    ) -> list[CalendarEvent]:
        query = calendar_events.select().where(calendar_events.c.room_id == room_id)
        if not include_deleted:
            query = query.where(calendar_events.c.is_deleted == False)
        if start_after:
            query = query.where(calendar_events.c.start_time >= start_after)
        if end_before:
            query = query.where(calendar_events.c.end_time <= end_before)
        query = query.order_by(calendar_events.c.start_time.asc())
        results = await get_database().fetch_all(query)
        return [CalendarEvent(**result) for result in results]
    async def get_upcoming(
        self, room_id: str, minutes_ahead: int = 120
    ) -> list[CalendarEvent]:
        """Get upcoming events for a room within the specified minutes, including currently happening events."""
        now = datetime.now(timezone.utc)
        future_time = now + timedelta(minutes=minutes_ahead)
        query = (
            calendar_events.select()
            .where(
                sa.and_(
                    calendar_events.c.room_id == room_id,
                    calendar_events.c.is_deleted == False,
                    calendar_events.c.start_time <= future_time,
                    calendar_events.c.end_time >= now,
                )
            )
            .order_by(calendar_events.c.start_time.asc())
        )
        results = await get_database().fetch_all(query)
        return [CalendarEvent(**result) for result in results]
    async def get_by_id(self, event_id: str) -> CalendarEvent | None:
        query = calendar_events.select().where(calendar_events.c.id == event_id)
        result = await get_database().fetch_one(query)
        return CalendarEvent(**result) if result else None
    async def get_by_ics_uid(self, room_id: str, ics_uid: str) -> CalendarEvent | None:
        query = calendar_events.select().where(
            sa.and_(
                calendar_events.c.room_id == room_id,
                calendar_events.c.ics_uid == ics_uid,
            )
        )
        result = await get_database().fetch_one(query)
        return CalendarEvent(**result) if result else None
    async def upsert(self, event: CalendarEvent) -> CalendarEvent:
        existing = await self.get_by_ics_uid(event.room_id, event.ics_uid)
        if existing:
            event.id = existing.id
            event.created_at = existing.created_at
            event.updated_at = datetime.now(timezone.utc)
            query = (
                calendar_events.update()
                .where(calendar_events.c.id == existing.id)
                .values(**event.model_dump())
            )
        else:
            query = calendar_events.insert().values(**event.model_dump())
        await get_database().execute(query)
        return event
    async def soft_delete_missing(
        self, room_id: str, current_ics_uids: list[str]
    ) -> int:
        """Soft delete future events that are no longer in the calendar."""
        now = datetime.now(timezone.utc)
        select_query = calendar_events.select().where(
            sa.and_(
                calendar_events.c.room_id == room_id,
                calendar_events.c.start_time > now,
                calendar_events.c.is_deleted == False,
                calendar_events.c.ics_uid.notin_(current_ics_uids)
                if current_ics_uids
                else True,
            )
        )
        to_delete = await get_database().fetch_all(select_query)
        delete_count = len(to_delete)
        if delete_count > 0:
            update_query = (
                calendar_events.update()
                .where(
                    sa.and_(
                        calendar_events.c.room_id == room_id,
                        calendar_events.c.start_time > now,
                        calendar_events.c.is_deleted == False,
                        calendar_events.c.ics_uid.notin_(current_ics_uids)
                        if current_ics_uids
                        else True,
                    )
                )
                .values(is_deleted=True, updated_at=now)
            )
            await get_database().execute(update_query)
        return delete_count
    async def delete_by_room(self, room_id: str) -> int:
        query = calendar_events.delete().where(calendar_events.c.room_id == room_id)
        result = await get_database().execute(query)
        return result.rowcount
 calendar_events_controller = CalendarEventController()
--- a/server/reflector/db/meetings.py
+++ b/server/reflector/db/meetings.py
@@ -1,13 +1,12 @@
 from datetime import datetime
-from typing import Any, Literal
+from typing import Literal
 import sqlalchemy as sa
 from fastapi import HTTPException
 from pydantic import BaseModel, Field
 from sqlalchemy.dialects.postgresql import JSONB
 from reflector.db import get_database, metadata
 from reflector.db.rooms import Room
 from reflector.platform_types import Platform
 from reflector.utils import generate_uuid4
 meetings = sa.Table(
@@ -19,12 +18,8 @@ meetings = sa.Table(
    sa.Column("host_room_url", sa.String),
    sa.Column("start_date", sa.DateTime(timezone=True)),
    sa.Column("end_date", sa.DateTime(timezone=True)),
-    sa.Column(
+    sa.Column("user_id", sa.String),
-        "room_id",
+    sa.Column("room_id", sa.String),
        sa.String,
        sa.ForeignKey("room.id", ondelete="CASCADE"),
        nullable=True,
    ),
    sa.Column("is_locked", sa.Boolean, nullable=False, server_default=sa.false()),
    sa.Column("room_mode", sa.String, nullable=False, server_default="normal"),
    sa.Column("recording_type", sa.String, nullable=False, server_default="cloud"),
@@ -46,36 +41,20 @@ meetings = sa.Table(
        nullable=False,
        server_default=sa.true(),
    ),
    sa.Column(
        "calendar_event_id",
        sa.String,
        sa.ForeignKey(
            "calendar_event.id",
            ondelete="SET NULL",
            name="fk_meeting_calendar_event_id",
        ),
    ),
    sa.Column("calendar_metadata", JSONB),
    sa.Column(
        "platform",
        sa.String,
        nullable=False,
        server_default="whereby",
    ),
    sa.Index("idx_meeting_room_id", "room_id"),
-    sa.Index("idx_meeting_calendar_event", "calendar_event_id"),
+    sa.Index(
        "idx_one_active_meeting_per_room",
        "room_id",
        unique=True,
        postgresql_where=sa.text("is_active = true"),
    ),
 )
 meeting_consent = sa.Table(
    "meeting_consent",
    metadata,
    sa.Column("id", sa.String, primary_key=True),
-    sa.Column(
+    sa.Column("meeting_id", sa.String, sa.ForeignKey("meeting.id"), nullable=False),
        "meeting_id",
        sa.String,
        sa.ForeignKey("meeting.id", ondelete="CASCADE"),
        nullable=False,
    ),
    sa.Column("user_id", sa.String),
    sa.Column("consent_given", sa.Boolean, nullable=False),
    sa.Column("consent_timestamp", sa.DateTime(timezone=True), nullable=False),
@@ -97,18 +76,15 @@ class Meeting(BaseModel):
    host_room_url: str
    start_date: datetime
    end_date: datetime
-    room_id: str | None
+    user_id: str | None = None
    room_id: str | None = None
    is_locked: bool = False
    room_mode: Literal["normal", "group"] = "normal"
    recording_type: Literal["none", "local", "cloud"] = "cloud"
-    recording_trigger: Literal[  # whereby-specific
+    recording_trigger: Literal[
        "none", "prompt", "automatic", "automatic-2nd-participant"
    ] = "automatic-2nd-participant"
    num_clients: int = 0
    is_active: bool = True
    calendar_event_id: str | None = None
    calendar_metadata: dict[str, Any] | None = None
    platform: Platform = "whereby"
 class MeetingController:
@@ -120,11 +96,12 @@ class MeetingController:
        host_room_url: str,
        start_date: datetime,
        end_date: datetime,
        user_id: str,
        room: Room,
        calendar_event_id: str | None = None,
        calendar_metadata: dict[str, Any] | None = None,
        platform: Platform = "whereby",
    ):
        """
        Create a new meeting
        """
        meeting = Meeting(
            id=id,
            room_name=room_name,
@@ -132,47 +109,41 @@ class MeetingController:
            host_room_url=host_room_url,
            start_date=start_date,
            end_date=end_date,
            user_id=user_id,
            room_id=room.id,
            is_locked=room.is_locked,
            room_mode=room.room_mode,
            recording_type=room.recording_type,
            recording_trigger=room.recording_trigger,
            calendar_event_id=calendar_event_id,
            calendar_metadata=calendar_metadata,
            platform=platform,
        )
        query = meetings.insert().values(**meeting.model_dump())
        await get_database().execute(query)
        return meeting
    async def get_all_active(self) -> list[Meeting]:
        """
        Get active meetings.
        """
        query = meetings.select().where(meetings.c.is_active)
        return await get_database().fetch_all(query)
    async def get_by_room_name(
        self,
        room_name: str,
-    ) -> Meeting | None:
+    ) -> Meeting:
        """
        Get a meeting by room name.
        For backward compatibility, returns the most recent meeting.
        """
-        end_date = getattr(meetings.c, "end_date")
+        query = meetings.select().where(meetings.c.room_name == room_name)
        query = (
            meetings.select()
            .where(meetings.c.room_name == room_name)
            .order_by(end_date.desc())
        )
        result = await get_database().fetch_one(query)
        if not result:
            return None
        return Meeting(**result)
-    async def get_active(self, room: Room, current_time: datetime) -> Meeting | None:
+    async def get_active(self, room: Room, current_time: datetime) -> Meeting:
        """
        Get latest active meeting for a room.
        For backward compatibility, returns the most recent active meeting.
        """
        end_date = getattr(meetings.c, "end_date")
        query = (
@@ -192,85 +163,37 @@ class MeetingController:
        return Meeting(**result)
    async def get_all_active_for_room(
        self, room: Room, current_time: datetime
    ) -> list[Meeting]:
        end_date = getattr(meetings.c, "end_date")
        query = (
            meetings.select()
            .where(
                sa.and_(
                    meetings.c.room_id == room.id,
                    meetings.c.end_date > current_time,
                    meetings.c.is_active,
                )
            )
            .order_by(end_date.desc())
        )
        results = await get_database().fetch_all(query)
        return [Meeting(**result) for result in results]
    async def get_active_by_calendar_event(
        self, room: Room, calendar_event_id: str, current_time: datetime
    ) -> Meeting | None:
        """
        Get active meeting for a specific calendar event.
        """
        query = meetings.select().where(
            sa.and_(
                meetings.c.room_id == room.id,
                meetings.c.calendar_event_id == calendar_event_id,
                meetings.c.end_date > current_time,
                meetings.c.is_active,
            )
        )
        result = await get_database().fetch_one(query)
        if not result:
            return None
        return Meeting(**result)
    async def get_by_id(self, meeting_id: str, **kwargs) -> Meeting | None:
        """
        Get a meeting by id
        """
        query = meetings.select().where(meetings.c.id == meeting_id)
        result = await get_database().fetch_one(query)
        if not result:
            return None
        return Meeting(**result)
-    async def get_by_calendar_event(self, calendar_event_id: str) -> Meeting | None:
+    async def get_by_id_for_http(self, meeting_id: str, user_id: str | None) -> Meeting:
-        query = meetings.select().where(
+        """
-            meetings.c.calendar_event_id == calendar_event_id
+        Get a meeting by ID for HTTP request.
-        )
+
        If not found, it will raise a 404 error.
        """
        query = meetings.select().where(meetings.c.id == meeting_id)
        result = await get_database().fetch_one(query)
        if not result:
-            return None
+            raise HTTPException(status_code=404, detail="Meeting not found")
-        return Meeting(**result)
+
        meeting = Meeting(**result)
        if result["user_id"] != user_id:
            meeting.host_room_url = ""
        return meeting
    async def update_meeting(self, meeting_id: str, **kwargs):
        query = meetings.update().where(meetings.c.id == meeting_id).values(**kwargs)
        await get_database().execute(query)
    async def increment_num_clients(self, meeting_id: str):
        """Atomically increment participant count."""
        query = (
            meetings.update()
            .where(meetings.c.id == meeting_id)
            .values(num_clients=meetings.c.num_clients + 1)
        )
        await get_database().execute(query)
    async def decrement_num_clients(self, meeting_id: str):
        """Atomically decrement participant count (min 0)."""
        query = (
            meetings.update()
            .where(meetings.c.id == meeting_id)
            .values(
                num_clients=sa.case(
                    (meetings.c.num_clients > 0, meetings.c.num_clients - 1), else_=0
                )
            )
        )
        await get_database().execute(query)
 class MeetingConsentController:
    async def get_by_meeting_id(self, meeting_id: str) -> list[MeetingConsent]:
@@ -291,9 +214,10 @@ class MeetingConsentController:
        result = await get_database().fetch_one(query)
        if result is None:
            return None
-        return MeetingConsent(**result)
+        return MeetingConsent(**result) if result else None
    async def upsert(self, consent: MeetingConsent) -> MeetingConsent:
        """Create new consent or update existing one for authenticated users"""
        if consent.user_id:
            # For authenticated users, check if consent already exists
            # not transactional but we're ok with that; the consents ain't deleted anyways
--- a/server/reflector/db/rooms.py
+++ b/server/reflector/db/rooms.py
@@ -1,7 +1,6 @@
 import secrets
 from datetime import datetime, timezone
 from sqlite3 import IntegrityError
-from typing import Literal, Optional
+from typing import Literal
 import sqlalchemy
 from fastapi import HTTPException
@@ -9,7 +8,6 @@ from pydantic import BaseModel, Field
 from sqlalchemy.sql import false, or_
 from reflector.db import get_database, metadata
 from reflector.platform_types import Platform
 from reflector.utils import generate_uuid4
 rooms = sqlalchemy.Table(
@@ -42,23 +40,7 @@ rooms = sqlalchemy.Table(
    sqlalchemy.Column(
        "is_shared", sqlalchemy.Boolean, nullable=False, server_default=false()
    ),
    sqlalchemy.Column("webhook_url", sqlalchemy.String, nullable=True),
    sqlalchemy.Column("webhook_secret", sqlalchemy.String, nullable=True),
    sqlalchemy.Column("ics_url", sqlalchemy.Text),
    sqlalchemy.Column("ics_fetch_interval", sqlalchemy.Integer, server_default="300"),
    sqlalchemy.Column(
        "ics_enabled", sqlalchemy.Boolean, nullable=False, server_default=false()
    ),
    sqlalchemy.Column("ics_last_sync", sqlalchemy.DateTime(timezone=True)),
    sqlalchemy.Column("ics_last_etag", sqlalchemy.Text),
    sqlalchemy.Column(
        "platform",
        sqlalchemy.String,
        nullable=False,
        server_default="whereby",
    ),
    sqlalchemy.Index("idx_room_is_shared", "is_shared"),
    sqlalchemy.Index("idx_room_ics_enabled", "ics_enabled"),
 )
@@ -73,18 +55,10 @@ class Room(BaseModel):
    is_locked: bool = False
    room_mode: Literal["normal", "group"] = "normal"
    recording_type: Literal["none", "local", "cloud"] = "cloud"
-    recording_trigger: Literal[  # whereby-specific
+    recording_trigger: Literal[
        "none", "prompt", "automatic", "automatic-2nd-participant"
    ] = "automatic-2nd-participant"
    is_shared: bool = False
    webhook_url: str | None = None
    webhook_secret: str | None = None
    ics_url: str | None = None
    ics_fetch_interval: int = 300
    ics_enabled: bool = False
    ics_last_sync: datetime | None = None
    ics_last_etag: str | None = None
    platform: Platform = "whereby"
 class RoomController:
@@ -133,19 +107,10 @@ class RoomController:
        recording_type: str,
        recording_trigger: str,
        is_shared: bool,
        webhook_url: str = "",
        webhook_secret: str = "",
        ics_url: str | None = None,
        ics_fetch_interval: int = 300,
        ics_enabled: bool = False,
        platform: Optional[Platform] = None,
    ):
        """
        Add a new room
        """
        if webhook_url and not webhook_secret:
            webhook_secret = secrets.token_urlsafe(32)
        room = Room(
            name=name,
            user_id=user_id,
@@ -157,12 +122,6 @@ class RoomController:
            recording_type=recording_type,
            recording_trigger=recording_trigger,
            is_shared=is_shared,
            webhook_url=webhook_url,
            webhook_secret=webhook_secret,
            ics_url=ics_url,
            ics_fetch_interval=ics_fetch_interval,
            ics_enabled=ics_enabled,
            platform=platform or "whereby",
        )
        query = rooms.insert().values(**room.model_dump())
        try:
@@ -175,9 +134,6 @@ class RoomController:
        """
        Update a room fields with key/values in values
        """
        if values.get("webhook_url") and not values.get("webhook_secret"):
            values["webhook_secret"] = secrets.token_urlsafe(32)
        query = rooms.update().where(rooms.c.id == room.id).values(**values)
        try:
            await get_database().execute(query)
@@ -227,13 +183,6 @@ class RoomController:
        return room
    async def get_ics_enabled(self) -> list[Room]:
        query = rooms.select().where(
            rooms.c.ics_enabled == True, rooms.c.ics_url != None
        )
        results = await get_database().fetch_all(query)
        return [Room(**result) for result in results]
    async def remove_by_id(
        self,
        room_id: str,
--- a/server/reflector/db/search.py
+++ b/server/reflector/db/search.py
@@ -8,14 +8,12 @@ from typing import Annotated, Any, Dict, Iterator
 import sqlalchemy
 import webvtt
 from databases.interfaces import Record as DbRecord
 from fastapi import HTTPException
 from pydantic import (
    BaseModel,
    Field,
    NonNegativeFloat,
    NonNegativeInt,
    TypeAdapter,
    ValidationError,
    constr,
    field_serializer,
@@ -23,10 +21,9 @@ from pydantic import (
 from reflector.db import get_database
 from reflector.db.rooms import rooms
-from reflector.db.transcripts import SourceKind, TranscriptStatus, transcripts
+from reflector.db.transcripts import SourceKind, transcripts
 from reflector.db.utils import is_postgresql
 from reflector.logger import logger
 from reflector.utils.string import NonEmptyString, try_parse_non_empty_string
 DEFAULT_SEARCH_LIMIT = 20
 SNIPPET_CONTEXT_LENGTH = 50  # Characters before/after match to include
@@ -34,13 +31,12 @@ DEFAULT_SNIPPET_MAX_LENGTH = NonNegativeInt(150)
 DEFAULT_MAX_SNIPPETS = NonNegativeInt(3)
 LONG_SUMMARY_MAX_SNIPPETS = 2
-SearchQueryBase = constr(min_length=1, strip_whitespace=True)
+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")]
 search_query_adapter = TypeAdapter(SearchQuery)
 SearchLimit = Annotated[SearchLimitBase, Field(description="Results per page")]
 SearchOffset = Annotated[
    SearchOffsetBase, Field(description="Number of results to skip")
@@ -92,7 +88,7 @@ class WebVTTProcessor:
    @staticmethod
    def generate_snippets(
        webvtt_content: WebVTTContent,
-        query: SearchQuery,
+        query: str,
        max_snippets: NonNegativeInt = DEFAULT_MAX_SNIPPETS,
    ) -> list[str]:
        """Generate snippets from WebVTT content."""
@@ -129,7 +125,7 @@ class SnippetCandidate:
 class SearchParameters(BaseModel):
    """Validated search parameters for full-text search."""
-    query_text: SearchQuery | None = None
+    query_text: SearchQuery
    limit: SearchLimit = DEFAULT_SEARCH_LIMIT
    offset: SearchOffset = 0
    user_id: str | None = None
@@ -161,7 +157,7 @@ class SearchResult(BaseModel):
    room_name: str | None = None
    source_kind: SourceKind
    created_at: datetime
-    status: TranscriptStatus = Field(..., min_length=1)
+    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(
@@ -203,13 +199,15 @@ class SnippetGenerator:
            prev_start = start
    @staticmethod
-    def count_matches(text: str, query: SearchQuery) -> NonNegativeInt:
+    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
-        assert query is not None
+        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))
        )
@@ -245,14 +243,13 @@ class SnippetGenerator:
    @staticmethod
    def generate(
        text: str,
-        query: SearchQuery,
+        query: str,
        max_length: NonNegativeInt = DEFAULT_SNIPPET_MAX_LENGTH,
        max_snippets: NonNegativeInt = DEFAULT_MAX_SNIPPETS,
    ) -> list[str]:
        """Generate snippets from text."""
-        assert query is not None
+        if not text or not query:
-        if not text:
+            logger.warning("Empty text or query for generate_snippets")
            logger.warning("Empty text for generate_snippets")
            return []
        candidates = (
@@ -273,7 +270,7 @@ class SnippetGenerator:
    @staticmethod
    def from_summary(
        summary: str,
-        query: SearchQuery,
+        query: str,
        max_snippets: NonNegativeInt = LONG_SUMMARY_MAX_SNIPPETS,
    ) -> list[str]:
        """Generate snippets from summary text."""
@@ -281,9 +278,9 @@ class SnippetGenerator:
    @staticmethod
    def combine_sources(
-        summary: NonEmptyString | None,
+        summary: str | None,
        webvtt: WebVTTContent | None,
-        query: SearchQuery,
+        query: str,
        max_total: NonNegativeInt = DEFAULT_MAX_SNIPPETS,
    ) -> tuple[list[str], NonNegativeInt]:
        """Combine snippets from multiple sources and return total match count.
@@ -292,11 +289,6 @@ class SnippetGenerator:
        snippets can be empty for real in case of e.g. title match
        """
        assert (
            summary is not None or webvtt is not None
        ), "At least one source must be present"
        webvtt_matches = 0
        summary_matches = 0
@@ -363,8 +355,8 @@ class SearchController:
                else_=rooms.c.name,
            ).label("room_name"),
        ]
-        search_query = None
+
-        if params.query_text is not None:
+        if params.query_text:
            search_query = sqlalchemy.func.websearch_to_tsquery(
                "english", params.query_text
            )
@@ -381,9 +373,7 @@ class SearchController:
            transcripts.join(rooms, transcripts.c.room_id == rooms.c.id, isouter=True)
        )
-        if params.query_text is not None:
+        if params.query_text:
            # because already initialized based on params.query_text presence above
            assert search_query is not None
            base_query = base_query.where(
                transcripts.c.search_vector_en.op("@@")(search_query)
            )
@@ -403,7 +393,7 @@ class SearchController:
                transcripts.c.source_kind == params.source_kind
            )
-        if params.query_text is not None:
+        if params.query_text:
            order_by = sqlalchemy.desc(sqlalchemy.text("rank"))
        else:
            order_by = sqlalchemy.desc(transcripts.c.created_at)
@@ -417,29 +407,19 @@ class SearchController:
        )
        total = await get_database().fetch_val(count_query)
-        def _process_result(r: DbRecord) -> SearchResult:
+        def _process_result(r) -> SearchResult:
            r_dict: Dict[str, Any] = dict(r)
            webvtt_raw: str | None = r_dict.pop("webvtt", None)
            webvtt: WebVTTContent | None
            if webvtt_raw:
                webvtt = WebVTTProcessor.parse(webvtt_raw)
            else:
                webvtt = None
-
+            long_summary: str | None = r_dict.pop("long_summary", None)
            long_summary_r: str | None = r_dict.pop("long_summary", None)
            long_summary: NonEmptyString = try_parse_non_empty_string(long_summary_r)
            room_name: str | None = r_dict.pop("room_name", None)
            db_result = SearchResultDB.model_validate(r_dict)
-            at_least_one_source = webvtt is not None or long_summary is not None
+            snippets, total_match_count = SnippetGenerator.combine_sources(
-            has_query = params.query_text is not None
+                long_summary, webvtt, params.query_text, DEFAULT_MAX_SNIPPETS
            snippets, total_match_count = (
                SnippetGenerator.combine_sources(
                    long_summary, webvtt, params.query_text, DEFAULT_MAX_SNIPPETS
                )
                if has_query and at_least_one_source
                else ([], 0)
            )
            return SearchResult(
--- a/server/reflector/db/transcripts.py
+++ b/server/reflector/db/transcripts.py
@@ -122,15 +122,6 @@ def generate_transcript_name() -> str:
    return f"Transcript {now.strftime('%Y-%m-%d %H:%M:%S')}"
 TranscriptStatus = Literal[
    "idle", "uploaded", "recording", "processing", "error", "ended"
 ]
 class StrValue(BaseModel):
    value: str
 class AudioWaveform(BaseModel):
    data: list[float]
@@ -194,7 +185,7 @@ class Transcript(BaseModel):
    id: str = Field(default_factory=generate_uuid4)
    user_id: str | None = None
    name: str = Field(default_factory=generate_transcript_name)
-    status: TranscriptStatus = "idle"
+    status: str = "idle"
    duration: float = 0
    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
    title: str | None = None
@@ -647,19 +638,6 @@ class TranscriptController:
        query = transcripts.delete().where(transcripts.c.recording_id == recording_id)
        await get_database().execute(query)
    @staticmethod
    def user_can_mutate(transcript: Transcript, user_id: str | None) -> bool:
        """
        Returns True if the given user is allowed to modify the transcript.
        Policy:
        - Anonymous transcripts (user_id is None) cannot be modified via API
        - Only the owner (matching user_id) can modify their transcript
        """
        if transcript.user_id is None:
            return False
        return user_id and transcript.user_id == user_id
    @asynccontextmanager
    async def transaction(self):
        """
@@ -754,27 +732,5 @@ class TranscriptController:
        transcript.delete_participant(participant_id)
        await self.update(transcript, {"participants": transcript.participants_dump()})
    async def set_status(
        self, transcript_id: str, status: TranscriptStatus
    ) -> TranscriptEvent | None:
        """
        Update the status of a transcript
        Will add an event STATUS + update the status field of transcript
        """
        async with self.transaction():
            transcript = await self.get_by_id(transcript_id)
            if not transcript:
                raise Exception(f"Transcript {transcript_id} not found")
            if transcript.status == status:
                return
            resp = await self.append_event(
                transcript=transcript,
                event="STATUS",
                data=StrValue(value=status),
            )
            await self.update(transcript, {"status": status})
        return resp
 transcripts_controller = TranscriptController()
--- a/server/reflector/pipelines/MULTITRACK_FIX_SUMMARY.md
+++ b/server/reflector/pipelines/MULTITRACK_FIX_SUMMARY.md
@@ -1,84 +0,0 @@
 # Multitrack Pipeline Fix Summary
 ## Problem
 Whisper timestamps were incorrect because it ignores leading silence in audio files. Daily.co tracks can have arbitrary amounts of silence before speech starts.
 ## Solution
 **Pad tracks BEFORE transcription using stream metadata `start_time`**
 This makes Whisper timestamps automatically correct relative to recording start.
 ## Key Changes in `main_multitrack_pipeline_fixed.py`
 ### 1. Added `pad_track_for_transcription()` method (lines 55-172)
 ```python
 async def pad_track_for_transcription(
    self,
    track_data: bytes,
    track_idx: int,
    storage,
 ) -> tuple[bytes, str]:
 ```
 - Extracts stream metadata `start_time` using PyAV
 - Creates PyAV filter graph with `adelay` filter to add padding
 - Stores padded track to S3 and returns URL
 - Uses same audio processing library (PyAV) already in the pipeline
 ### 2. Modified `process()` method
 #### REMOVED (lines 255-302):
 - Entire filename parsing for offsets - NOT NEEDED ANYMORE
 - The complex regex parsing of Daily.co filenames
 - Offset adjustment after transcription
 #### ADDED (lines 371-382):
 - Padding step BEFORE transcription:
 ```python
 # PAD TRACKS BEFORE TRANSCRIPTION - THIS IS THE KEY FIX!
 padded_track_urls: list[str] = []
 for idx, data in enumerate(track_datas):
    if not data:
        padded_track_urls.append("")
        continue
    _, padded_url = await self.pad_track_for_transcription(
        data, idx, storage
    )
    padded_track_urls.append(padded_url)
 ```
 #### MODIFIED (lines 385-435):
 - Transcribe PADDED tracks instead of raw tracks
 - Removed all timestamp offset adjustment code
 - Just set speaker ID - timestamps already correct!
 ```python
 # NO OFFSET ADJUSTMENT NEEDED!
 # Timestamps are already correct because we transcribed padded tracks
 # Just set speaker ID
 for w in t.words:
    w.speaker = idx
 ```
 ## Why This Works
 1. **Stream metadata is authoritative**: Daily.co sets `start_time` in the WebM container
 2. **PyAV respects metadata**: `audio_stream.start_time * audio_stream.time_base` gives seconds
 3. **Padding before transcription**: Whisper sees continuous audio from time 0
 4. **Automatic alignment**: Word at 51s in padded track = 51s in recording
 ## Testing
 Process the test recording (daily-20251020193458) and verify:
 - Participant 0 words appear at ~2s
 - Participant 1 words appear at ~51s
 - No word interleaving
 - Correct chronological order
 ## Files
 - **Original**: `main_multitrack_pipeline.py`
 - **Fixed**: `main_multitrack_pipeline_fixed.py`
 - **Test data**: `/Users/firfi/work/clients/monadical/reflector/1760988935484-*.webm`
--- a/server/reflector/pipelines/main_file_pipeline.py
+++ b/server/reflector/pipelines/main_file_pipeline.py
@@ -7,28 +7,18 @@ Uses parallel processing for transcription, diarization, and waveform generation
 """
 import asyncio
 import uuid
 from pathlib import Path
 import av
 import structlog
-from celery import chain, shared_task
+from celery import shared_task
 from reflector.asynctask import asynctask
 from reflector.db.rooms import rooms_controller
 from reflector.db.transcripts import (
    SourceKind,
    Transcript,
    TranscriptStatus,
    transcripts_controller,
 )
 from reflector.logger import logger
-from reflector.pipelines.main_live_pipeline import (
+from reflector.pipelines.main_live_pipeline import PipelineMainBase, asynctask
    PipelineMainBase,
    broadcast_to_sockets,
    task_cleanup_consent,
    task_pipeline_post_to_zulip,
 )
 from reflector.processors import (
    AudioFileWriterProcessor,
    TranscriptFinalSummaryProcessor,
@@ -53,7 +43,6 @@ from reflector.processors.types import (
 )
 from reflector.settings import settings
 from reflector.storage import get_transcripts_storage
 from reflector.worker.webhook import send_transcript_webhook
 class EmptyPipeline:
@@ -94,27 +83,12 @@ class PipelineMainFile(PipelineMainBase):
                exc_info=result,
            )
    @broadcast_to_sockets
    async def set_status(self, transcript_id: str, status: TranscriptStatus):
        async with self.lock_transaction():
            return await transcripts_controller.set_status(transcript_id, status)
    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()
        # Clear transcript as we're going to regenerate everything
        async with self.transaction():
            await transcripts_controller.update(
                transcript,
                {
                    "events": [],
                    "topics": [],
                },
            )
        # Extract audio and write to transcript location
        audio_path = await self.extract_and_write_audio(file_path, transcript)
@@ -131,8 +105,6 @@ class PipelineMainFile(PipelineMainBase):
        self.logger.info("File pipeline complete")
        await self.set_status(transcript.id, "ended")
    async def extract_and_write_audio(
        self, file_path: Path, transcript: Transcript
    ) -> Path:
@@ -381,28 +353,6 @@ class PipelineMainFile(PipelineMainBase):
        await processor.flush()
@shared_task
@asynctask
 async def task_send_webhook_if_needed(*, transcript_id: str):
    """Send webhook if this is a room recording with webhook configured"""
    transcript = await transcripts_controller.get_by_id(transcript_id)
    if not transcript:
        return
    if transcript.source_kind == SourceKind.ROOM and transcript.room_id:
        room = await rooms_controller.get_by_id(transcript.room_id)
        if room and room.webhook_url:
            logger.info(
                "Dispatching webhook",
                transcript_id=transcript_id,
                room_id=room.id,
                webhook_url=room.webhook_url,
            )
            send_transcript_webhook.delay(
                transcript_id, room.id, event_id=uuid.uuid4().hex
            )
@shared_task
@asynctask
 async def task_pipeline_file_process(*, transcript_id: str):
@@ -412,28 +362,14 @@ async def task_pipeline_file_process(*, transcript_id: str):
    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)
-    try:
+    await pipeline.process(audio_file)
        await pipeline.set_status(transcript_id, "processing")
        # 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")
        await pipeline.process(audio_file)
    except Exception:
        await pipeline.set_status(transcript_id, "error")
        raise
    # Run post-processing chain: consent cleanup -> zulip -> webhook
    post_chain = chain(
        task_cleanup_consent.si(transcript_id=transcript_id),
        task_pipeline_post_to_zulip.si(transcript_id=transcript_id),
        task_send_webhook_if_needed.si(transcript_id=transcript_id),
    )
    post_chain.delay()
--- a/server/reflector/pipelines/main_live_pipeline.py
+++ b/server/reflector/pipelines/main_live_pipeline.py
@@ -22,7 +22,7 @@ from celery import chord, current_task, group, shared_task
 from pydantic import BaseModel
 from structlog import BoundLogger as Logger
-from reflector.asynctask import asynctask
+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
@@ -32,7 +32,6 @@ from reflector.db.transcripts import (
    TranscriptFinalLongSummary,
    TranscriptFinalShortSummary,
    TranscriptFinalTitle,
    TranscriptStatus,
    TranscriptText,
    TranscriptTopic,
    TranscriptWaveform,
@@ -41,9 +40,8 @@ from reflector.db.transcripts import (
 from reflector.logger import logger
 from reflector.pipelines.runner import PipelineMessage, PipelineRunner
 from reflector.processors import (
-    AudioChunkerAutoProcessor,
+    AudioChunkerProcessor,
    AudioDiarizationAutoProcessor,
    AudioDownscaleProcessor,
    AudioFileWriterProcessor,
    AudioMergeProcessor,
    AudioTranscriptAutoProcessor,
@@ -70,6 +68,29 @@ from reflector.zulip import (
 )
 def asynctask(f):
    @functools.wraps(f)
    def wrapper(*args, **kwargs):
        async def run_with_db():
            database = get_database()
            await database.connect()
            try:
                return await f(*args, **kwargs)
            finally:
                await database.disconnect()
        coro = run_with_db()
        try:
            loop = asyncio.get_running_loop()
        except RuntimeError:
            loop = None
        if loop and loop.is_running():
            return loop.run_until_complete(coro)
        return asyncio.run(coro)
    return wrapper
 def broadcast_to_sockets(func):
    """
    Decorator to broadcast transcript event to websockets
@@ -85,20 +106,6 @@ def broadcast_to_sockets(func):
            message=resp.model_dump(mode="json"),
        )
        transcript = await transcripts_controller.get_by_id(self.transcript_id)
        if transcript and transcript.user_id:
            # Emit only relevant events to the user room to avoid noisy updates.
            # Allowed: STATUS, FINAL_TITLE, DURATION. All are prefixed with TRANSCRIPT_
            allowed_user_events = {"STATUS", "FINAL_TITLE", "DURATION"}
            if resp.event in allowed_user_events:
                await self.ws_manager.send_json(
                    room_id=f"user:{transcript.user_id}",
                    message={
                        "event": f"TRANSCRIPT_{resp.event}",
                        "data": {"id": self.transcript_id, **resp.data},
                    },
                )
    return wrapper
@@ -179,16 +186,9 @@ class PipelineMainBase(PipelineRunner[PipelineMessage], Generic[PipelineMessage]
            for topic in topics
        ]
    @asynccontextmanager
    async def lock_transaction(self):
        # This lock is to prevent multiple processor starting adding
        # into event array at the same time
        async with self._lock:
            yield
    @asynccontextmanager
    async def transaction(self):
-        async with self.lock_transaction():
+        async with self._lock:
            async with transcripts_controller.transaction():
                yield
@@ -197,14 +197,14 @@ class PipelineMainBase(PipelineRunner[PipelineMessage], Generic[PipelineMessage]
        # if it's the first part, update the status of the transcript
        # but do not set the ended status yet.
        if isinstance(self, PipelineMainLive):
-            status_mapping: dict[str, TranscriptStatus] = {
+            status_mapping = {
                "started": "recording",
                "push": "recording",
                "flush": "processing",
                "error": "error",
            }
        elif isinstance(self, PipelineMainFinalSummaries):
-            status_mapping: dict[str, TranscriptStatus] = {
+            status_mapping = {
                "push": "processing",
                "flush": "processing",
                "error": "error",
@@ -220,8 +220,22 @@ class PipelineMainBase(PipelineRunner[PipelineMessage], Generic[PipelineMessage]
            return
        # when the status of the pipeline changes, update the transcript
-        async with self._lock:
+        async with self.transaction():
-            return await transcripts_controller.set_status(self.transcript_id, status)
+            transcript = await self.get_transcript()
            if status == transcript.status:
                return
            resp = await transcripts_controller.append_event(
                transcript=transcript,
                event="STATUS",
                data=StrValue(value=status),
            )
            await transcripts_controller.update(
                transcript,
                {
                    "status": status,
                },
            )
            return resp
    @broadcast_to_sockets
    async def on_transcript(self, data):
@@ -351,8 +365,7 @@ class PipelineMainLive(PipelineMainBase):
                path=transcript.audio_wav_filename,
                on_duration=self.on_duration,
            ),
-            AudioDownscaleProcessor(),
+            AudioChunkerProcessor(),
            AudioChunkerAutoProcessor(),
            AudioMergeProcessor(),
            AudioTranscriptAutoProcessor.as_threaded(),
            TranscriptLinerProcessor(),
@@ -779,7 +792,7 @@ def pipeline_post(*, transcript_id: str):
        chain_final_summaries,
    ) | task_pipeline_post_to_zulip.si(transcript_id=transcript_id)
-    return chain.delay()
+    chain.delay()
@get_transcript
--- a/server/reflector/pipelines/main_multitrack_pipeline.backup.py
+++ b/server/reflector/pipelines/main_multitrack_pipeline.backup.py
@@ -1,510 +0,0 @@
 import asyncio
 import io
 from fractions import Fraction
 import av
 import boto3
 import structlog
 from av.audio.resampler import AudioResampler
 from celery import chain, shared_task
 from reflector.asynctask import asynctask
 from reflector.db.transcripts import (
    TranscriptStatus,
    TranscriptText,
    transcripts_controller,
 )
 from reflector.logger import logger
 from reflector.pipelines.main_file_pipeline import task_send_webhook_if_needed
 from reflector.pipelines.main_live_pipeline import (
    PipelineMainBase,
    task_cleanup_consent,
    task_pipeline_post_to_zulip,
 )
 from reflector.processors import (
    AudioFileWriterProcessor,
    TranscriptFinalSummaryProcessor,
    TranscriptFinalTitleProcessor,
    TranscriptTopicDetectorProcessor,
 )
 from reflector.processors.file_transcript import FileTranscriptInput
 from reflector.processors.file_transcript_auto import FileTranscriptAutoProcessor
 from reflector.processors.types import TitleSummary
 from reflector.processors.types import (
    Transcript as TranscriptType,
 )
 from reflector.settings import settings
 from reflector.storage import get_transcripts_storage
 class EmptyPipeline:
    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 PipelineMainMultitrack(PipelineMainBase):
    """Process multiple participant tracks for a transcript without mixing audio."""
    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)
    async def mixdown_tracks(
        self,
        track_datas: list[bytes],
        writer: AudioFileWriterProcessor,
        offsets_seconds: list[float] | None = None,
    ) -> None:
        """
        Minimal multi-track mixdown using a PyAV filter graph (amix), no resampling.
        """
        # Discover target sample rate from first decodable frame
        target_sample_rate: int | None = None
        for data in track_datas:
            if not data:
                continue
            try:
                container = av.open(io.BytesIO(data))
                try:
                    for frame in container.decode(audio=0):
                        target_sample_rate = frame.sample_rate
                        break
                finally:
                    container.close()
            except Exception:
                continue
            if target_sample_rate:
                break
        if not target_sample_rate:
            self.logger.warning("Mixdown skipped - no decodable audio frames found")
            return
        # Build PyAV filter graph:
        # N abuffer (s32/stereo)
        #   -> optional adelay per input (for alignment)
        #   -> amix (s32)
        #   -> aformat(s16)
        #   -> sink
        graph = av.filter.Graph()
        inputs = []
        valid_track_datas = [d for d in track_datas if d]
        # Align offsets list with the filtered inputs (skip empties)
        input_offsets_seconds = None
        if offsets_seconds is not None:
            input_offsets_seconds = [
                offsets_seconds[i] for i, d in enumerate(track_datas) if d
            ]
        for idx, data in enumerate(valid_track_datas):
            args = (
                f"time_base=1/{target_sample_rate}:"
                f"sample_rate={target_sample_rate}:"
                f"sample_fmt=s32:"
                f"channel_layout=stereo"
            )
            in_ctx = graph.add("abuffer", args=args, name=f"in{idx}")
            inputs.append(in_ctx)
        if not inputs:
            self.logger.warning("Mixdown skipped - no valid inputs for graph")
            return
        mixer = graph.add("amix", args=f"inputs={len(inputs)}:normalize=0", name="mix")
        fmt = graph.add(
            "aformat",
            args=(
                f"sample_fmts=s32:channel_layouts=stereo:sample_rates={target_sample_rate}"
            ),
            name="fmt",
        )
        sink = graph.add("abuffersink", name="out")
        # Optional per-input delay before mixing
        delays_ms: list[int] = []
        if input_offsets_seconds is not None:
            base = min(input_offsets_seconds) if input_offsets_seconds else 0.0
            delays_ms = [
                max(0, int(round((o - base) * 1000))) for o in input_offsets_seconds
            ]
        else:
            delays_ms = [0 for _ in inputs]
        for idx, in_ctx in enumerate(inputs):
            delay_ms = delays_ms[idx] if idx < len(delays_ms) else 0
            if delay_ms > 0:
                # adelay requires one value per channel; use same for stereo
                adelay = graph.add(
                    "adelay",
                    args=f"delays={delay_ms}|{delay_ms}:all=1",
                    name=f"delay{idx}",
                )
                in_ctx.link_to(adelay)
                adelay.link_to(mixer, 0, idx)
            else:
                in_ctx.link_to(mixer, 0, idx)
        mixer.link_to(fmt)
        fmt.link_to(sink)
        graph.configure()
        # Open containers for decoding
        containers = []
        for i, d in enumerate(valid_track_datas):
            try:
                c = av.open(io.BytesIO(d))
                containers.append(c)
            except Exception as e:
                self.logger.warning(
                    "Mixdown: failed to open container", input=i, error=str(e)
                )
                containers.append(None)
        # Filter out Nones for decoders
        containers = [c for c in containers if c is not None]
        decoders = [c.decode(audio=0) for c in containers]
        active = [True] * len(decoders)
        # Per-input resamplers to enforce s32/stereo at the same rate (no resample of rate)
        resamplers = [
            AudioResampler(format="s32", layout="stereo", rate=target_sample_rate)
            for _ in decoders
        ]
        try:
            # Round-robin feed frames into graph, pull mixed frames as they become available
            while any(active):
                for i, (dec, is_active) in enumerate(zip(decoders, active)):
                    if not is_active:
                        continue
                    try:
                        frame = next(dec)
                    except StopIteration:
                        active[i] = False
                        continue
                    # Enforce same sample rate; convert format/layout to s16/stereo (no resample)
                    if frame.sample_rate != target_sample_rate:
                        # Skip frames with differing rate
                        continue
                    out_frames = resamplers[i].resample(frame) or []
                    for rf in out_frames:
                        rf.sample_rate = target_sample_rate
                        rf.time_base = Fraction(1, target_sample_rate)
                        inputs[i].push(rf)
                    # Drain available mixed frames
                    while True:
                        try:
                            mixed = sink.pull()
                        except Exception:
                            break
                        mixed.sample_rate = target_sample_rate
                        mixed.time_base = Fraction(1, target_sample_rate)
                        await writer.push(mixed)
            # Signal EOF to inputs and drain remaining
            for in_ctx in inputs:
                in_ctx.push(None)
            while True:
                try:
                    mixed = sink.pull()
                except Exception:
                    break
                mixed.sample_rate = target_sample_rate
                mixed.time_base = Fraction(1, target_sample_rate)
                await writer.push(mixed)
        finally:
            for c in containers:
                c.close()
    async def set_status(self, transcript_id: str, status: TranscriptStatus):
        async with self.lock_transaction():
            return await transcripts_controller.set_status(transcript_id, status)
    async def process(self, bucket_name: str, track_keys: list[str]):
        transcript = await self.get_transcript()
        s3 = boto3.client(
            "s3",
            region_name=settings.RECORDING_STORAGE_AWS_REGION,
            aws_access_key_id=settings.RECORDING_STORAGE_AWS_ACCESS_KEY_ID,
            aws_secret_access_key=settings.RECORDING_STORAGE_AWS_SECRET_ACCESS_KEY,
        )
        storage = get_transcripts_storage()
        # Pre-download bytes for all tracks for mixing and transcription
        track_datas: list[bytes] = []
        for key in track_keys:
            try:
                obj = s3.get_object(Bucket=bucket_name, Key=key)
                track_datas.append(obj["Body"].read())
            except Exception as e:
                self.logger.warning(
                    "Skipping track - cannot read S3 object", key=key, error=str(e)
                )
                track_datas.append(b"")
        # Extract offsets from Daily.co filename timestamps
        # Format: {rec_start_ts}-{uuid}-{media_type}-{track_start_ts}.{ext}
        # Example: 1760988935484-uuid-cam-audio-1760988935922
        import re
        offsets_seconds: list[float] = []
        recording_start_ts: int | None = None
        for key in track_keys:
            # Parse Daily.co raw-tracks filename pattern
            match = re.search(r"(\d+)-([0-9a-f-]{36})-(cam-audio)-(\d+)", key)
            if not match:
                self.logger.warning(
                    "Track key doesn't match Daily.co pattern, using 0.0 offset",
                    key=key,
                )
                offsets_seconds.append(0.0)
                continue
            rec_start_ts = int(match.group(1))
            track_start_ts = int(match.group(4))
            # Validate all tracks belong to same recording
            if recording_start_ts is None:
                recording_start_ts = rec_start_ts
            elif rec_start_ts != recording_start_ts:
                self.logger.error(
                    "Track belongs to different recording",
                    key=key,
                    expected_start=recording_start_ts,
                    got_start=rec_start_ts,
                )
                offsets_seconds.append(0.0)
                continue
            # Calculate offset in seconds
            offset_ms = track_start_ts - rec_start_ts
            offset_s = offset_ms / 1000.0
            self.logger.info(
                "Parsed track offset from filename",
                key=key,
                recording_start=rec_start_ts,
                track_start=track_start_ts,
                offset_seconds=offset_s,
            )
            offsets_seconds.append(max(0.0, offset_s))
        # Mixdown all available tracks into transcript.audio_mp3_filename, preserving sample rate
        try:
            mp3_writer = AudioFileWriterProcessor(
                path=str(transcript.audio_mp3_filename)
            )
            await self.mixdown_tracks(track_datas, mp3_writer, offsets_seconds)
            await mp3_writer.flush()
        except Exception as e:
            self.logger.error("Mixdown failed", error=str(e))
        speaker_transcripts: list[TranscriptType] = []
        for idx, key in enumerate(track_keys):
            ext = ".mp4"
            try:
                obj = s3.get_object(Bucket=bucket_name, Key=key)
                data = obj["Body"].read()
            except Exception as e:
                self.logger.error(
                    "Skipping track - cannot read S3 object", key=key, error=str(e)
                )
                continue
            storage_path = f"file_pipeline/{transcript.id}/tracks/track_{idx}{ext}"
            try:
                await storage.put_file(storage_path, data)
                audio_url = await storage.get_file_url(storage_path)
            except Exception as e:
                self.logger.error(
                    "Skipping track - cannot upload to storage", key=key, error=str(e)
                )
                continue
            try:
                t = await self.transcribe_file(audio_url, transcript.source_language)
            except Exception as e:
                self.logger.error(
                    "Transcription via default backend failed, trying local whisper",
                    key=key,
                    url=audio_url,
                    error=str(e),
                )
                try:
                    fallback = FileTranscriptAutoProcessor(name="whisper")
                    result = None
                    async def capture_result(r):
                        nonlocal result
                        result = r
                    fallback.on(capture_result)
                    await fallback.push(
                        FileTranscriptInput(
                            audio_url=audio_url, language=transcript.source_language
                        )
                    )
                    await fallback.flush()
                    if not result:
                        raise Exception("No transcript captured in fallback")
                    t = result
                except Exception as e2:
                    self.logger.error(
                        "Skipping track - transcription failed after fallback",
                        key=key,
                        url=audio_url,
                        error=str(e2),
                    )
                    continue
            if not t.words:
                continue
            # Shift word timestamps by the track's offset so all are relative to 00:00
            track_offset = offsets_seconds[idx] if idx < len(offsets_seconds) else 0.0
            for w in t.words:
                try:
                    if hasattr(w, "start") and w.start is not None:
                        w.start = float(w.start) + track_offset
                    if hasattr(w, "end") and w.end is not None:
                        w.end = float(w.end) + track_offset
                except Exception:
                    pass
                w.speaker = idx
            speaker_transcripts.append(t)
        if not speaker_transcripts:
            raise Exception("No valid track transcriptions")
        merged_words = []
        for t in speaker_transcripts:
            merged_words.extend(t.words)
        merged_words.sort(key=lambda w: w.start)
        merged_transcript = TranscriptType(words=merged_words, translation=None)
        await transcripts_controller.append_event(
            transcript,
            event="TRANSCRIPT",
            data=TranscriptText(
                text=merged_transcript.text, translation=merged_transcript.translation
            ),
        )
        topics = await self.detect_topics(merged_transcript, transcript.target_language)
        await asyncio.gather(
            self.generate_title(topics),
            self.generate_summaries(topics),
            return_exceptions=False,
        )
        await self.set_status(transcript.id, "ended")
    async def transcribe_file(self, audio_url: str, language: str) -> TranscriptType:
        processor = FileTranscriptAutoProcessor()
        input_data = FileTranscriptInput(audio_url=audio_url, language=language)
        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 detect_topics(
        self, transcript: TranscriptType, target_language: str
    ) -> list[TitleSummary]:
        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]):
        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]):
        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_multitrack_process(
    *, transcript_id: str, bucket_name: str, track_keys: list[str]
 ):
    pipeline = PipelineMainMultitrack(transcript_id=transcript_id)
    try:
        await pipeline.set_status(transcript_id, "processing")
        await pipeline.process(bucket_name, track_keys)
    except Exception:
        await pipeline.set_status(transcript_id, "error")
        raise
    post_chain = chain(
        task_cleanup_consent.si(transcript_id=transcript_id),
        task_pipeline_post_to_zulip.si(transcript_id=transcript_id),
        task_send_webhook_if_needed.si(transcript_id=transcript_id),
    )
    post_chain.delay()
--- a/server/reflector/pipelines/main_multitrack_pipeline.py
+++ b/server/reflector/pipelines/main_multitrack_pipeline.py
@@ -1,654 +0,0 @@
 import asyncio
 import io
 from fractions import Fraction
 import av
 import boto3
 import structlog
 from av.audio.resampler import AudioResampler
 from celery import chain, shared_task
 from reflector.asynctask import asynctask
 from reflector.db.transcripts import (
    TranscriptStatus,
    TranscriptWaveform,
    transcripts_controller,
 )
 from reflector.logger import logger
 from reflector.pipelines.main_file_pipeline import task_send_webhook_if_needed
 from reflector.pipelines.main_live_pipeline import (
    PipelineMainBase,
    broadcast_to_sockets,
    task_cleanup_consent,
    task_pipeline_post_to_zulip,
 )
 from reflector.processors import (
    AudioFileWriterProcessor,
    TranscriptFinalSummaryProcessor,
    TranscriptFinalTitleProcessor,
    TranscriptTopicDetectorProcessor,
 )
 from reflector.processors.audio_waveform_processor import AudioWaveformProcessor
 from reflector.processors.file_transcript import FileTranscriptInput
 from reflector.processors.file_transcript_auto import FileTranscriptAutoProcessor
 from reflector.processors.types import TitleSummary
 from reflector.processors.types import (
    Transcript as TranscriptType,
 )
 from reflector.settings import settings
 from reflector.storage import get_transcripts_storage
 class EmptyPipeline:
    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 PipelineMainMultitrack(PipelineMainBase):
    """Process multiple participant tracks for a transcript without mixing audio."""
    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)
    async def pad_track_for_transcription(
        self,
        track_data: bytes,
        track_idx: int,
        storage,
    ) -> tuple[bytes, str]:
        """
        Pad a single track with silence based on stream metadata start_time.
        This ensures Whisper timestamps will be relative to recording start.
        Uses ffmpeg subprocess approach proven to work with python-raw-tracks-align.
        Returns: (padded_data, storage_url)
        """
        import json
        import math
        import subprocess
        import tempfile
        if not track_data:
            return b"", ""
        transcript = await self.get_transcript()
        # Create temp files for ffmpeg processing
        with tempfile.NamedTemporaryFile(suffix=".webm", delete=False) as input_file:
            input_file.write(track_data)
            input_file_path = input_file.name
        output_file_path = input_file_path.replace(".webm", "_padded.webm")
        try:
            # Get stream metadata using ffprobe
            ffprobe_cmd = [
                "ffprobe",
                "-v",
                "error",
                "-show_entries",
                "stream=start_time",
                "-of",
                "json",
                input_file_path,
            ]
            result = subprocess.run(
                ffprobe_cmd, capture_output=True, text=True, check=True
            )
            metadata = json.loads(result.stdout)
            # Extract start_time from stream metadata
            start_time_seconds = 0.0
            if metadata.get("streams") and len(metadata["streams"]) > 0:
                start_time_str = metadata["streams"][0].get("start_time", "0")
                start_time_seconds = float(start_time_str)
            self.logger.info(
                f"Track {track_idx} stream metadata: start_time={start_time_seconds:.3f}s",
                track_idx=track_idx,
            )
            # If no padding needed, use original
            if start_time_seconds <= 0:
                storage_path = f"file_pipeline/{transcript.id}/tracks/original_track_{track_idx}.webm"
                await storage.put_file(storage_path, track_data)
                url = await storage.get_file_url(storage_path)
                return track_data, url
            # Calculate delay in milliseconds
            delay_ms = math.floor(start_time_seconds * 1000)
            # Run ffmpeg to pad the audio while maintaining WebM/Opus format for Modal compatibility
            # ffmpeg quirk: aresample needs to come before adelay in the filter chain
            ffmpeg_cmd = [
                "ffmpeg",
                "-hide_banner",
                "-loglevel",
                "error",
                "-y",  # overwrite output
                "-i",
                input_file_path,
                "-af",
                f"aresample=async=1,adelay={delay_ms}:all=true",
                "-c:a",
                "libopus",  # Keep Opus codec for Modal compatibility
                "-b:a",
                "128k",  # Standard bitrate for Opus
                output_file_path,
            ]
            self.logger.info(
                f"Padding track {track_idx} with {delay_ms}ms delay using ffmpeg",
                track_idx=track_idx,
                delay_ms=delay_ms,
                command=" ".join(ffmpeg_cmd),
            )
            result = subprocess.run(ffmpeg_cmd, capture_output=True, text=True)
            if result.returncode != 0:
                self.logger.error(
                    f"ffmpeg padding failed for track {track_idx}",
                    track_idx=track_idx,
                    stderr=result.stderr,
                    returncode=result.returncode,
                )
                raise Exception(f"ffmpeg padding failed: {result.stderr}")
            # Read the padded output
            with open(output_file_path, "rb") as f:
                padded_data = f.read()
            # Store padded track
            storage_path = (
                f"file_pipeline/{transcript.id}/tracks/padded_track_{track_idx}.webm"
            )
            await storage.put_file(storage_path, padded_data)
            padded_url = await storage.get_file_url(storage_path)
            self.logger.info(
                f"Successfully padded track {track_idx} with {start_time_seconds:.3f}s offset, stored at {storage_path}",
                track_idx=track_idx,
                delay_ms=delay_ms,
                padded_url=padded_url,
                padded_size=len(padded_data),
            )
            return padded_data, padded_url
        finally:
            # Clean up temp files
            import os
            try:
                os.unlink(input_file_path)
            except:
                pass
            try:
                os.unlink(output_file_path)
            except:
                pass
    async def mixdown_tracks(
        self,
        track_datas: list[bytes],
        writer: AudioFileWriterProcessor,
        offsets_seconds: list[float] | None = None,
    ) -> None:
        """
        Minimal multi-track mixdown using a PyAV filter graph (amix), no resampling.
        """
        # Discover target sample rate from first decodable frame
        target_sample_rate: int | None = None
        for data in track_datas:
            if not data:
                continue
            try:
                container = av.open(io.BytesIO(data))
                try:
                    for frame in container.decode(audio=0):
                        target_sample_rate = frame.sample_rate
                        break
                finally:
                    container.close()
            except Exception:
                continue
            if target_sample_rate:
                break
        if not target_sample_rate:
            self.logger.warning("Mixdown skipped - no decodable audio frames found")
            return
        # Build PyAV filter graph:
        # N abuffer (s32/stereo)
        #   -> optional adelay per input (for alignment)
        #   -> amix (s32)
        #   -> aformat(s16)
        #   -> sink
        graph = av.filter.Graph()
        inputs = []
        valid_track_datas = [d for d in track_datas if d]
        # Align offsets list with the filtered inputs (skip empties)
        input_offsets_seconds = None
        if offsets_seconds is not None:
            input_offsets_seconds = [
                offsets_seconds[i] for i, d in enumerate(track_datas) if d
            ]
        for idx, data in enumerate(valid_track_datas):
            args = (
                f"time_base=1/{target_sample_rate}:"
                f"sample_rate={target_sample_rate}:"
                f"sample_fmt=s32:"
                f"channel_layout=stereo"
            )
            in_ctx = graph.add("abuffer", args=args, name=f"in{idx}")
            inputs.append(in_ctx)
        if not inputs:
            self.logger.warning("Mixdown skipped - no valid inputs for graph")
            return
        mixer = graph.add("amix", args=f"inputs={len(inputs)}:normalize=0", name="mix")
        fmt = graph.add(
            "aformat",
            args=(
                f"sample_fmts=s32:channel_layouts=stereo:sample_rates={target_sample_rate}"
            ),
            name="fmt",
        )
        sink = graph.add("abuffersink", name="out")
        # Optional per-input delay before mixing
        delays_ms: list[int] = []
        if input_offsets_seconds is not None:
            base = min(input_offsets_seconds) if input_offsets_seconds else 0.0
            delays_ms = [
                max(0, int(round((o - base) * 1000))) for o in input_offsets_seconds
            ]
        else:
            delays_ms = [0 for _ in inputs]
        for idx, in_ctx in enumerate(inputs):
            delay_ms = delays_ms[idx] if idx < len(delays_ms) else 0
            if delay_ms > 0:
                # adelay requires one value per channel; use same for stereo
                adelay = graph.add(
                    "adelay",
                    args=f"delays={delay_ms}|{delay_ms}:all=1",
                    name=f"delay{idx}",
                )
                in_ctx.link_to(adelay)
                adelay.link_to(mixer, 0, idx)
            else:
                in_ctx.link_to(mixer, 0, idx)
        mixer.link_to(fmt)
        fmt.link_to(sink)
        graph.configure()
        # Open containers for decoding
        containers = []
        for i, d in enumerate(valid_track_datas):
            try:
                c = av.open(io.BytesIO(d))
                containers.append(c)
            except Exception as e:
                self.logger.warning(
                    "Mixdown: failed to open container", input=i, error=str(e)
                )
                containers.append(None)
        # Filter out Nones for decoders
        containers = [c for c in containers if c is not None]
        decoders = [c.decode(audio=0) for c in containers]
        active = [True] * len(decoders)
        # Per-input resamplers to enforce s32/stereo at the same rate (no resample of rate)
        resamplers = [
            AudioResampler(format="s32", layout="stereo", rate=target_sample_rate)
            for _ in decoders
        ]
        try:
            # Round-robin feed frames into graph, pull mixed frames as they become available
            while any(active):
                for i, (dec, is_active) in enumerate(zip(decoders, active)):
                    if not is_active:
                        continue
                    try:
                        frame = next(dec)
                    except StopIteration:
                        active[i] = False
                        continue
                    # Enforce same sample rate; convert format/layout to s16/stereo (no resample)
                    if frame.sample_rate != target_sample_rate:
                        # Skip frames with differing rate
                        continue
                    out_frames = resamplers[i].resample(frame) or []
                    for rf in out_frames:
                        rf.sample_rate = target_sample_rate
                        rf.time_base = Fraction(1, target_sample_rate)
                        inputs[i].push(rf)
                    # Drain available mixed frames
                    while True:
                        try:
                            mixed = sink.pull()
                        except Exception:
                            break
                        mixed.sample_rate = target_sample_rate
                        mixed.time_base = Fraction(1, target_sample_rate)
                        await writer.push(mixed)
            # Signal EOF to inputs and drain remaining
            for in_ctx in inputs:
                in_ctx.push(None)
            while True:
                try:
                    mixed = sink.pull()
                except Exception:
                    break
                mixed.sample_rate = target_sample_rate
                mixed.time_base = Fraction(1, target_sample_rate)
                await writer.push(mixed)
        finally:
            for c in containers:
                c.close()
    @broadcast_to_sockets
    async def set_status(self, transcript_id: str, status: TranscriptStatus):
        async with self.lock_transaction():
            return await transcripts_controller.set_status(transcript_id, status)
    async def on_waveform(self, data):
        async with self.transaction():
            waveform = TranscriptWaveform(waveform=data)
            transcript = await self.get_transcript()
            return await transcripts_controller.append_event(
                transcript=transcript, event="WAVEFORM", data=waveform
            )
    async def process(self, bucket_name: str, track_keys: list[str]):
        transcript = await self.get_transcript()
        s3 = boto3.client(
            "s3",
            region_name=settings.RECORDING_STORAGE_AWS_REGION,
            aws_access_key_id=settings.RECORDING_STORAGE_AWS_ACCESS_KEY_ID,
            aws_secret_access_key=settings.RECORDING_STORAGE_AWS_SECRET_ACCESS_KEY,
        )
        storage = get_transcripts_storage()
        # Pre-download bytes for all tracks for mixing and transcription
        track_datas: list[bytes] = []
        for key in track_keys:
            try:
                obj = s3.get_object(Bucket=bucket_name, Key=key)
                track_datas.append(obj["Body"].read())
            except Exception as e:
                self.logger.warning(
                    "Skipping track - cannot read S3 object", key=key, error=str(e)
                )
                track_datas.append(b"")
        # PAD TRACKS FIRST - this creates full-length tracks with correct timeline
        padded_track_datas: list[bytes] = []
        padded_track_urls: list[str] = []
        for idx, data in enumerate(track_datas):
            if not data:
                padded_track_datas.append(b"")
                padded_track_urls.append("")
                continue
            padded_data, padded_url = await self.pad_track_for_transcription(
                data, idx, storage
            )
            padded_track_datas.append(padded_data)
            padded_track_urls.append(padded_url)
            self.logger.info(f"Padded track {idx} for transcription: {padded_url}")
        # Mixdown PADDED tracks (already aligned with timeline) into transcript.audio_mp3_filename
        try:
            # Ensure data directory exists
            transcript.data_path.mkdir(parents=True, exist_ok=True)
            mp3_writer = AudioFileWriterProcessor(
                path=str(transcript.audio_mp3_filename),
                on_duration=self.on_duration,
            )
            # Use PADDED tracks with NO additional offsets (already aligned by padding)
            await self.mixdown_tracks(
                padded_track_datas, mp3_writer, offsets_seconds=None
            )
            await mp3_writer.flush()
            # Upload the mixed audio to S3 for web playback
            if transcript.audio_mp3_filename.exists():
                mp3_data = transcript.audio_mp3_filename.read_bytes()
                storage_path = f"{transcript.id}/audio.mp3"
                await storage.put_file(storage_path, mp3_data)
                mp3_url = await storage.get_file_url(storage_path)
                # Update transcript to indicate audio is in storage
                await transcripts_controller.update(
                    transcript, {"audio_location": "storage"}
                )
                self.logger.info(
                    f"Uploaded mixed audio to storage",
                    storage_path=storage_path,
                    size=len(mp3_data),
                    url=mp3_url,
                )
            else:
                self.logger.warning("Mixdown file does not exist after processing")
        except Exception as e:
            self.logger.error("Mixdown failed", error=str(e), exc_info=True)
        # Generate waveform from the mixed audio file
        if transcript.audio_mp3_filename.exists():
            try:
                self.logger.info("Generating waveform from mixed audio")
                waveform_processor = AudioWaveformProcessor(
                    audio_path=transcript.audio_mp3_filename,
                    waveform_path=transcript.audio_waveform_filename,
                    on_waveform=self.on_waveform,
                )
                waveform_processor.set_pipeline(self.empty_pipeline)
                await waveform_processor.flush()
                self.logger.info("Waveform generated successfully")
            except Exception as e:
                self.logger.error(
                    "Waveform generation failed", error=str(e), exc_info=True
                )
        # Transcribe PADDED tracks - timestamps will be automatically correct!
        speaker_transcripts: list[TranscriptType] = []
        for idx, padded_url in enumerate(padded_track_urls):
            if not padded_url:
                continue
            try:
                # Transcribe the PADDED track
                t = await self.transcribe_file(padded_url, transcript.source_language)
            except Exception as e:
                self.logger.error(
                    "Transcription via default backend failed, trying local whisper",
                    track_idx=idx,
                    url=padded_url,
                    error=str(e),
                )
                try:
                    fallback = FileTranscriptAutoProcessor(name="whisper")
                    result = None
                    async def capture_result(r):
                        nonlocal result
                        result = r
                    fallback.on(capture_result)
                    await fallback.push(
                        FileTranscriptInput(
                            audio_url=padded_url, language=transcript.source_language
                        )
                    )
                    await fallback.flush()
                    if not result:
                        raise Exception("No transcript captured in fallback")
                    t = result
                except Exception as e2:
                    self.logger.error(
                        "Skipping track - transcription failed after fallback",
                        track_idx=idx,
                        url=padded_url,
                        error=str(e2),
                    )
                    continue
            if not t.words:
                continue
            # NO OFFSET ADJUSTMENT NEEDED!
            # Timestamps are already correct because we transcribed padded tracks
            # Just set speaker ID
            for w in t.words:
                w.speaker = idx
            speaker_transcripts.append(t)
            self.logger.info(
                f"Track {idx} transcribed successfully with {len(t.words)} words",
                track_idx=idx,
            )
        if not speaker_transcripts:
            raise Exception("No valid track transcriptions")
        # Merge all words and sort by timestamp
        merged_words = []
        for t in speaker_transcripts:
            merged_words.extend(t.words)
        merged_words.sort(
            key=lambda w: w.start if hasattr(w, "start") and w.start is not None else 0
        )
        merged_transcript = TranscriptType(words=merged_words, translation=None)
        # Emit TRANSCRIPT event through the shared handler (persists and broadcasts)
        await self.on_transcript(merged_transcript)
        topics = await self.detect_topics(merged_transcript, transcript.target_language)
        await asyncio.gather(
            self.generate_title(topics),
            self.generate_summaries(topics),
            return_exceptions=False,
        )
        await self.set_status(transcript.id, "ended")
    async def transcribe_file(self, audio_url: str, language: str) -> TranscriptType:
        processor = FileTranscriptAutoProcessor()
        input_data = FileTranscriptInput(audio_url=audio_url, language=language)
        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 detect_topics(
        self, transcript: TranscriptType, target_language: str
    ) -> list[TitleSummary]:
        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]):
        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]):
        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_multitrack_process(
    *, transcript_id: str, bucket_name: str, track_keys: list[str]
 ):
    pipeline = PipelineMainMultitrack(transcript_id=transcript_id)
    try:
        await pipeline.set_status(transcript_id, "processing")
        await pipeline.process(bucket_name, track_keys)
    except Exception:
        await pipeline.set_status(transcript_id, "error")
        raise
    post_chain = chain(
        task_cleanup_consent.si(transcript_id=transcript_id),
        task_pipeline_post_to_zulip.si(transcript_id=transcript_id),
        task_send_webhook_if_needed.si(transcript_id=transcript_id),
    )
    post_chain.delay()
--- a/server/reflector/pipelines/main_multitrack_pipeline_fixed.py
+++ b/server/reflector/pipelines/main_multitrack_pipeline_fixed.py
@@ -1,629 +0,0 @@
 import asyncio
 import io
 from fractions import Fraction
 import av
 import boto3
 import structlog
 from av.audio.resampler import AudioResampler
 from celery import chain, shared_task
 from reflector.asynctask import asynctask
 from reflector.db.transcripts import (
    TranscriptStatus,
    TranscriptText,
    transcripts_controller,
 )
 from reflector.logger import logger
 from reflector.pipelines.main_file_pipeline import task_send_webhook_if_needed
 from reflector.pipelines.main_live_pipeline import (
    PipelineMainBase,
    task_cleanup_consent,
    task_pipeline_post_to_zulip,
 )
 from reflector.processors import (
    AudioFileWriterProcessor,
    TranscriptFinalSummaryProcessor,
    TranscriptFinalTitleProcessor,
    TranscriptTopicDetectorProcessor,
 )
 from reflector.processors.file_transcript import FileTranscriptInput
 from reflector.processors.file_transcript_auto import FileTranscriptAutoProcessor
 from reflector.processors.types import TitleSummary
 from reflector.processors.types import (
    Transcript as TranscriptType,
 )
 from reflector.settings import settings
 from reflector.storage import get_transcripts_storage
 class EmptyPipeline:
    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 PipelineMainMultitrack(PipelineMainBase):
    """Process multiple participant tracks for a transcript without mixing audio."""
    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)
    async def pad_track_for_transcription(
        self,
        track_data: bytes,
        track_idx: int,
        storage,
    ) -> tuple[bytes, str]:
        """
        Pad a single track with silence based on stream metadata start_time.
        This ensures Whisper timestamps will be relative to recording start.
        Returns: (padded_data, storage_url)
        """
        if not track_data:
            return b"", ""
        transcript = await self.get_transcript()
        # Get stream metadata start_time using PyAV
        container = av.open(io.BytesIO(track_data))
        try:
            audio_stream = container.streams.audio[0]
            # Extract start_time from stream metadata
            if (
                audio_stream.start_time is not None
                and audio_stream.time_base is not None
            ):
                start_time_seconds = float(
                    audio_stream.start_time * audio_stream.time_base
                )
            else:
                start_time_seconds = 0.0
            sample_rate = audio_stream.sample_rate
            codec_name = audio_stream.codec.name
        finally:
            container.close()
        self.logger.info(
            f"Track {track_idx} stream metadata: start_time={start_time_seconds:.3f}s, sample_rate={sample_rate}",
            track_idx=track_idx,
        )
        # If no padding needed, use original
        if start_time_seconds <= 0:
            storage_path = (
                f"file_pipeline/{transcript.id}/tracks/original_track_{track_idx}.webm"
            )
            await storage.put_file(storage_path, track_data)
            url = await storage.get_file_url(storage_path)
            return track_data, url
        # Create PyAV filter graph for padding
        graph = av.filter.Graph()
        # Input buffer
        in_args = (
            f"time_base=1/{sample_rate}:"
            f"sample_rate={sample_rate}:"
            f"sample_fmt=s16:"
            f"channel_layout=stereo"
        )
        input_buffer = graph.add("abuffer", args=in_args, name="in")
        # Add delay filter for padding
        delay_ms = int(start_time_seconds * 1000)
        delay_filter = graph.add(
            "adelay", args=f"delays={delay_ms}|{delay_ms}:all=1", name="delay"
        )
        # Output sink
        sink = graph.add("abuffersink", name="out")
        # Link filters
        input_buffer.link_to(delay_filter)
        delay_filter.link_to(sink)
        graph.configure()
        # Process audio through filter
        output_bytes = io.BytesIO()
        output_container = av.open(output_bytes, "w", format="webm")
        output_stream = output_container.add_stream("libopus", rate=sample_rate)
        output_stream.channels = 2
        # Reopen input for processing
        input_container = av.open(io.BytesIO(track_data))
        resampler = AudioResampler(format="s16", layout="stereo", rate=sample_rate)
        try:
            # Process frames
            for frame in input_container.decode(audio=0):
                # Resample to match filter requirements
                resampled_frames = resampler.resample(frame)
                for resampled_frame in resampled_frames:
                    resampled_frame.pts = frame.pts
                    resampled_frame.time_base = Fraction(1, sample_rate)
                    input_buffer.push(resampled_frame)
                    # Pull from filter and encode
                    while True:
                        try:
                            out_frame = sink.pull()
                            out_frame.pts = out_frame.pts if out_frame.pts else 0
                            out_frame.time_base = Fraction(1, sample_rate)
                            for packet in output_stream.encode(out_frame):
                                output_container.mux(packet)
                        except av.BlockingIOError:
                            break
            # Flush
            input_buffer.push(None)
            while True:
                try:
                    out_frame = sink.pull()
                    for packet in output_stream.encode(out_frame):
                        output_container.mux(packet)
                except (av.BlockingIOError, av.EOFError):
                    break
            # Flush encoder
            for packet in output_stream.encode(None):
                output_container.mux(packet)
        finally:
            input_container.close()
            output_container.close()
        padded_data = output_bytes.getvalue()
        # Store padded track
        storage_path = (
            f"file_pipeline/{transcript.id}/tracks/padded_track_{track_idx}.webm"
        )
        await storage.put_file(storage_path, padded_data)
        padded_url = await storage.get_file_url(storage_path)
        self.logger.info(
            f"Padded track {track_idx} with {start_time_seconds:.3f}s offset, stored at {storage_path}",
            track_idx=track_idx,
            delay_ms=delay_ms,
            padded_url=padded_url,
        )
        return padded_data, padded_url
    async def mixdown_tracks(
        self,
        track_datas: list[bytes],
        writer: AudioFileWriterProcessor,
        offsets_seconds: list[float] | None = None,
    ) -> None:
        """
        Minimal multi-track mixdown using a PyAV filter graph (amix), no resampling.
        """
        # Discover target sample rate from first decodable frame
        target_sample_rate: int | None = None
        for data in track_datas:
            if not data:
                continue
            try:
                container = av.open(io.BytesIO(data))
                try:
                    for frame in container.decode(audio=0):
                        target_sample_rate = frame.sample_rate
                        break
                finally:
                    container.close()
            except Exception:
                continue
            if target_sample_rate:
                break
        if not target_sample_rate:
            self.logger.warning("Mixdown skipped - no decodable audio frames found")
            return
        # Build PyAV filter graph:
        # N abuffer (s32/stereo)
        #   -> optional adelay per input (for alignment)
        #   -> amix (s32)
        #   -> aformat(s16)
        #   -> sink
        graph = av.filter.Graph()
        inputs = []
        valid_track_datas = [d for d in track_datas if d]
        # Align offsets list with the filtered inputs (skip empties)
        input_offsets_seconds = None
        if offsets_seconds is not None:
            input_offsets_seconds = [
                offsets_seconds[i] for i, d in enumerate(track_datas) if d
            ]
        for idx, data in enumerate(valid_track_datas):
            args = (
                f"time_base=1/{target_sample_rate}:"
                f"sample_rate={target_sample_rate}:"
                f"sample_fmt=s32:"
                f"channel_layout=stereo"
            )
            in_ctx = graph.add("abuffer", args=args, name=f"in{idx}")
            inputs.append(in_ctx)
        if not inputs:
            self.logger.warning("Mixdown skipped - no valid inputs for graph")
            return
        mixer = graph.add("amix", args=f"inputs={len(inputs)}:normalize=0", name="mix")
        fmt = graph.add(
            "aformat",
            args=(
                f"sample_fmts=s32:channel_layouts=stereo:sample_rates={target_sample_rate}"
            ),
            name="fmt",
        )
        sink = graph.add("abuffersink", name="out")
        # Optional per-input delay before mixing
        delays_ms: list[int] = []
        if input_offsets_seconds is not None:
            base = min(input_offsets_seconds) if input_offsets_seconds else 0.0
            delays_ms = [
                max(0, int(round((o - base) * 1000))) for o in input_offsets_seconds
            ]
        else:
            delays_ms = [0 for _ in inputs]
        for idx, in_ctx in enumerate(inputs):
            delay_ms = delays_ms[idx] if idx < len(delays_ms) else 0
            if delay_ms > 0:
                # adelay requires one value per channel; use same for stereo
                adelay = graph.add(
                    "adelay",
                    args=f"delays={delay_ms}|{delay_ms}:all=1",
                    name=f"delay{idx}",
                )
                in_ctx.link_to(adelay)
                adelay.link_to(mixer, 0, idx)
            else:
                in_ctx.link_to(mixer, 0, idx)
        mixer.link_to(fmt)
        fmt.link_to(sink)
        graph.configure()
        # Open containers for decoding
        containers = []
        for i, d in enumerate(valid_track_datas):
            try:
                c = av.open(io.BytesIO(d))
                containers.append(c)
            except Exception as e:
                self.logger.warning(
                    "Mixdown: failed to open container", input=i, error=str(e)
                )
                containers.append(None)
        # Filter out Nones for decoders
        containers = [c for c in containers if c is not None]
        decoders = [c.decode(audio=0) for c in containers]
        active = [True] * len(decoders)
        # Per-input resamplers to enforce s32/stereo at the same rate (no resample of rate)
        resamplers = [
            AudioResampler(format="s32", layout="stereo", rate=target_sample_rate)
            for _ in decoders
        ]
        try:
            # Round-robin feed frames into graph, pull mixed frames as they become available
            while any(active):
                for i, (dec, is_active) in enumerate(zip(decoders, active)):
                    if not is_active:
                        continue
                    try:
                        frame = next(dec)
                    except StopIteration:
                        active[i] = False
                        continue
                    # Enforce same sample rate; convert format/layout to s16/stereo (no resample)
                    if frame.sample_rate != target_sample_rate:
                        # Skip frames with differing rate
                        continue
                    out_frames = resamplers[i].resample(frame) or []
                    for rf in out_frames:
                        rf.sample_rate = target_sample_rate
                        rf.time_base = Fraction(1, target_sample_rate)
                        inputs[i].push(rf)
                    # Drain available mixed frames
                    while True:
                        try:
                            mixed = sink.pull()
                        except Exception:
                            break
                        mixed.sample_rate = target_sample_rate
                        mixed.time_base = Fraction(1, target_sample_rate)
                        await writer.push(mixed)
            # Signal EOF to inputs and drain remaining
            for in_ctx in inputs:
                in_ctx.push(None)
            while True:
                try:
                    mixed = sink.pull()
                except Exception:
                    break
                mixed.sample_rate = target_sample_rate
                mixed.time_base = Fraction(1, target_sample_rate)
                await writer.push(mixed)
        finally:
            for c in containers:
                c.close()
    async def set_status(self, transcript_id: str, status: TranscriptStatus):
        async with self.lock_transaction():
            return await transcripts_controller.set_status(transcript_id, status)
    async def process(self, bucket_name: str, track_keys: list[str]):
        transcript = await self.get_transcript()
        s3 = boto3.client(
            "s3",
            region_name=settings.RECORDING_STORAGE_AWS_REGION,
            aws_access_key_id=settings.RECORDING_STORAGE_AWS_ACCESS_KEY_ID,
            aws_secret_access_key=settings.RECORDING_STORAGE_AWS_SECRET_ACCESS_KEY,
        )
        storage = get_transcripts_storage()
        # Pre-download bytes for all tracks for mixing and transcription
        track_datas: list[bytes] = []
        for key in track_keys:
            try:
                obj = s3.get_object(Bucket=bucket_name, Key=key)
                track_datas.append(obj["Body"].read())
            except Exception as e:
                self.logger.warning(
                    "Skipping track - cannot read S3 object", key=key, error=str(e)
                )
                track_datas.append(b"")
        # REMOVED: Filename offset extraction - not needed anymore!
        # We use stream metadata start_time for padding instead
        # Get stream metadata start_times for mixing (still useful for mixdown)
        stream_start_times: list[float] = []
        for data in track_datas:
            if not data:
                stream_start_times.append(0.0)
                continue
            container = av.open(io.BytesIO(data))
            try:
                audio_stream = container.streams.audio[0]
                if (
                    audio_stream.start_time is not None
                    and audio_stream.time_base is not None
                ):
                    start_time = float(audio_stream.start_time * audio_stream.time_base)
                else:
                    start_time = 0.0
                stream_start_times.append(start_time)
            finally:
                container.close()
        # Mixdown all available tracks into transcript.audio_mp3_filename, using stream metadata offsets
        try:
            mp3_writer = AudioFileWriterProcessor(
                path=str(transcript.audio_mp3_filename)
            )
            await self.mixdown_tracks(track_datas, mp3_writer, stream_start_times)
            await mp3_writer.flush()
        except Exception as e:
            self.logger.error("Mixdown failed", error=str(e))
        # PAD TRACKS BEFORE TRANSCRIPTION - THIS IS THE KEY FIX!
        padded_track_urls: list[str] = []
        for idx, data in enumerate(track_datas):
            if not data:
                padded_track_urls.append("")
                continue
            _, padded_url = await self.pad_track_for_transcription(data, idx, storage)
            padded_track_urls.append(padded_url)
            self.logger.info(f"Padded track {idx} for transcription: {padded_url}")
        # Transcribe PADDED tracks - timestamps will be automatically correct!
        speaker_transcripts: list[TranscriptType] = []
        for idx, padded_url in enumerate(padded_track_urls):
            if not padded_url:
                continue
            try:
                # Transcribe the PADDED track
                t = await self.transcribe_file(padded_url, transcript.source_language)
            except Exception as e:
                self.logger.error(
                    "Transcription via default backend failed, trying local whisper",
                    track_idx=idx,
                    url=padded_url,
                    error=str(e),
                )
                try:
                    fallback = FileTranscriptAutoProcessor(name="whisper")
                    result = None
                    async def capture_result(r):
                        nonlocal result
                        result = r
                    fallback.on(capture_result)
                    await fallback.push(
                        FileTranscriptInput(
                            audio_url=padded_url, language=transcript.source_language
                        )
                    )
                    await fallback.flush()
                    if not result:
                        raise Exception("No transcript captured in fallback")
                    t = result
                except Exception as e2:
                    self.logger.error(
                        "Skipping track - transcription failed after fallback",
                        track_idx=idx,
                        url=padded_url,
                        error=str(e2),
                    )
                    continue
            if not t.words:
                continue
            # NO OFFSET ADJUSTMENT NEEDED!
            # Timestamps are already correct because we transcribed padded tracks
            # Just set speaker ID
            for w in t.words:
                w.speaker = idx
            speaker_transcripts.append(t)
            self.logger.info(
                f"Track {idx} transcribed successfully with {len(t.words)} words",
                track_idx=idx,
            )
        if not speaker_transcripts:
            raise Exception("No valid track transcriptions")
        # Merge all words and sort by timestamp
        merged_words = []
        for t in speaker_transcripts:
            merged_words.extend(t.words)
        merged_words.sort(
            key=lambda w: w.start if hasattr(w, "start") and w.start is not None else 0
        )
        merged_transcript = TranscriptType(words=merged_words, translation=None)
        await transcripts_controller.append_event(
            transcript,
            event="TRANSCRIPT",
            data=TranscriptText(
                text=merged_transcript.text, translation=merged_transcript.translation
            ),
        )
        topics = await self.detect_topics(merged_transcript, transcript.target_language)
        await asyncio.gather(
            self.generate_title(topics),
            self.generate_summaries(topics),
            return_exceptions=False,
        )
        await self.set_status(transcript.id, "ended")
    async def transcribe_file(self, audio_url: str, language: str) -> TranscriptType:
        processor = FileTranscriptAutoProcessor()
        input_data = FileTranscriptInput(audio_url=audio_url, language=language)
        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 detect_topics(
        self, transcript: TranscriptType, target_language: str
    ) -> list[TitleSummary]:
        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]):
        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]):
        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_multitrack_process(
    *, transcript_id: str, bucket_name: str, track_keys: list[str]
 ):
    pipeline = PipelineMainMultitrack(transcript_id=transcript_id)
    try:
        await pipeline.set_status(transcript_id, "processing")
        await pipeline.process(bucket_name, track_keys)
    except Exception:
        await pipeline.set_status(transcript_id, "error")
        raise
    post_chain = chain(
        task_cleanup_consent.si(transcript_id=transcript_id),
        task_pipeline_post_to_zulip.si(transcript_id=transcript_id),
        task_send_webhook_if_needed.si(transcript_id=transcript_id),
    )
    post_chain.delay()
--- a/server/reflector/platform_types.py
+++ b/server/reflector/platform_types.py
@@ -1,9 +0,0 @@
 """Platform type definitions.
 This module exists solely to define the Platform literal type without any imports,
 preventing circular import issues when used across the codebase.
 """
 from typing import Literal
 Platform = Literal["whereby", "daily"]
--- a/server/reflector/processors/init.py
+++ b/server/reflector/processors/init.py
@@ -1,7 +1,5 @@
 from .audio_chunker import AudioChunkerProcessor  # noqa: F401
 from .audio_chunker_auto import AudioChunkerAutoProcessor  # noqa: F401
 from .audio_diarization_auto import AudioDiarizationAutoProcessor  # noqa: F401
 from .audio_downscale import AudioDownscaleProcessor  # noqa: F401
 from .audio_file_writer import AudioFileWriterProcessor  # noqa: F401
 from .audio_merge import AudioMergeProcessor  # noqa: F401
 from .audio_transcript import AudioTranscriptProcessor  # noqa: F401
--- a/server/reflector/processors/audio_chunker.py
+++ b/server/reflector/processors/audio_chunker.py
@@ -1,78 +1,340 @@
 from typing import Optional
 import av
-from prometheus_client import Counter, Histogram
+import numpy as np
 import torch
 from silero_vad import VADIterator, load_silero_vad
 from reflector.processors.base import Processor
 class AudioChunkerProcessor(Processor):
    """
-    Base class for assembling audio frames into chunks
+    Assemble audio frames into chunks with VAD-based speech detection
    """
    INPUT_TYPE = av.AudioFrame
    OUTPUT_TYPE = list[av.AudioFrame]
-    m_chunk = Histogram(
+    def __init__(
-        "audio_chunker",
+        self,
-        "Time spent in AudioChunker.chunk",
+        block_frames=256,
-        ["backend"],
+        max_frames=1024,
-    )
+        vad_threshold=0.5,
-    m_chunk_call = Counter(
+        use_onnx=False,
-        "audio_chunker_call",
+        min_frames=2,
-        "Number of calls to AudioChunker.chunk",
+    ):
-        ["backend"],
+        super().__init__()
    )
    m_chunk_success = Counter(
        "audio_chunker_success",
        "Number of successful calls to AudioChunker.chunk",
        ["backend"],
    )
    m_chunk_failure = Counter(
        "audio_chunker_failure",
        "Number of failed calls to AudioChunker.chunk",
        ["backend"],
    )
    def __init__(self, *args, **kwargs):
        name = self.__class__.__name__
        self.m_chunk = self.m_chunk.labels(name)
        self.m_chunk_call = self.m_chunk_call.labels(name)
        self.m_chunk_success = self.m_chunk_success.labels(name)
        self.m_chunk_failure = self.m_chunk_failure.labels(name)
        super().__init__(*args, **kwargs)
        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):
-        """Process incoming audio frame"""
+        self.frames.append(data)
-        # Validate audio format on first frame
+        # print("timestamp", data.pts * data.time_base * 1000)
-        if len(self.frames) == 0:
+
-            if data.sample_rate != 16000 or len(data.layout.channels) != 1:
+        # Check for speech segments every 32 frames (~1 second)
-                raise ValueError(
+        if len(self.frames) >= 32 and len(self.frames) % 32 == 0:
-                    f"AudioChunkerProcessor expects 16kHz mono audio, got {data.sample_rate}Hz "
+            await self._process_block()
-                    f"with {len(data.layout.channels)} channel(s). "
+
-                    f"Use AudioDownscaleProcessor before this processor."
+        # 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)"
                )
-        try:
+    async def _process_block(self):
-            self.m_chunk_call.inc()
+        # Need at least 32 frames for VAD detection (~1 second)
-            with self.m_chunk.time():
+        if len(self.frames) < 32 or self.vad_iterator is None:
-                result = await self._chunk(data)
+            return
            self.m_chunk_success.inc()
            if result:
                await self.emit(result)
        except Exception:
            self.m_chunk_failure.inc()
            raise
-    async def _chunk(self, data: av.AudioFrame) -> Optional[list[av.AudioFrame]]:
+        # Processing block with current buffer size
-        """
+        # print(f"Processing block: {len(self.frames)} frames in buffer")
-        Process audio frame and return chunk when ready.
+
-        Subclasses should implement their chunking logic here.
+        try:
-        """
+            # Convert frames to numpy array for VAD
-        raise NotImplementedError
+            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):
-        """Flush any remaining frames when processing ends"""
+        frames = self.frames[:]
-        raise NotImplementedError
+        self.frames = []
        if 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_chunker_auto.py
+++ b/server/reflector/processors/audio_chunker_auto.py
@@ -1,32 +0,0 @@
 import importlib
 from reflector.processors.audio_chunker import AudioChunkerProcessor
 from reflector.settings import settings
 class AudioChunkerAutoProcessor(AudioChunkerProcessor):
    _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.AUDIO_CHUNKER_BACKEND
        if name not in cls._registry:
            module_name = f"reflector.processors.audio_chunker_{name}"
            importlib.import_module(module_name)
        # gather specific configuration for the processor
        # search `AUDIO_CHUNKER_BACKEND_XXX_YYY`, push to constructor as `backend_xxx_yyy`
        config = {}
        name_upper = name.upper()
        settings_prefix = "AUDIO_CHUNKER_"
        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/audio_chunker_frames.py
+++ b/server/reflector/processors/audio_chunker_frames.py
@@ -1,34 +0,0 @@
 from typing import Optional
 import av
 from reflector.processors.audio_chunker import AudioChunkerProcessor
 from reflector.processors.audio_chunker_auto import AudioChunkerAutoProcessor
 class AudioChunkerFramesProcessor(AudioChunkerProcessor):
    """
    Simple frame-based audio chunker that emits chunks after a fixed number of frames
    """
    def __init__(self, max_frames=256, **kwargs):
        super().__init__(**kwargs)
        self.max_frames = max_frames
    async def _chunk(self, data: av.AudioFrame) -> Optional[list[av.AudioFrame]]:
        self.frames.append(data)
        if len(self.frames) >= self.max_frames:
            frames_to_emit = self.frames[:]
            self.frames = []
            return frames_to_emit
        return None
    async def _flush(self):
        frames = self.frames[:]
        self.frames = []
        if frames:
            await self.emit(frames)
 AudioChunkerAutoProcessor.register("frames", AudioChunkerFramesProcessor)
--- a/server/reflector/processors/audio_chunker_silero.py
+++ b/server/reflector/processors/audio_chunker_silero.py
@@ -1,298 +0,0 @@
 from typing import Optional
 import av
 import numpy as np
 import torch
 from silero_vad import VADIterator, load_silero_vad
 from reflector.processors.audio_chunker import AudioChunkerProcessor
 from reflector.processors.audio_chunker_auto import AudioChunkerAutoProcessor
 class AudioChunkerSileroProcessor(AudioChunkerProcessor):
    """
    Assemble audio frames into chunks with VAD-based speech detection using Silero VAD
    """
    def __init__(
        self,
        block_frames=256,
        max_frames=1024,
        use_onnx=True,
        min_frames=2,
        **kwargs,
    ):
        super().__init__(**kwargs)
        self.block_frames = block_frames
        self.max_frames = max_frames
        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 _chunk(self, data: av.AudioFrame) -> Optional[list[av.AudioFrame]]:
        """Process audio frame and return chunk when ready"""
        self.frames.append(data)
        # Check for speech segments every 32 frames (~1 second)
        if len(self.frames) >= 32 and len(self.frames) % 32 == 0:
            return await self._process_block()
        # Safety fallback - emit if we hit max frames
        elif len(self.frames) >= self.max_frames:
            self.logger.warning(
                f"AudioChunkerSileroProcessor: 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:
                return frames_to_emit
            else:
                self.logger.debug(
                    f"Ignoring fallback segment with {len(frames_to_emit)} frames "
                    f"(< {self.min_frames} minimum)"
                )
        return None
    async def _process_block(self) -> Optional[list[av.AudioFrame]]:
        # Need at least 32 frames for VAD detection (~1 second)
        if len(self.frames) < 32 or self.vad_iterator is None:
            return None
        # 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:
                    return frames_to_emit
                else:
                    self.logger.debug(
                        f"Ignoring conversion-failed segment with {len(frames_to_emit)} frames "
                        f"(< {self.min_frames} minimum)"
                    )
                return None
            # 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 None
            # 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:
                return 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:
                    return frames_to_emit
                else:
                    self.logger.debug(
                        f"Ignoring exception-fallback segment with {len(frames_to_emit)} frames "
                        f"(< {self.min_frames} minimum)"
                    )
        return None
    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:
            audio_data = []
            for frame in frames:
                frame_array = frame.to_ndarray()
                if 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)
            # 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 _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
                frame_index = speech_end // 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:
            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)"
                )
 AudioChunkerAutoProcessor.register("silero", AudioChunkerSileroProcessor)
--- a/server/reflector/processors/audio_downscale.py
+++ b/server/reflector/processors/audio_downscale.py
@@ -1,60 +0,0 @@
 from typing import Optional
 import av
 from av.audio.resampler import AudioResampler
 from reflector.processors.base import Processor
 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 AudioDownscaleProcessor(Processor):
    """
    Downscale audio frames to 16kHz mono format
    """
    INPUT_TYPE = av.AudioFrame
    OUTPUT_TYPE = av.AudioFrame
    def __init__(self, target_rate: int = 16000, target_layout: str = "mono", **kwargs):
        super().__init__(**kwargs)
        self.target_rate = target_rate
        self.target_layout = target_layout
        self.resampler: Optional[AudioResampler] = None
        self.needs_resampling: Optional[bool] = None
    async def _push(self, data: av.AudioFrame):
        if self.needs_resampling is None:
            self.needs_resampling = (
                data.sample_rate != self.target_rate
                or data.layout.name != self.target_layout
            )
            if self.needs_resampling:
                self.resampler = AudioResampler(
                    format="s16", layout=self.target_layout, rate=self.target_rate
                )
        if not self.needs_resampling or not self.resampler:
            await self.emit(data)
            return
        resampled_frames = self.resampler.resample(copy_frame(data))
        for resampled_frame in resampled_frames:
            await self.emit(resampled_frame)
    async def _flush(self):
        if self.needs_resampling and self.resampler:
            final_frames = self.resampler.resample(None)
            for frame in final_frames:
                await self.emit(frame)
--- 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,8 +29,9 @@ class AudioMergeProcessor(Processor):
    INPUT_TYPE = list[av.AudioFrame]
    OUTPUT_TYPE = AudioFile
-    def __init__(self, **kwargs):
+    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:
@@ -25,27 +39,72 @@ class AudioMergeProcessor(Processor):
        # get audio information from first frame
        frame = data[0]
-        output_channels = len(frame.layout.channels)
+        original_channels = len(frame.layout.channels)
-        output_sample_rate = frame.sample_rate
+        original_sample_rate = frame.sample_rate
-        output_sample_width = frame.format.bytes
+        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()
-        # Use PyAV to write frames
+        if needs_processing:
-        out_container = av.open(fd, "w", format="wav")
+            # Process with PyAV resampler
-        out_stream = out_container.add_stream("pcm_s16le", rate=output_sample_rate)
+            out_container = av.open(fd, "w", format="wav")
-        out_stream.layout = frame.layout.name
+            out_stream = out_container.add_stream("pcm_s16le", rate=16000)
            out_stream.layout = "mono"
-        for frame in data:
+            # Create resampler if needed
-            for packet in out_stream.encode(frame):
+            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)
            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
-        # Flush the encoder
+            for frame in data:
-        for packet in out_stream.encode(None):
+                for packet in out_stream.encode(frame):
-            out_container.mux(packet)
+                    out_container.mux(packet)
-        out_container.close()
+
            for packet in out_stream.encode(None):
                out_container.mux(packet)
            out_container.close()
        fd.seek(0)
--- 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
@@ -22,9 +25,7 @@ from reflector.settings import settings
 class AudioTranscriptModalProcessor(AudioTranscriptProcessor):
    def __init__(
-        self,
+        self, modal_api_key: str | None = None, batch_enabled: bool = True, **kwargs
        modal_api_key: str | None = None,
        **kwargs,
    ):
        super().__init__()
        if not settings.TRANSCRIPT_URL:
@@ -34,6 +35,126 @@ class AudioTranscriptModalProcessor(AudioTranscriptProcessor):
        self.transcript_url = settings.TRANSCRIPT_URL + "/v1"
        self.timeout = settings.TRANSCRIPT_TIMEOUT
        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(
@@ -66,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/file_diarization_modal.py
+++ b/server/reflector/processors/file_diarization_modal.py
@@ -47,7 +47,6 @@ class FileDiarizationModalProcessor(FileDiarizationProcessor):
                    "audio_file_url": data.audio_url,
                    "timestamp": 0,
                },
                follow_redirects=True,
            )
            response.raise_for_status()
            diarization_data = response.json()["diarization"]
--- a/server/reflector/processors/file_transcript_modal.py
+++ b/server/reflector/processors/file_transcript_modal.py
@@ -54,7 +54,6 @@ class FileTranscriptModalProcessor(FileTranscriptProcessor):
                    "language": data.language,
                    "batch": True,
                },
                follow_redirects=True,
            )
            response.raise_for_status()
            result = response.json()
@@ -68,9 +67,6 @@ class FileTranscriptModalProcessor(FileTranscriptProcessor):
            for word_info in result.get("words", [])
        ]
        # words come not in order
        words.sort(key=lambda w: w.start)
        return Transcript(words=words)
--- a/server/reflector/processors/transcript_topic_detector.py
+++ b/server/reflector/processors/transcript_topic_detector.py
@@ -1,6 +1,6 @@
 from textwrap import dedent
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, Field
 from reflector.llm import LLM
 from reflector.processors.base import Processor
@@ -34,14 +34,8 @@ TOPIC_PROMPT = dedent(
 class TopicResponse(BaseModel):
    """Structured response for topic detection"""
-    model_config = ConfigDict(populate_by_name=True)
+    title: str = Field(description="A descriptive title for the topic being discussed")
-
+    summary: str = Field(description="A concise 1-2 sentence summary of the discussion")
    title: str = Field(
        description="A descriptive title for the topic being discussed", alias="Title"
    )
    summary: str = Field(
        description="A concise 1-2 sentence summary of the discussion", alias="Summary"
    )
 class TranscriptTopicDetectorProcessor(Processor):
--- a/server/reflector/processors/types.py
+++ b/server/reflector/processors/types.py
@@ -4,8 +4,11 @@ import tempfile
 from pathlib import Path
 from typing import Annotated, TypedDict
 from profanityfilter import ProfanityFilter
 from pydantic import BaseModel, Field, PrivateAttr
 from reflector.redis_cache import redis_cache
 class DiarizationSegment(TypedDict):
    """Type definition for diarization segment containing speaker information"""
@@ -17,6 +20,9 @@ class DiarizationSegment(TypedDict):
 PUNC_RE = re.compile(r"[.;:?!…]")
 profanity_filter = ProfanityFilter()
 profanity_filter.set_censor("*")
 class AudioFile(BaseModel):
    name: str
@@ -118,11 +124,21 @@ def words_to_segments(words: list[Word]) -> list[TranscriptSegment]:
 class Transcript(BaseModel):
    translation: str | None = None
-    words: list[Word] = []
+    words: list[Word] = None
    @property
    def raw_text(self):
        # Uncensored text
        return "".join([word.text for word in self.words])
    @redis_cache(prefix="profanity", duration=3600 * 24 * 7)
    def _get_censored_text(self, text: str):
        return profanity_filter.censor(text).strip()
    @property
    def text(self):
-        return "".join([word.text for word in self.words])
+        # Censored text
        return self._get_censored_text(self.raw_text)
    @property
    def human_timestamp(self):
@@ -154,6 +170,12 @@ class Transcript(BaseModel):
            word.start += offset
            word.end += offset
    def clone(self):
        words = [
            Word(text=word.text, start=word.start, end=word.end) for word in self.words
        ]
        return Transcript(text=self.text, translation=self.translation, words=words)
    def as_segments(self) -> list[TranscriptSegment]:
        return words_to_segments(self.words)
--- a/server/reflector/redis_cache.py
+++ b/server/reflector/redis_cache.py
@@ -1,17 +1,10 @@
 import asyncio
 import functools
 import json
 from typing import Optional
 import redis
 import redis.asyncio as redis_async
 import structlog
 from redis.exceptions import LockError
 from reflector.settings import settings
 logger = structlog.get_logger(__name__)
 redis_clients = {}
@@ -28,12 +21,6 @@ def get_redis_client(db=0):
    return redis_clients[db]
 async def get_async_redis_client(db: int = 0):
    return await redis_async.from_url(
        f"redis://{settings.REDIS_HOST}:{settings.REDIS_PORT}/{db}"
    )
 def redis_cache(prefix="cache", duration=3600, db=settings.REDIS_CACHE_DB, argidx=1):
    """
    Cache the result of a function in Redis.
@@ -62,87 +49,3 @@ def redis_cache(prefix="cache", duration=3600, db=settings.REDIS_CACHE_DB, argid
        return wrapper
    return decorator
 class RedisAsyncLock:
    def __init__(
        self,
        key: str,
        timeout: int = 120,
        extend_interval: int = 30,
        skip_if_locked: bool = False,
        blocking: bool = True,
        blocking_timeout: Optional[float] = None,
    ):
        self.key = f"async_lock:{key}"
        self.timeout = timeout
        self.extend_interval = extend_interval
        self.skip_if_locked = skip_if_locked
        self.blocking = blocking
        self.blocking_timeout = blocking_timeout
        self._lock = None
        self._redis = None
        self._extend_task = None
        self._acquired = False
    async def _extend_lock_periodically(self):
        while True:
            try:
                await asyncio.sleep(self.extend_interval)
                if self._lock:
                    await self._lock.extend(self.timeout, replace_ttl=True)
                    logger.debug("Extended lock", key=self.key)
            except LockError:
                logger.warning("Failed to extend lock", key=self.key)
                break
            except asyncio.CancelledError:
                break
            except Exception as e:
                logger.error("Error extending lock", key=self.key, error=str(e))
                break
    async def __aenter__(self):
        self._redis = await get_async_redis_client()
        self._lock = self._redis.lock(
            self.key,
            timeout=self.timeout,
            blocking=self.blocking,
            blocking_timeout=self.blocking_timeout,
        )
        self._acquired = await self._lock.acquire()
        if not self._acquired:
            if self.skip_if_locked:
                logger.warning(
                    "Lock already acquired by another process, skipping", key=self.key
                )
                return self
            else:
                raise LockError(f"Failed to acquire lock: {self.key}")
        self._extend_task = asyncio.create_task(self._extend_lock_periodically())
        logger.info("Acquired lock", key=self.key)
        return self
    async def __aexit__(self, exc_type, exc_val, exc_tb):
        if self._extend_task:
            self._extend_task.cancel()
            try:
                await self._extend_task
            except asyncio.CancelledError:
                pass
        if self._acquired and self._lock:
            try:
                await self._lock.release()
                logger.info("Released lock", key=self.key)
            except LockError:
                logger.debug("Lock already released or expired", key=self.key)
        if self._redis:
            await self._redis.aclose()
    @property
    def acquired(self) -> bool:
        return self._acquired
--- a/server/reflector/services/ics_sync.py
+++ b/server/reflector/services/ics_sync.py
@@ -1,408 +0,0 @@
 """
 ICS Calendar Synchronization Service
 This module provides services for fetching, parsing, and synchronizing ICS (iCalendar)
 calendar feeds with room booking data in the database.
 Key Components:
 - ICSFetchService: Handles HTTP fetching and parsing of ICS calendar data
 - ICSSyncService: Manages the synchronization process between ICS feeds and database
 Example Usage:
    # Sync a room's calendar
    room = Room(id="room1", name="conference-room", ics_url="https://cal.example.com/room.ics")
    result = await ics_sync_service.sync_room_calendar(room)
    # Result structure:
    {
        "status": "success",  # success|unchanged|error|skipped
        "hash": "abc123...",  # MD5 hash of ICS content
        "events_found": 5,    # Events matching this room
        "total_events": 12,   # Total events in calendar within time window
        "events_created": 2,  # New events added to database
        "events_updated": 3,  # Existing events modified
        "events_deleted": 1   # Events soft-deleted (no longer in calendar)
    }
 Event Matching:
    Events are matched to rooms by checking if the room's full URL appears in the
    event's LOCATION or DESCRIPTION fields. Only events within a 25-hour window
    (1 hour ago to 24 hours from now) are processed.
 Input: ICS calendar URL (e.g., "https://calendar.google.com/calendar/ical/...")
 Output: EventData objects with structured calendar information:
    {
        "ics_uid": "event123@google.com",
        "title": "Team Meeting",
        "description": "Weekly sync meeting",
        "location": "https://meet.company.com/conference-room",
        "start_time": datetime(2024, 1, 15, 14, 0, tzinfo=UTC),
        "end_time": datetime(2024, 1, 15, 15, 0, tzinfo=UTC),
        "attendees": [
            {"email": "user@company.com", "name": "John Doe", "role": "ORGANIZER"},
            {"email": "attendee@company.com", "name": "Jane Smith", "status": "ACCEPTED"}
        ],
        "ics_raw_data": "BEGIN:VEVENT\nUID:event123@google.com\n..."
    }
 """
 import hashlib
 from datetime import date, datetime, timedelta, timezone
 from enum import Enum
 from typing import TypedDict
 import httpx
 import pytz
 import structlog
 from icalendar import Calendar, Event
 from reflector.db.calendar_events import CalendarEvent, calendar_events_controller
 from reflector.db.rooms import Room, rooms_controller
 from reflector.redis_cache import RedisAsyncLock
 from reflector.settings import settings
 logger = structlog.get_logger()
 EVENT_WINDOW_DELTA_START = timedelta(hours=-1)
 EVENT_WINDOW_DELTA_END = timedelta(hours=24)
 class SyncStatus(str, Enum):
    SUCCESS = "success"
    UNCHANGED = "unchanged"
    ERROR = "error"
    SKIPPED = "skipped"
 class AttendeeData(TypedDict, total=False):
    email: str | None
    name: str | None
    status: str | None
    role: str | None
 class EventData(TypedDict):
    ics_uid: str
    title: str | None
    description: str | None
    location: str | None
    start_time: datetime
    end_time: datetime
    attendees: list[AttendeeData]
    ics_raw_data: str
 class SyncStats(TypedDict):
    events_created: int
    events_updated: int
    events_deleted: int
 class SyncResultBase(TypedDict):
    status: SyncStatus
 class SyncResult(SyncResultBase, total=False):
    hash: str | None
    events_found: int
    total_events: int
    events_created: int
    events_updated: int
    events_deleted: int
    error: str | None
    reason: str | None
 class ICSFetchService:
    def __init__(self):
        self.client = httpx.AsyncClient(
            timeout=30.0, headers={"User-Agent": "Reflector/1.0"}
        )
    async def fetch_ics(self, url: str) -> str:
        response = await self.client.get(url)
        response.raise_for_status()
        return response.text
    def parse_ics(self, ics_content: str) -> Calendar:
        return Calendar.from_ical(ics_content)
    def extract_room_events(
        self, calendar: Calendar, room_name: str, room_url: str
    ) -> tuple[list[EventData], int]:
        events = []
        total_events = 0
        now = datetime.now(timezone.utc)
        window_start = now + EVENT_WINDOW_DELTA_START
        window_end = now + EVENT_WINDOW_DELTA_END
        for component in calendar.walk():
            if component.name != "VEVENT":
                continue
            status = component.get("STATUS", "").upper()
            if status == "CANCELLED":
                continue
            # Count total non-cancelled events in the time window
            event_data = self._parse_event(component)
            if event_data and window_start <= event_data["start_time"] <= window_end:
                total_events += 1
                # Check if event matches this room
                if self._event_matches_room(component, room_name, room_url):
                    events.append(event_data)
        return events, total_events
    def _event_matches_room(self, event: Event, room_name: str, room_url: str) -> bool:
        location = str(event.get("LOCATION", ""))
        description = str(event.get("DESCRIPTION", ""))
        # Only match full room URL
        # XXX leaved here as a patterns, to later be extended with tinyurl or such too
        patterns = [
            room_url,
        ]
        # Check location and description for patterns
        text_to_check = f"{location} {description}".lower()
        for pattern in patterns:
            if pattern.lower() in text_to_check:
                return True
        return False
    def _parse_event(self, event: Event) -> EventData | None:
        uid = str(event.get("UID", ""))
        summary = str(event.get("SUMMARY", ""))
        description = str(event.get("DESCRIPTION", ""))
        location = str(event.get("LOCATION", ""))
        dtstart = event.get("DTSTART")
        dtend = event.get("DTEND")
        if not dtstart:
            return None
        # Convert fields
        start_time = self._normalize_datetime(
            dtstart.dt if hasattr(dtstart, "dt") else dtstart
        )
        end_time = (
            self._normalize_datetime(dtend.dt if hasattr(dtend, "dt") else dtend)
            if dtend
            else start_time + timedelta(hours=1)
        )
        attendees = self._parse_attendees(event)
        # Get raw event data for storage
        raw_data = event.to_ical().decode("utf-8")
        return {
            "ics_uid": uid,
            "title": summary,
            "description": description,
            "location": location,
            "start_time": start_time,
            "end_time": end_time,
            "attendees": attendees,
            "ics_raw_data": raw_data,
        }
    def _normalize_datetime(self, dt) -> datetime:
        # Ensure datetime is with timezone, if not, assume UTC
        if isinstance(dt, date) and not isinstance(dt, datetime):
            dt = datetime.combine(dt, datetime.min.time())
            dt = pytz.UTC.localize(dt)
        elif isinstance(dt, datetime):
            if dt.tzinfo is None:
                dt = pytz.UTC.localize(dt)
            else:
                dt = dt.astimezone(pytz.UTC)
        return dt
    def _parse_attendees(self, event: Event) -> list[AttendeeData]:
        # Extracts attendee information from both ATTENDEE and ORGANIZER properties.
        # Handles malformed comma-separated email addresses in single ATTENDEE fields
        # by splitting them into separate attendee entries. Returns a list of attendee
        # data including email, name, status, and role information.
        final_attendees = []
        attendees = event.get("ATTENDEE", [])
        if not isinstance(attendees, list):
            attendees = [attendees]
        for att in attendees:
            email_str = str(att).replace("mailto:", "") if att else None
            # Handle malformed comma-separated email addresses in a single ATTENDEE field
            if email_str and "," in email_str:
                # Split comma-separated emails and create separate attendee entries
                email_parts = [email.strip() for email in email_str.split(",")]
                for email in email_parts:
                    if email and "@" in email:
                        clean_email = email.replace("MAILTO:", "").replace(
                            "mailto:", ""
                        )
                        att_data: AttendeeData = {
                            "email": clean_email,
                            "name": att.params.get("CN")
                            if hasattr(att, "params") and email == email_parts[0]
                            else None,
                            "status": att.params.get("PARTSTAT")
                            if hasattr(att, "params") and email == email_parts[0]
                            else None,
                            "role": att.params.get("ROLE")
                            if hasattr(att, "params") and email == email_parts[0]
                            else None,
                        }
                        final_attendees.append(att_data)
            else:
                # Normal single attendee
                att_data: AttendeeData = {
                    "email": email_str,
                    "name": att.params.get("CN") if hasattr(att, "params") else None,
                    "status": att.params.get("PARTSTAT")
                    if hasattr(att, "params")
                    else None,
                    "role": att.params.get("ROLE") if hasattr(att, "params") else None,
                }
                final_attendees.append(att_data)
        # Add organizer
        organizer = event.get("ORGANIZER")
        if organizer:
            org_email = (
                str(organizer).replace("mailto:", "").replace("MAILTO:", "")
                if organizer
                else None
            )
            org_data: AttendeeData = {
                "email": org_email,
                "name": organizer.params.get("CN")
                if hasattr(organizer, "params")
                else None,
                "role": "ORGANIZER",
            }
            final_attendees.append(org_data)
        return final_attendees
 class ICSSyncService:
    def __init__(self):
        self.fetch_service = ICSFetchService()
    async def sync_room_calendar(self, room: Room) -> SyncResult:
        async with RedisAsyncLock(
            f"ics_sync_room:{room.id}", skip_if_locked=True
        ) as lock:
            if not lock.acquired:
                logger.warning("ICS sync already in progress for room", room_id=room.id)
                return {
                    "status": SyncStatus.SKIPPED,
                    "reason": "Sync already in progress",
                }
            return await self._sync_room_calendar(room)
    async def _sync_room_calendar(self, room: Room) -> SyncResult:
        if not room.ics_enabled or not room.ics_url:
            return {"status": SyncStatus.SKIPPED, "reason": "ICS not configured"}
        try:
            if not self._should_sync(room):
                return {"status": SyncStatus.SKIPPED, "reason": "Not time to sync yet"}
            ics_content = await self.fetch_service.fetch_ics(room.ics_url)
            calendar = self.fetch_service.parse_ics(ics_content)
            content_hash = hashlib.md5(ics_content.encode()).hexdigest()
            if room.ics_last_etag == content_hash:
                logger.info("No changes in ICS for room", room_id=room.id)
                room_url = f"{settings.UI_BASE_URL}/{room.name}"
                events, total_events = self.fetch_service.extract_room_events(
                    calendar, room.name, room_url
                )
                return {
                    "status": SyncStatus.UNCHANGED,
                    "hash": content_hash,
                    "events_found": len(events),
                    "total_events": total_events,
                    "events_created": 0,
                    "events_updated": 0,
                    "events_deleted": 0,
                }
            # Extract matching events
            room_url = f"{settings.UI_BASE_URL}/{room.name}"
            events, total_events = self.fetch_service.extract_room_events(
                calendar, room.name, room_url
            )
            sync_result = await self._sync_events_to_database(room.id, events)
            # Update room sync metadata
            await rooms_controller.update(
                room,
                {
                    "ics_last_sync": datetime.now(timezone.utc),
                    "ics_last_etag": content_hash,
                },
                mutate=False,
            )
            return {
                "status": SyncStatus.SUCCESS,
                "hash": content_hash,
                "events_found": len(events),
                "total_events": total_events,
                **sync_result,
            }
        except Exception as e:
            logger.error("Failed to sync ICS for room", room_id=room.id, error=str(e))
            return {"status": SyncStatus.ERROR, "error": str(e)}
    def _should_sync(self, room: Room) -> bool:
        if not room.ics_last_sync:
            return True
        time_since_sync = datetime.now(timezone.utc) - room.ics_last_sync
        return time_since_sync.total_seconds() >= room.ics_fetch_interval
    async def _sync_events_to_database(
        self, room_id: str, events: list[EventData]
    ) -> SyncStats:
        created = 0
        updated = 0
        current_ics_uids = []
        for event_data in events:
            calendar_event = CalendarEvent(room_id=room_id, **event_data)
            existing = await calendar_events_controller.get_by_ics_uid(
                room_id, event_data["ics_uid"]
            )
            if existing:
                updated += 1
            else:
                created += 1
            await calendar_events_controller.upsert(calendar_event)
            current_ics_uids.append(event_data["ics_uid"])
        # Soft delete events that are no longer in calendar
        deleted = await calendar_events_controller.soft_delete_missing(
            room_id, current_ics_uids
        )
        return {
            "events_created": created,
            "events_updated": updated,
            "events_deleted": deleted,
        }
 ics_sync_service = ICSSyncService()
--- a/server/reflector/settings.py
+++ b/server/reflector/settings.py
@@ -1,9 +1,5 @@
 from pydantic.types import PositiveInt
 from pydantic_settings import BaseSettings, SettingsConfigDict
 from reflector.platform_types import Platform
 from reflector.utils.string import NonEmptyString
 class Settings(BaseSettings):
    model_config = SettingsConfigDict(
@@ -25,10 +21,6 @@ class Settings(BaseSettings):
    # local data directory
    DATA_DIR: str = "./data"
    # Audio Chunking
    # backends: silero, frames
    AUDIO_CHUNKER_BACKEND: str = "frames"
    # Audio Transcription
    # backends: whisper, modal
    TRANSCRIPT_BACKEND: str = "whisper"
@@ -94,8 +86,9 @@ class Settings(BaseSettings):
    AUTH_JWT_PUBLIC_KEY: str | None = "authentik.monadical.com_public.pem"
    AUTH_JWT_AUDIENCE: str | None = None
    # API public mode
    # if set, all anonymous record will be public
    PUBLIC_MODE: bool = False
    PUBLIC_DATA_RETENTION_DAYS: PositiveInt = 7
    # Min transcript length to generate topic + summary
    MIN_TRANSCRIPT_LENGTH: int = 750
@@ -123,26 +116,13 @@ class Settings(BaseSettings):
    # Whereby integration
    WHEREBY_API_URL: str = "https://api.whereby.dev/v1"
-    WHEREBY_API_KEY: NonEmptyString | None = None
+    WHEREBY_API_KEY: str | None = None
    WHEREBY_WEBHOOK_SECRET: 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
    # Platform Migration Feature Flags
    DAILY_MIGRATION_ENABLED: bool = False
    DAILY_MIGRATION_ROOM_IDS: list[str] = []
    DEFAULT_VIDEO_PLATFORM: Platform = "whereby"
    # Zulip integration
    ZULIP_REALM: str | None = None
    ZULIP_API_KEY: str | None = None
--- a/server/reflector/tools/cleanup_old_data.py
+++ b/server/reflector/tools/cleanup_old_data.py
@@ -1,72 +0,0 @@
 #!/usr/bin/env python
 """
 Manual cleanup tool for old public data.
 Uses the same implementation as the Celery worker task.
 """
 import argparse
 import asyncio
 import sys
 import structlog
 from reflector.settings import settings
 from reflector.worker.cleanup import _cleanup_old_public_data
 logger = structlog.get_logger(__name__)
 async def cleanup_old_data(days: int = 7):
    logger.info(
        "Starting manual cleanup",
        retention_days=days,
        public_mode=settings.PUBLIC_MODE,
    )
    if not settings.PUBLIC_MODE:
        logger.critical(
            "WARNING: PUBLIC_MODE is False. "
            "This tool is intended for public instances only."
        )
        raise Exception("Tool intended for public instances only")
    result = await _cleanup_old_public_data(days=days)
    if result:
        logger.info(
            "Cleanup completed",
            transcripts_deleted=result.get("transcripts_deleted", 0),
            meetings_deleted=result.get("meetings_deleted", 0),
            recordings_deleted=result.get("recordings_deleted", 0),
            errors_count=len(result.get("errors", [])),
        )
        if result.get("errors"):
            logger.warning(
                "Errors encountered during cleanup:", errors=result["errors"][:10]
            )
    else:
        logger.info("Cleanup skipped or completed without results")
 def main():
    parser = argparse.ArgumentParser(
        description="Clean up old transcripts and meetings"
    )
    parser.add_argument(
        "--days",
        type=int,
        default=7,
        help="Number of days to keep data (default: 7)",
    )
    args = parser.parse_args()
    if args.days < 1:
        logger.error("Days must be at least 1")
        sys.exit(1)
    asyncio.run(cleanup_old_data(days=args.days))
 if __name__ == "__main__":
    main()
--- a/server/reflector/tools/process.py
+++ b/server/reflector/tools/process.py
@@ -1,204 +1,292 @@
 """
 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 argparse
 import asyncio
-import json
+import tempfile
-import shutil
+import uuid
 import sys
 import time
 from pathlib import Path
-from typing import Any, Dict, List, Literal
+from typing import List
 import av
 from reflector.db.transcripts import SourceKind, TranscriptTopic, transcripts_controller
 from reflector.logger import logger
-from reflector.pipelines.main_file_pipeline import (
+from reflector.processors import (
-    task_pipeline_file_process as task_pipeline_file_process,
+    AudioChunkerProcessor,
    AudioFileWriterProcessor,
    AudioMergeProcessor,
    AudioTranscriptAutoProcessor,
    Pipeline,
    PipelineEvent,
    TranscriptFinalSummaryProcessor,
    TranscriptFinalTitleProcessor,
    TranscriptLinerProcessor,
    TranscriptTopicDetectorProcessor,
    TranscriptTranslatorAutoProcessor,
 )
-from reflector.pipelines.main_live_pipeline import pipeline_post as live_pipeline_post
+from reflector.processors.base import BroadcastProcessor, Processor
-from reflector.pipelines.main_live_pipeline import (
+from reflector.processors.types import (
-    pipeline_process as live_pipeline_process,
+    AudioDiarizationInput,
    TitleSummary,
    TitleSummaryWithId,
 )
-def serialize_topics(topics: List[TranscriptTopic]) -> List[Dict[str, Any]]:
+class TopicCollectorProcessor(Processor):
-    """Convert TranscriptTopic objects to JSON-serializable dicts"""
+    """Collect topics for diarization"""
    serialized = []
    for topic in topics:
        topic_dict = topic.model_dump()
        serialized.append(topic_dict)
    return serialized
    INPUT_TYPE = TitleSummary
    OUTPUT_TYPE = TitleSummary
-def debug_print_speakers(serialized_topics: List[Dict[str, Any]]) -> None:
+    def __init__(self, **kwargs):
-    """Print debug info about speakers found in topics"""
+        super().__init__(**kwargs)
-    all_speakers = set()
+        self.topics: List[TitleSummaryWithId] = []
-    for topic_dict in serialized_topics:
+        self._topic_id = 0
        for word in topic_dict.get("words", []):
            all_speakers.add(word.get("speaker", 0))
-    print(
+    async def _push(self, data: TitleSummary):
-        f"Found {len(serialized_topics)} topics with speakers: {all_speakers}",
+        # Convert to TitleSummaryWithId and collect
-        file=sys.stderr,
+        self._topic_id += 1
-    )
+        topic_with_id = TitleSummaryWithId(
-
+            id=str(self._topic_id),
-
+            title=data.title,
-TranscriptId = str
+            summary=data.summary,
-
+            timestamp=data.timestamp,
-
+            duration=data.duration,
-# common interface for every flow: it needs an Entry in db with specific ceremony (file path + status + actual file in file system)
+            transcript=data.transcript,
 # ideally we want to get rid of it at some point
 async def prepare_entry(
    source_path: str,
    source_language: str,
    target_language: str,
 ) -> TranscriptId:
    file_path = Path(source_path)
    transcript = await transcripts_controller.add(
        file_path.name,
        # note that the real file upload has SourceKind: LIVE for the reason of it's an error
        source_kind=SourceKind.FILE,
        source_language=source_language,
        target_language=target_language,
        user_id=None,
    )
    logger.info(
        f"Created empty transcript {transcript.id} for file {file_path.name} because technically we need an empty transcript before we start transcript"
    )
    # pipelines expect files as upload.*
    extension = file_path.suffix
    upload_path = transcript.data_path / f"upload{extension}"
    upload_path.parent.mkdir(parents=True, exist_ok=True)
    shutil.copy2(source_path, upload_path)
    logger.info(f"Copied {source_path} to {upload_path}")
    # pipelines expect entity status "uploaded"
    await transcripts_controller.update(transcript, {"status": "uploaded"})
    return transcript.id
 # same reason as prepare_entry
 async def extract_result_from_entry(
    transcript_id: TranscriptId, output_path: str
 ) -> None:
    post_final_transcript = await transcripts_controller.get_by_id(transcript_id)
    # assert post_final_transcript.status == "ended"
    # File pipeline doesn't set status to "ended", only live pipeline does https://github.com/Monadical-SAS/reflector/issues/582
    topics = post_final_transcript.topics
    if not topics:
        raise RuntimeError(
            f"No topics found for transcript {transcript_id} after processing"
        )
        self.topics.append(topic_with_id)
-    serialized_topics = serialize_topics(topics)
+        # Pass through the original topic
        await self.emit(data)
-    if output_path:
+    def get_topics(self) -> List[TitleSummaryWithId]:
-        # Write to JSON file
+        return self.topics
        with open(output_path, "w") as f:
            for topic_dict in serialized_topics:
                json.dump(topic_dict, f)
                f.write("\n")
        print(f"Results written to {output_path}", file=sys.stderr)
    else:
        # Write to stdout as JSONL
        for topic_dict in serialized_topics:
            print(json.dumps(topic_dict))
    debug_print_speakers(serialized_topics)
-async def process_live_pipeline(
+async def process_audio_file(
-    transcript_id: TranscriptId,
+    filename,
    event_callback,
    only_transcript=False,
    source_language="en",
    target_language="en",
    enable_diarization=True,
    diarization_backend="pyannote",
 ):
-    """Process transcript_id with transcription and diarization"""
+    # 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()
-    print(f"Processing transcript_id {transcript_id}...", file=sys.stderr)
+    # Create processor for collecting topics
-    await live_pipeline_process(transcript_id=transcript_id)
+    topic_collector = TopicCollectorProcessor()
    print(f"Processing complete for transcript {transcript_id}", file=sys.stderr)
-    pre_final_transcript = await transcripts_controller.get_by_id(transcript_id)
+    # Build pipeline for audio processing
    processors = []
-    # assert documented behaviour: after process, the pipeline isn't ended. this is the reason of calling pipeline_post
+    # Add audio file writer at the beginning if diarization is enabled
-    assert pre_final_transcript.status != "ended"
+    if enable_diarization:
        processors.append(AudioFileWriterProcessor(audio_temp_path))
-    # at this point, diarization is running but we have no access to it. run diarization in parallel - one will hopefully win after polling
+    # Add the rest of the processors
-    result = live_pipeline_post(transcript_id=transcript_id)
+    processors += [
        AudioChunkerProcessor(),
        AudioMergeProcessor(),
        AudioTranscriptAutoProcessor.as_threaded(),
        TranscriptLinerProcessor(),
        TranscriptTranslatorAutoProcessor.as_threaded(),
    ]
-    # result.ready() blocks even without await; it mutates result also
+    if not only_transcript:
-    while not result.ready():
+        processors += [
-        print(f"Status: {result.state}")
+            TranscriptTopicDetectorProcessor.as_threaded(),
-        time.sleep(2)
+            # Collect topics for diarization
            topic_collector,
            BroadcastProcessor(
                processors=[
                    TranscriptFinalTitleProcessor.as_threaded(),
                    TranscriptFinalSummaryProcessor.as_threaded(),
                ],
            ),
        ]
    # 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
    logger.info(f"Opening {filename}")
    container = av.open(filename)
    try:
        logger.info("Start pushing audio into the pipeline")
        for frame in container.decode(audio=0):
            await pipeline.push(frame)
    finally:
        logger.info("Flushing the pipeline")
        await pipeline.flush()
    # 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(
-    transcript_id: TranscriptId,
+    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"""
    # task_pipeline_file_process is a Celery task, need to use .delay() for async execution
    result = task_pipeline_file_process.delay(transcript_id=transcript_id)
    # Wait for the Celery task to complete
    while not result.ready():
        print(f"File pipeline status: {result.state}", file=sys.stderr)
        time.sleep(2)
    logger.info("File pipeline processing complete")
 async def process(
    source_path: str,
    source_language: str,
    target_language: str,
    pipeline: Literal["live", "file"],
    output_path: str = None,
 ):
    from reflector.db import get_database
    database = get_database()
    # db connect is a part of ceremony
    await database.connect()
    try:
-        transcript_id = await prepare_entry(
+        from reflector.db import database
-            source_path,
+        from reflector.db.transcripts import SourceKind, transcripts_controller
-            source_language,
+        from reflector.pipelines.main_file_pipeline import PipelineMainFile
-            target_language,
+
        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,
        )
        pipeline_handlers = {
            "live": process_live_pipeline,
            "file": process_file_pipeline,
        }
        handler = pipeline_handlers.get(pipeline)
        if not handler:
            raise ValueError(f"Unknown pipeline type: {pipeline}")
        await handler(transcript_id)
        await extract_result_from_entry(transcript_id, output_path)
    finally:
        await database.disconnect()
 if __name__ == "__main__":
    import argparse
    import os
    parser = argparse.ArgumentParser(
-        description="Process audio files with speaker diarization"
+        description="Process audio files with optional speaker diarization"
    )
    parser.add_argument("source", help="Source file (mp3, wav, mp4...)")
    parser.add_argument(
-        "--pipeline",
+        "--stream",
-        required=True,
+        action="store_true",
-        choices=["live", "file"],
+        help="Use streaming pipeline (original frame-based processing)",
-        help="Pipeline type to use for processing (live: streaming/incremental, file: batch/parallel)",
+    )
    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)"
@@ -207,14 +295,81 @@ if __name__ == "__main__":
        "--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()
-    asyncio.run(
+    if "REDIS_HOST" not in os.environ:
-        process(
+        os.environ["REDIS_HOST"] = "localhost"
-            args.source,
+
-            args.source_language,
+    output_fd = None
-            args.target_language,
+    if args.output:
-            args.pipeline,
+        output_fd = open(args.output, "w")
-            args.output,
+
    async def event_callback(event: PipelineEvent):
        processor = event.processor
        data = event.data
        # Ignore internal processors
        if processor in (
            "AudioChunkerProcessor",
            "AudioMergeProcessor",
            "AudioFileWriterProcessor",
            "TopicCollectorProcessor",
            "BroadcastProcessor",
        ):
            return
        # 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()
    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()
        logger.info(f"Output written to {args.output}")
--- a/server/reflector/tools/process_with_diarization.py
+++ b/server/reflector/tools/process_with_diarization.py
@@ -0,0 +1,315 @@
 """
@vibe-generated
 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,
    PipelineEvent,
    TranscriptFinalSummaryProcessor,
    TranscriptFinalTitleProcessor,
    TranscriptLinerProcessor,
    TranscriptTopicDetectorProcessor,
    TranscriptTranslatorAutoProcessor,
 )
 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_with_diarization(
    filename,
    event_callback,
    only_transcript=False,
    source_language="en",
    target_language="en",
    enable_diarization=True,
    diarization_backend="modal",
 ):
    # 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(),
    ]
    processors += [
        TranscriptLinerProcessor(),
        TranscriptTranslatorAutoProcessor.as_threaded(),
    ]
    if not only_transcript:
        processors += [
            TranscriptTopicDetectorProcessor.as_threaded(),
            # Collect topics for diarization
            topic_collector,
            BroadcastProcessor(
                processors=[
                    TranscriptFinalTitleProcessor.as_threaded(),
                    TranscriptFinalSummaryProcessor.as_threaded(),
                ],
            ),
        ]
    # 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
    logger.info(f"Opening {filename}")
    container = av.open(filename)
    try:
        logger.info("Start pushing audio into the pipeline")
        for frame in container.decode(audio=0):
            await pipeline.push(frame)
    finally:
        logger.info("Flushing the pipeline")
        await pipeline.flush()
    # 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, timezone
                    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.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
                    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!")
 if __name__ == "__main__":
    import argparse
    import os
    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",
        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="modal",
        choices=["modal"],
        help="Diarization backend to use (default: modal)",
    )
    args = parser.parse_args()
    # Set REDIS_HOST to localhost if not provided
    if "REDIS_HOST" not in os.environ:
        os.environ["REDIS_HOST"] = "localhost"
        logger.info("REDIS_HOST not set, defaulting to localhost")
    output_fd = None
    if args.output:
        output_fd = open(args.output, "w")
    async def event_callback(event: PipelineEvent):
        processor = event.processor
        data = event.data
        # Ignore internal processors
        if processor in (
            "AudioChunkerProcessor",
            "AudioMergeProcessor",
            "AudioFileWriterProcessor",
            "TopicCollectorProcessor",
            "BroadcastProcessor",
        ):
            return
        # 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_with_diarization(
            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,
        )
    )
    if output_fd:
        output_fd.close()
        logger.info(f"Output written to {args.output}")
--- a/server/reflector/tools/runpipeline.py
+++ b/server/reflector/tools/runpipeline.py
@@ -53,7 +53,7 @@ async def run_single_processor(args):
    async def event_callback(event: PipelineEvent):
        processor = event.processor
        # ignore some processor
-        if processor in ("AudioChunkerAutoProcessor", "AudioMergeProcessor"):
+        if processor in ("AudioChunkerProcessor", "AudioMergeProcessor"):
            return
        print(f"Event: {event}")
        if output_fd:
--- a/server/reflector/tools/test_diarization.py
+++ b/server/reflector/tools/test_diarization.py
@@ -0,0 +1,96 @@
 #!/usr/bin/env python3
 """
@vibe-generated
 Test script for the diarization CLI tool
 =========================================
 This script helps test the diarization functionality with sample audio files.
 """
 import asyncio
 import sys
 from pathlib import Path
 from reflector.logger import logger
 async def test_diarization(audio_file: str):
    """Test the diarization functionality"""
    # Import the processing function
    from process_with_diarization import process_audio_file_with_diarization
    # Collect events
    events = []
    async def event_callback(event):
        events.append({"processor": event.processor, "data": event.data})
        logger.info(f"Event from {event.processor}")
    # Process the audio file
    logger.info(f"Processing audio file: {audio_file}")
    try:
        await process_audio_file_with_diarization(
            audio_file,
            event_callback,
            only_transcript=False,
            source_language="en",
            target_language="en",
            enable_diarization=True,
            diarization_backend="modal",
        )
        # Analyze results
        logger.info(f"Processing complete. Received {len(events)} events")
        # Look for diarization results
        diarized_topics = []
        for event in events:
            if "TitleSummary" in event["processor"]:
                # Check if words have speaker information
                if hasattr(event["data"], "transcript") and event["data"].transcript:
                    words = event["data"].transcript.words
                    if words and hasattr(words[0], "speaker"):
                        speakers = set(
                            w.speaker for w in words if hasattr(w, "speaker")
                        )
                        logger.info(
                            f"Found {len(speakers)} speakers in topic: {event['data'].title}"
                        )
                        diarized_topics.append(event["data"])
        if diarized_topics:
            logger.info(f"Successfully diarized {len(diarized_topics)} topics")
            # Print sample output
            sample_topic = diarized_topics[0]
            logger.info("Sample diarized output:")
            for i, word in enumerate(sample_topic.transcript.words[:10]):
                logger.info(f"  Word {i}: '{word.text}' - Speaker {word.speaker}")
        else:
            logger.warning("No diarization results found in output")
        return events
    except Exception as e:
        logger.error(f"Error during processing: {e}")
        raise
 def main():
    if len(sys.argv) < 2:
        print("Usage: python test_diarization.py <audio_file>")
        sys.exit(1)
    audio_file = sys.argv[1]
    if not Path(audio_file).exists():
        print(f"Error: Audio file '{audio_file}' not found")
        sys.exit(1)
    # Run the test
    asyncio.run(test_diarization(audio_file))
 if __name__ == "__main__":
    main()
--- a/server/reflector/utils/string.py
+++ b/server/reflector/utils/string.py
@@ -1,23 +0,0 @@
 from typing import Annotated
 from pydantic import Field, TypeAdapter, constr
 NonEmptyStringBase = constr(min_length=1, strip_whitespace=False)
 NonEmptyString = Annotated[
    NonEmptyStringBase,
    Field(description="A non-empty string", min_length=1),
 ]
 non_empty_string_adapter = TypeAdapter(NonEmptyString)
 def parse_non_empty_string(s: str, error: str | None = None) -> NonEmptyString:
    try:
        return non_empty_string_adapter.validate_python(s)
    except Exception as e:
        raise ValueError(f"{e}: {error}" if error else e) from e
 def try_parse_non_empty_string(s: str) -> NonEmptyString | None:
    if not s:
        return None
    return parse_non_empty_string(s)
--- a/server/reflector/video_platforms/init.py
+++ b/server/reflector/video_platforms/init.py
@@ -1,18 +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 VideoPlatformClient
 from .models import MeetingData, 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,60 +0,0 @@
 from abc import ABC, abstractmethod
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, Dict, Optional
 from reflector.platform_types import Platform
 from .models import MeetingData, VideoPlatformConfig
 if TYPE_CHECKING:
    from reflector.db.rooms import Room
 class VideoPlatformClient(ABC):
    """Abstract base class for video platform integrations."""
    PLATFORM_NAME: Platform
    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,178 +0,0 @@
 import hmac
 from datetime import datetime
 from hashlib import sha256
 from http import HTTPStatus
 from typing import Any, Dict, Optional
 import httpx
 from reflector.db.rooms import Room
 from reflector.platform_types import Platform
 from .base import VideoPlatformClient
 from .models import MeetingData, RecordingType, VideoPlatformConfig
 class DailyClient(VideoPlatformClient):
    PLATFORM_NAME: Platform = "daily"
    TIMEOUT = 10
    BASE_URL = "https://api.daily.co/v1"
    TIMESTAMP_FORMAT = "%Y%m%d%H%M%S"
    RECORDING_NONE: RecordingType = "none"
    RECORDING_CLOUD: RecordingType = "cloud"
    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."""
        timestamp = datetime.now().strftime(self.TIMESTAMP_FORMAT)
        if room_name_prefix:
            room_name = f"{room_name_prefix}-{timestamp}"
        else:
            room_name = f"room-{timestamp}"
        data = {
            "name": room_name,
            "privacy": "private" if room.is_locked else "public",
            "properties": {
                "enable_recording": "raw-tracks"
                if room.recording_type != self.RECORDING_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 recordings
        # NOTE: Not checking room.recording_type - figure out later if conditional needed
        assert self.config.s3_bucket, "S3 bucket must be configured"
        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,
        }
        from reflector.logger import logger
        async with httpx.AsyncClient() as client:
            response = await client.post(
                f"{self.BASE_URL}/rooms",
                headers=self.headers,
                json=data,
                timeout=self.TIMEOUT,
            )
            if response.status_code >= 400:
                logger.error(
                    "Daily.co API error",
                    status_code=response.status_code,
                    response_body=response.text,
                    request_data=data,
                )
            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 (HTTPStatus.OK, HTTPStatus.NOT_FOUND)
    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.
        Daily.co uses:
        - X-Webhook-Signature header
        - X-Webhook-Timestamp header
        - Signature format: HMAC-SHA256(base64_decode(secret), timestamp + '.' + body)
        - Result is base64 encoded
        """
        if not signature or not timestamp:
            return False
        try:
            import base64
            secret_bytes = base64.b64decode(self.config.webhook_secret)
            signed_content = timestamp.encode() + b"." + body
            expected = hmac.new(secret_bytes, signed_content, sha256).digest()
            expected_b64 = base64.b64encode(expected).decode()
            return hmac.compare_digest(expected_b64, signature)
        except Exception:
            return False
    async def create_meeting_token(self, room_name: str, enable_recording: bool) -> str:
        """Create meeting token for auto-recording."""
        data = {"properties": {"room_name": room_name}}
        if enable_recording:
            data["properties"]["start_cloud_recording"] = True
            data["properties"]["enable_recording_ui"] = False
        async with httpx.AsyncClient() as client:
            response = await client.post(
                f"{self.BASE_URL}/meeting-tokens",
                headers=self.headers,
                json=data,
                timeout=self.TIMEOUT,
            )
            response.raise_for_status()
            return response.json()["token"]
--- a/Show More
+++ b/Show More
		`@@ -1 +0,0 @@`
			`b9d891d3424f371642cb032ecfd0e2564470a72c:server/tests/test_transcripts_recording_deletion.py:generic-api-key:15`
		`@@ -1,3 +0,0 @@`
			`from app.factory import create_app`

			`app = create_app()`