feat: use jitsi file system

Merge main into jisti-integration branch
- Resolved conflicts in server/reflector/views/rooms.py to keep platform-agnostic approach - Resolved conflicts in www/app/[roomName]/page.tsx to keep VideoPlatformEmbed approach - Accepted main's version of generated API files (schemas.gen.ts, services.gen.ts, types.gen.ts) - Removed config-template.ts as per main branch changes
2025-12-20 20:29:06 +00:00 · 2025-09-17 15:16:03 -06:00 · 2025-09-15 12:53:49 -06:00 · 2025-09-04 12:21:51 -06:00 · 2025-09-02 18:28:50 -06:00 · 2025-09-02 18:25:55 -06:00
273 changed files with 8256 additions and 26547 deletions
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -0,0 +1,90 @@
+name: Deploy to Amazon ECS
+
+on: [workflow_dispatch]
+
+env:
+  # 950402358378.dkr.ecr.us-east-1.amazonaws.com/reflector
+  AWS_REGION: us-east-1
+  ECR_REPOSITORY: reflector
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        include:
+          - platform: linux/amd64
+            runner: linux-amd64
+            arch: amd64
+          - platform: linux/arm64
+            runner: linux-arm64
+            arch: arm64
+
+    runs-on: ${{ matrix.runner }}
+
+    permissions:
+      contents: read
+
+    outputs:
+      registry: ${{ steps.login-ecr.outputs.registry }}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ env.AWS_REGION }}
+
+      - name: Login to Amazon ECR
+        id: login-ecr
+        uses: aws-actions/amazon-ecr-login@v2
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build and push ${{ matrix.arch }}
+        uses: docker/build-push-action@v5
+        with:
+          context: server
+          platforms: ${{ matrix.platform }}
+          push: true
+          tags: ${{ steps.login-ecr.outputs.registry }}/${{ env.ECR_REPOSITORY }}:latest-${{ matrix.arch }}
+          cache-from: type=gha,scope=${{ matrix.arch }}
+          cache-to: type=gha,mode=max,scope=${{ matrix.arch }}
+          github-token: ${{ secrets.GHA_CACHE_TOKEN }}
+          provenance: false
+
+  create-manifest:
+    runs-on: ubuntu-latest
+    needs: [build]
+
+    permissions:
+      deployments: write
+      contents: read
+
+    steps:
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ env.AWS_REGION }}
+
+      - name: Login to Amazon ECR
+        uses: aws-actions/amazon-ecr-login@v2
+
+      - name: Create and push multi-arch manifest
+        run: |
+          # Get the registry URL (since we can't easily access job outputs in matrix)
+          ECR_REGISTRY=$(aws ecr describe-registry --query 'registryId' --output text).dkr.ecr.${{ env.AWS_REGION }}.amazonaws.com
+
+          docker manifest create \
+            $ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:latest \
+            $ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:latest-amd64 \
+            $ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:latest-arm64
+
+          docker manifest push $ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:latest
+
+          echo "✅ Multi-arch manifest pushed: $ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:latest"
--- a/.github/workflows/dockerhub-backend.yml
+++ b/.github/workflows/dockerhub-backend.yml
@@ -1,61 +0,0 @@
-name: Build and Push Backend Docker Image (Docker Hub)
-
-on:
-  pull_request:
-    types:
-      - closed
-    paths:
-      - "server/**"
-      - ".github/workflows/dockerhub-backend.yml"
-  workflow_dispatch:
-
-env:
-  REGISTRY: docker.io
-  IMAGE_NAME: monadicalsas/reflector-backend
-
-jobs:
-  build-and-push:
-    runs-on: ubuntu-latest
-    if: |
-      github.event_name == 'workflow_dispatch' ||
-      (github.event.pull_request.merged == true &&
-       startsWith(github.event.pull_request.head.ref, 'release-please--branches--'))
-
-    permissions:
-      contents: read
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Log in to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: monadicalsas
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Extract metadata
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
-          tags: |
-            type=ref,event=branch
-            type=ref,event=tag
-            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: ./server
-          file: ./server/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/dockerhub-frontend.yml
+++ b/.github/workflows/dockerhub-frontend.yml
@@ -1,78 +0,0 @@
-name: Build and Push Frontend Docker Image
-
-on:
-  pull_request:
-    types:
-      - closed
-    paths:
-      - "www/**"
-      - ".github/workflows/dockerhub-frontend.yml"
-  workflow_dispatch:
-
-env:
-  REGISTRY: docker.io
-  IMAGE_NAME: monadicalsas/reflector-frontend
-
-jobs:
-  build-and-push:
-    runs-on: ubuntu-latest
-    if: |
-      github.event_name == 'workflow_dispatch' ||
-      (github.event.pull_request.merged == true &&
-       startsWith(github.event.pull_request.head.ref, 'release-please--branches--'))
-
-    permissions:
-      contents: read
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Log in to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: monadicalsas
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Extract metadata
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
-          tags: |
-            type=ref,event=branch
-            type=ref,event=tag
-            type=raw,value=latest,enable={{is_default_branch}}
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-
-      - 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
-
-  deploy:
-    needs: build-and-push
-    runs-on: ubuntu-latest
-    if: success()
-    strategy:
-      matrix:
-        environment: [reflector-monadical, reflector-media]
-    environment: ${{ matrix.environment }}
-    steps:
-      - name: Trigger Coolify deployment
-        run: |
-          curl -X POST "${{ secrets.COOLIFY_WEBHOOK_URL }}" \
-            -H "Content-Type: application/json" \
-            -H "Authorization: Bearer ${{ secrets.COOLIFY_WEBHOOK_TOKEN }}" \
-            -f || (echo "Failed to trigger Coolify deployment for ${{ matrix.environment }}" && exit 1)
--- a/.gitignore
+++ b/.gitignore
@@ -18,4 +18,3 @@ CLAUDE.local.md
 www/.env.development
 www/.env.production
 .playwright-mcp
-.secrets
--- a/.secrets.example
+++ b/.secrets.example
@@ -1,24 +0,0 @@
-# Example secrets file for GitHub Actions workflows
-# Copy this to .secrets and fill in your values
-# These secrets should be configured in GitHub repository settings:
-# Settings > Secrets and variables > Actions
-
-# DockerHub Configuration (required for frontend and backend deployment)
-# Create a Docker Hub access token at https://hub.docker.com/settings/security
-# Username: monadicalsas
-DOCKERHUB_TOKEN=your-dockerhub-access-token
-
-# GitHub Token (required for frontend and backend deployment)
-# Used by docker/metadata-action for extracting image metadata
-# Can use the default GITHUB_TOKEN or create a personal access token
-GITHUB_TOKEN=your-github-token-or-use-default-GITHUB_TOKEN
-
-# Coolify Deployment Webhook (required for frontend deployment)
-# Used to trigger automatic deployment after image push
-# Configure these secrets in GitHub Environments:
-# Each environment should have:
-#   - COOLIFY_WEBHOOK_URL: The webhook URL for that specific deployment
-#   - COOLIFY_WEBHOOK_TOKEN: The webhook token (can be the same for both if using same token)
-
-# Optional: GitHub Actions Cache Token (for local testing with act)
-GHA_CACHE_TOKEN=your-github-token-or-empty
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,199 +1,5 @@
 # Changelog

-## [0.23.1](https://github.com/Monadical-SAS/reflector/compare/v0.23.0...v0.23.1) (2025-12-11)
-
-
-### Bug Fixes
-
-* populate room_name in transcript GET endpoint ([#783](https://github.com/Monadical-SAS/reflector/issues/783)) ([0eba147](https://github.com/Monadical-SAS/reflector/commit/0eba1470181c7b9e0a79964a1ef28c09bcbdd9d7))
-
-## [0.23.0](https://github.com/Monadical-SAS/reflector/compare/v0.22.4...v0.23.0) (2025-12-10)
-
-
-### Features
-
-* dockerhub ci ([#772](https://github.com/Monadical-SAS/reflector/issues/772)) ([00549f1](https://github.com/Monadical-SAS/reflector/commit/00549f153ade922cf4cb6c5358a7d11a39c426d2))
-* llm retries ([#739](https://github.com/Monadical-SAS/reflector/issues/739)) ([61f0e29](https://github.com/Monadical-SAS/reflector/commit/61f0e29d4c51eab54ee67af92141fbb171e8ccaa))
-
-
-### Bug Fixes
-
-* celery inspect bug sidestep in restart script ([#766](https://github.com/Monadical-SAS/reflector/issues/766)) ([ec17ed7](https://github.com/Monadical-SAS/reflector/commit/ec17ed7b587cf6ee143646baaee67a7c017044d4))
-* deploy frontend to coolify ([#779](https://github.com/Monadical-SAS/reflector/issues/779)) ([91650ec](https://github.com/Monadical-SAS/reflector/commit/91650ec65f65713faa7ee0dcfb75af427b7c4ba0))
-* hide rooms settings instead of disabling ([#763](https://github.com/Monadical-SAS/reflector/issues/763)) ([3ad78be](https://github.com/Monadical-SAS/reflector/commit/3ad78be7628c0d029296b301a0e87236c76b7598))
-* return participant emails from transcript endpoint ([#769](https://github.com/Monadical-SAS/reflector/issues/769)) ([d3a5cd1](https://github.com/Monadical-SAS/reflector/commit/d3a5cd12d2d0d9c32af2d5bd9322e030ef69b85d))
-
-## [0.22.4](https://github.com/Monadical-SAS/reflector/compare/v0.22.3...v0.22.4) (2025-12-02)
-
-
-### Bug Fixes
-
-* Multitrack mixdown optimisation 2 ([#764](https://github.com/Monadical-SAS/reflector/issues/764)) ([bd5df1c](https://github.com/Monadical-SAS/reflector/commit/bd5df1ce2ebf35d7f3413b295e56937a9a28ef7b))
-
-## [0.22.3](https://github.com/Monadical-SAS/reflector/compare/v0.22.2...v0.22.3) (2025-12-02)
-
-
-### Bug Fixes
-
-* align daily room settings ([#759](https://github.com/Monadical-SAS/reflector/issues/759)) ([28f87c0](https://github.com/Monadical-SAS/reflector/commit/28f87c09dc459846873d0dde65b03e3d7b2b9399))
-
-## [0.22.2](https://github.com/Monadical-SAS/reflector/compare/v0.22.1...v0.22.2) (2025-12-02)
-
-
-### Bug Fixes
-
-* daily auto refresh fix ([#755](https://github.com/Monadical-SAS/reflector/issues/755)) ([fe47c46](https://github.com/Monadical-SAS/reflector/commit/fe47c46489c5aa0cc538109f7559cc9accb35c01))
-* Skip mixdown for multitrack ([#760](https://github.com/Monadical-SAS/reflector/issues/760)) ([b51b7aa](https://github.com/Monadical-SAS/reflector/commit/b51b7aa9176c1a53ba57ad99f5e976c804a1e80c))
-
-## [0.22.1](https://github.com/Monadical-SAS/reflector/compare/v0.22.0...v0.22.1) (2025-11-27)
-
-
-### Bug Fixes
-
-* participants update from daily ([#749](https://github.com/Monadical-SAS/reflector/issues/749)) ([7f0b728](https://github.com/Monadical-SAS/reflector/commit/7f0b728991c1b9f9aae702c96297eae63b561ef5))
-
-## [0.22.0](https://github.com/Monadical-SAS/reflector/compare/v0.21.0...v0.22.0) (2025-11-26)
-
-
-### Features
-
-* Multitrack segmentation ([#747](https://github.com/Monadical-SAS/reflector/issues/747)) ([d63040e](https://github.com/Monadical-SAS/reflector/commit/d63040e2fdc07e7b272e85a39eb2411cd6a14798))
-
-## [0.21.0](https://github.com/Monadical-SAS/reflector/compare/v0.20.0...v0.21.0) (2025-11-26)
-
-
-### Features
-
-* add transcript format parameter to GET endpoint ([#709](https://github.com/Monadical-SAS/reflector/issues/709)) ([f6ca075](https://github.com/Monadical-SAS/reflector/commit/f6ca07505f34483b02270a2ef3bd809e9d2e1045))
-
-## [0.20.0](https://github.com/Monadical-SAS/reflector/compare/v0.19.0...v0.20.0) (2025-11-25)
-
-
-### Features
-
-* link transcript participants ([#737](https://github.com/Monadical-SAS/reflector/issues/737)) ([9bec398](https://github.com/Monadical-SAS/reflector/commit/9bec39808fc6322612d8b87e922a6f7901fc01c1))
-* transcript restart script ([#742](https://github.com/Monadical-SAS/reflector/issues/742)) ([86d5e26](https://github.com/Monadical-SAS/reflector/commit/86d5e26224bb55a0f1cc785aeda52065bb92ee6f))
-
-## [0.19.0](https://github.com/Monadical-SAS/reflector/compare/v0.18.0...v0.19.0) (2025-11-25)
-
-
-### Features
-
-* dailyco api module ([#725](https://github.com/Monadical-SAS/reflector/issues/725)) ([4287f8b](https://github.com/Monadical-SAS/reflector/commit/4287f8b8aeee60e51db7539f4dcbda5f6e696bd8))
-* dailyco poll ([#730](https://github.com/Monadical-SAS/reflector/issues/730)) ([8e438ca](https://github.com/Monadical-SAS/reflector/commit/8e438ca285152bd48fdc42767e706fb448d3525c))
-* multitrack cli ([#735](https://github.com/Monadical-SAS/reflector/issues/735)) ([11731c9](https://github.com/Monadical-SAS/reflector/commit/11731c9d38439b04e93b1c3afbd7090bad11a11f))
-
-
-### Bug Fixes
-
-* default platform fix ([#736](https://github.com/Monadical-SAS/reflector/issues/736)) ([c442a62](https://github.com/Monadical-SAS/reflector/commit/c442a627873ca667656eeaefb63e54ab10b8d19e))
-* parakeet vad not getting the end timestamp ([#728](https://github.com/Monadical-SAS/reflector/issues/728)) ([18ed713](https://github.com/Monadical-SAS/reflector/commit/18ed7133693653ef4ddac6c659a8c14b320d1657))
-* start raw tracks recording ([#729](https://github.com/Monadical-SAS/reflector/issues/729)) ([3e47c2c](https://github.com/Monadical-SAS/reflector/commit/3e47c2c0573504858e0d2e1798b6ed31f16b4a5d))
-
-## [0.18.0](https://github.com/Monadical-SAS/reflector/compare/v0.17.0...v0.18.0) (2025-11-14)
-
-
-### Features
-
-* daily QOL: participants dictionary ([#721](https://github.com/Monadical-SAS/reflector/issues/721)) ([b20cad7](https://github.com/Monadical-SAS/reflector/commit/b20cad76e69fb6a76405af299a005f1ddcf60eae))
-
-
-### Bug Fixes
-
-* add proccessing page to file upload and reprocessing ([#650](https://github.com/Monadical-SAS/reflector/issues/650)) ([28a7258](https://github.com/Monadical-SAS/reflector/commit/28a7258e45317b78e60e6397be2bc503647eaace))
-* copy transcript ([#674](https://github.com/Monadical-SAS/reflector/issues/674)) ([a9a4f32](https://github.com/Monadical-SAS/reflector/commit/a9a4f32324f66c838e081eee42bb9502f38c1db1))
-
-## [0.17.0](https://github.com/Monadical-SAS/reflector/compare/v0.16.0...v0.17.0) (2025-11-13)
-
-
-### Features
-
-* add API key management UI ([#716](https://github.com/Monadical-SAS/reflector/issues/716)) ([372202b](https://github.com/Monadical-SAS/reflector/commit/372202b0e1a86823900b0aa77be1bfbc2893d8a1))
-* daily.co support as alternative to whereby ([#691](https://github.com/Monadical-SAS/reflector/issues/691)) ([1473fd8](https://github.com/Monadical-SAS/reflector/commit/1473fd82dc472c394cbaa2987212ad662a74bcac))
-
-## [0.16.0](https://github.com/Monadical-SAS/reflector/compare/v0.15.0...v0.16.0) (2025-10-24)
-
-
-### Features
-
-* search date filter ([#710](https://github.com/Monadical-SAS/reflector/issues/710)) ([962c40e](https://github.com/Monadical-SAS/reflector/commit/962c40e2b6428ac42fd10aea926782d7a6f3f902))
-
-## [0.15.0](https://github.com/Monadical-SAS/reflector/compare/v0.14.0...v0.15.0) (2025-10-20)
-
-
-### Features
-
-* api tokens  ([#705](https://github.com/Monadical-SAS/reflector/issues/705)) ([9a258ab](https://github.com/Monadical-SAS/reflector/commit/9a258abc0209b0ac3799532a507ea6a9125d703a))
-
-## [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)


--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -151,7 +151,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/README.md
+++ b/README.md
@@ -168,19 +168,6 @@ You can manually process an audio file by calling the process tool:
 uv run python -m reflector.tools.process path/to/audio.wav
 ```

-## Reprocessing any transcription
-
-```bash
-uv run -m reflector.tools.process_transcript 81ec38d1-9dd7-43d2-b3f8-51f4d34a07cd --sync
-```
-
-## 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

@@ -190,24 +177,24 @@ Reflector uses environment variable-based feature flags to control application f

 | Feature Flag | Environment Variable |
 |-------------|---------------------|
-| `requireLogin` | `FEATURE_REQUIRE_LOGIN` |
-| `privacy` | `FEATURE_PRIVACY` |
-| `browse` | `FEATURE_BROWSE` |
-| `sendToZulip` | `FEATURE_SEND_TO_ZULIP` |
-| `rooms` | `FEATURE_ROOMS` |
+| `requireLogin` | `NEXT_PUBLIC_FEATURE_REQUIRE_LOGIN` |
+| `privacy` | `NEXT_PUBLIC_FEATURE_PRIVACY` |
+| `browse` | `NEXT_PUBLIC_FEATURE_BROWSE` |
+| `sendToZulip` | `NEXT_PUBLIC_FEATURE_SEND_TO_ZULIP` |
+| `rooms` | `NEXT_PUBLIC_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.
+Feature flags are controlled via environment variables using the pattern `NEXT_PUBLIC_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
+NEXT_PUBLIC_FEATURE_REQUIRE_LOGIN=true

 # Disable browse functionality
-FEATURE_BROWSE=false
+NEXT_PUBLIC_FEATURE_BROWSE=false

 # Enable Zulip integration
-FEATURE_SEND_TO_ZULIP=true
+NEXT_PUBLIC_FEATURE_SEND_TO_ZULIP=true
 ```
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -39,7 +39,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 +50,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,36 +0,0 @@
-# Production Docker Compose configuration for Frontend
-# Usage: docker compose -f docker-compose.prod.yml up -d
-
-services:
-  web:
-    image: monadicalsas/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/docs/jitsi.md
+++ b/docs/jitsi.md
@@ -0,0 +1,369 @@
+# Jitsi Integration for Reflector
+
+This document contains research and planning notes for integrating Jitsi Meet as a replacement for Whereby in Reflector.
+
+## Overview
+
+Jitsi Meet is an open-source video conferencing solution that can replace Whereby in Reflector, providing:
+- Cost reduction (no per-minute charges)
+- Direct recording access via Jibri
+- Real-time event webhooks
+- Full customization and control
+
+## Current Whereby Integration Analysis
+
+### Architecture
+1. **Room Creation**: User creates a "room" template in Reflector DB with settings
+2. **Meeting Creation**: `/rooms/{room_name}/meeting` endpoint calls Whereby API to create meeting
+3. **Recording**: Whereby handles recording automatically to S3 bucket
+4. **Webhooks**: Whereby sends events for participant tracking
+
+### Database Structure
+```python
+# Room = Template/Configuration
+class Room:
+    id, name, user_id
+    recording_type, recording_trigger  # cloud, automatic-2nd-participant
+    webhook_url, webhook_secret
+
+# Meeting = Actual Whereby Meeting Instance
+class Meeting:
+    id  # Whereby meetingId
+    room_name  # Generated by Whereby
+    room_url, host_room_url  # Whereby URLs
+    num_clients  # Updated via webhooks
+```
+
+## Jitsi Components
+
+### Core Architecture
+- **Jitsi Meet**: Web frontend (Next.js + React)
+- **Prosody**: XMPP server for messaging/rooms
+- **Jicofo**: Conference focus (orchestration)
+- **JVB**: Videobridge (media routing)
+- **Jibri**: Recording service
+- **Jigasi**: SIP gateway (optional, for phone dial-in)
+
+### Exposure Requirements
+- **Web service**: 443/80 (frontend)
+- **JVB**: 10000/UDP (media streams) - **MUST EXPOSE**
+- **Prosody**: 5280 (BOSH/WebSocket) - can proxy via web
+- **Jicofo, Jibri, Jigasi**: Internal only
+
+## Recording with Jibri
+
+### How Jibri Works
+- Each Jibri instance handles **one recording at a time**
+- Records mixed audio/video to MP4 format
+- Uses Chrome headless + ffmpeg for capture
+- Supports finalize scripts for post-processing
+
+### Jibri Pool for Scaling
+- Multiple Jibri instances join "jibribrewery" MUC
+- Jicofo distributes recording requests to available instances
+- Automatic load balancing and failover
+
+```yaml
+# Multiple Jibri instances
+jibri1:
+  environment:
+    - JIBRI_INSTANCE_ID=jibri1
+    - JIBRI_BREWERY_MUC=jibribrewery
+
+jibri2:
+  environment:
+    - JIBRI_INSTANCE_ID=jibri2
+    - JIBRI_BREWERY_MUC=jibribrewery
+```
+
+### Recording Automation Options
+1. **Environment Variables**: `ENABLE_RECORDING=1`, `AUTO_RECORDING=1`
+2. **URL Parameters**: `?config.autoRecord=true`
+3. **JWT Token**: Include recording permissions in JWT
+4. **API Control**: `api.executeCommand('startRecording')`
+
+### Post-Processing Integration
+```bash
+#!/bin/bash
+# finalize.sh - runs after recording completion
+RECORDING_FILE=$1
+MEETING_METADATA=$2
+ROOM_NAME=$3
+
+# Copy to Reflector-accessible location
+cp "$RECORDING_FILE" /shared/reflector-uploads/
+
+# Trigger Reflector processing
+curl -X POST "http://reflector-api:8000/v1/transcripts/process" \
+  -H "Content-Type: application/json" \
+  -d "{
+    \"file_path\": \"/shared/reflector-uploads/$(basename $RECORDING_FILE)\",
+    \"room_name\": \"$ROOM_NAME\",
+    \"source\": \"jitsi\"
+  }"
+```
+
+## React Integration
+
+### Official React SDK
+```bash
+npm i @jitsi/react-sdk
+```
+
+```jsx
+import { JitsiMeeting } from '@jitsi/react-sdk'
+
+<JitsiMeeting
+  room="meeting-room"
+  serverURL="https://your-jitsi.domain"
+  jwt="your-jwt-token"
+  config={{
+    startWithAudioMuted: true,
+    fileRecordingsEnabled: true,
+    autoRecord: true
+  }}
+  onParticipantJoined={(participant) => {
+    // Track participant events
+  }}
+  onRecordingStatusChanged={(status) => {
+    // Handle recording events
+  }}
+/>
+```
+
+## Authentication & Room Control
+
+### JWT-Based Access Control
+```python
+def generate_jitsi_jwt(payload):
+    return jwt.encode({
+        "aud": "jitsi",
+        "iss": "reflector",
+        "sub": "reflector-user",
+        "room": payload["room"],
+        "exp": int(payload["exp"].timestamp()),
+        "context": {
+            "user": {
+                "name": payload["user_name"],
+                "moderator": payload.get("moderator", False)
+            },
+            "features": {
+                "recording": payload.get("recording", True)
+            }
+        }
+    }, JITSI_JWT_SECRET)
+```
+
+### Prevent Anonymous Room Creation
+```bash
+# Environment configuration
+ENABLE_AUTH=1
+ENABLE_GUESTS=0
+AUTH_TYPE=jwt
+JWT_APP_ID=reflector
+JWT_APP_SECRET=your-secret-key
+```
+
+## Webhook Integration
+
+### Real-time Events via Prosody
+Custom event-sync module can send webhooks for:
+- Participant join/leave
+- Recording start/stop
+- Room creation/destruction
+- Mute/unmute events
+
+```lua
+-- mod_event_sync.lua
+module:hook("muc-occupant-joined", function(event)
+    send_event({
+        type = "participant_joined",
+        room = event.room.jid,
+        participant = {
+            nick = event.occupant.nick,
+            jid = event.occupant.jid,
+        },
+        timestamp = os.time(),
+    });
+end);
+```
+
+### Jibri Recording Webhooks
+```bash
+# Environment variable
+JIBRI_WEBHOOK_SUBSCRIBERS=https://your-reflector.com/webhooks/jibri
+```
+
+## Proposed Reflector Integration
+
+### Modified Database Schema
+```python
+class Meeting(BaseModel):
+    id: str  # Our generated meeting ID
+    room_name: str  # Generated: reflector-{room.name}-{timestamp}
+    room_url: str  # https://jitsi.domain/room_name?jwt=token
+    host_room_url: str  # Same but with moderator JWT
+    # Add Jitsi-specific fields
+    jitsi_jwt: str  # JWT token
+    jitsi_room_id: str  # Internal room identifier
+    recording_status: str  # pending, recording, completed
+    recording_file_path: Optional[str]
+```
+
+### API Replacement
+```python
+# Replace whereby.py with jitsi.py
+async def create_meeting(room_name_prefix: str, end_date: datetime, room: Room):
+    # Generate unique room name
+    jitsi_room = f"reflector-{room.name}-{int(time.time())}"
+
+    # Generate JWT tokens
+    user_jwt = generate_jwt(room=jitsi_room, moderator=False, exp=end_date)
+    host_jwt = generate_jwt(room=jitsi_room, moderator=True, exp=end_date)
+
+    return {
+        "meetingId": generate_uuid4(),  # Our ID
+        "roomName": jitsi_room,
+        "roomUrl": f"https://jitsi.domain/{jitsi_room}?jwt={user_jwt}",
+        "hostRoomUrl": f"https://jitsi.domain/{jitsi_room}?jwt={host_jwt}",
+        "startDate": datetime.now().isoformat(),
+        "endDate": end_date.isoformat(),
+    }
+```
+
+### Webhook Endpoints
+```python
+# Replace whereby webhook with jitsi webhooks
+@router.post("/jitsi/events")
+async def jitsi_events_webhook(event_data: dict):
+    event_type = event_data.get("event")
+    room_name = event_data.get("room", "").split("@")[0]
+
+    meeting = await Meeting.get_by_room(room_name)
+
+    if event_type == "muc-occupant-joined":
+        # Update participant count
+        meeting.num_clients += 1
+
+    elif event_type == "jibri-recording-on":
+        meeting.recording_status = "recording"
+
+    elif event_type == "jibri-recording-off":
+        meeting.recording_status = "processing"
+        await process_meeting_recording.delay(meeting.id)
+
+@router.post("/jibri/recording-complete")
+async def recording_complete(data: dict):
+    # Handle finalize script webhook
+    room_name = data.get("room_name")
+    file_path = data.get("file_path")
+
+    meeting = await Meeting.get_by_room(room_name)
+    meeting.recording_file_path = file_path
+    meeting.recording_status = "completed"
+
+    # Start Reflector processing
+    await process_recording_for_transcription(meeting.id, file_path)
+```
+
+## Deployment with Docker
+
+### Official docker-jitsi-meet
+```bash
+# Download official release
+wget $(wget -q -O - https://api.github.com/repos/jitsi/docker-jitsi-meet/releases/latest | grep zip | cut -d\" -f4)
+
+# Setup
+mkdir -p ~/.jitsi-meet-cfg/{web,transcripts,prosody/config,prosody/prosody-plugins-custom,jicofo,jvb,jigasi,jibri}
+./gen-passwords.sh  # Generate secure passwords
+docker compose up -d
+```
+
+### Coolify Integration
+```yaml
+services:
+  web:
+    ports: ["80:80", "443:443"]
+  jvb:
+    ports: ["10000:10000/udp"]  # Must expose for media
+  jibri1:
+    environment:
+      - JIBRI_INSTANCE_ID=jibri1
+      - JIBRI_FINALIZE_RECORDING_SCRIPT_PATH=/config/finalize.sh
+  jibri2:
+    environment:
+      - JIBRI_INSTANCE_ID=jibri2
+```
+
+## Benefits vs Whereby
+
+### Cost & Control
+✅ **No per-minute charges** - significant cost savings
+✅ **Full recording control** - direct file access
+✅ **Custom branding** - complete UI control
+✅ **Self-hosted** - no vendor lock-in
+
+### Technical Advantages
+✅ **Real-time events** - immediate webhook notifications
+✅ **Rich participant metadata** - detailed tracking
+✅ **JWT security** - token-based access with expiration
+✅ **Multiple recording formats** - audio-only options
+✅ **Scalable architecture** - horizontal Jibri scaling
+
+### Integration Benefits
+✅ **Same API surface** - minimal changes to existing code
+✅ **React SDK** - better frontend integration
+✅ **Direct processing** - no S3 download delays
+✅ **Event-driven architecture** - better real-time capabilities
+
+## Implementation Plan
+
+1. **Deploy Jitsi Stack** - Set up docker-jitsi-meet with multiple Jibri instances
+2. **Create jitsi.py** - Replace whereby.py with Jitsi API functions
+3. **Update Database** - Add Jitsi-specific fields to Meeting model
+4. **Webhook Integration** - Replace Whereby webhooks with Jitsi events
+5. **Frontend Updates** - Replace Whereby embed with Jitsi React SDK
+6. **Testing & Migration** - Gradual rollout with fallback to Whereby
+
+## Recording Limitations & Considerations
+
+### Current Limitations
+- **Mixed audio only** - Jibri doesn't separate participant tracks natively
+- **One recording per Jibri** - requires multiple instances for concurrent recordings
+- **Chrome dependency** - Jibri uses headless Chrome for recording
+
+### Metadata Capabilities
+✅ **Participant join/leave timestamps** - via webhooks
+✅ **Speaking time tracking** - via audio level events
+✅ **Meeting duration** - precise timing
+✅ **Room-specific data** - custom metadata in JWT
+
+### Alternative Recording Methods
+- **Local recording** - browser-based, per-participant
+- **Custom recording** - lib-jitsi-meet for individual streams
+- **Third-party solutions** - Recall.ai, Otter.ai integrations
+
+## Security Considerations
+
+### JWT Configuration
+- **Room-specific tokens** - limit access to specific rooms
+- **Time-based expiration** - automatic cleanup
+- **Feature permissions** - control recording, moderation rights
+- **User identification** - embed user metadata in tokens
+
+### Access Control
+- **No anonymous rooms** - all rooms require valid JWT
+- **API-only creation** - prevent direct room access
+- **Webhook verification** - HMAC signature validation
+
+## Next Steps
+
+1. **Deploy test Jitsi instance** - validate recording pipeline
+2. **Prototype jitsi.py** - create equivalent API functions
+3. **Test webhook integration** - ensure event delivery works
+4. **Performance testing** - validate multiple concurrent recordings
+5. **Migration strategy** - plan gradual transition from Whereby
+
+---
+
+*This document serves as the comprehensive planning and research notes for Jitsi integration in Reflector. It should be updated as implementation progresses and new insights are discovered.*
--- a/docs/transcript.md
+++ b/docs/transcript.md
@@ -1,241 +0,0 @@
-# Transcript Formats
-
-The Reflector API provides multiple output formats for transcript data through the `transcript_format` query parameter on the GET `/v1/transcripts/{id}` endpoint.
-
-## Overview
-
-When retrieving a transcript, you can specify the desired format using the `transcript_format` query parameter. The API supports four formats optimized for different use cases:
-
- **text** - Plain text with speaker names (default)
- **text-timestamped** - Timestamped text with speaker names
- **webvtt-named** - WebVTT subtitle format with participant names
- **json** - Structured JSON segments with full metadata
-
-All formats include participant information when available, resolving speaker IDs to actual names.
-
-## Query Parameter Usage
-
-```
-GET /v1/transcripts/{id}?transcript_format={format}
-```
-
-### Parameters
-
- `transcript_format` (optional): The desired output format
-  - Type: `"text" | "text-timestamped" | "webvtt-named" | "json"`
-  - Default: `"text"`
-
-## Format Descriptions
-
-### Text Format (`text`)
-
-**Use case:** Simple, human-readable transcript for display or export.
-
-**Format:** Speaker names followed by their dialogue, one line per segment.
-
-**Example:**
-```
-John Smith: Hello everyone
-Jane Doe: Hi there
-John Smith: How are you today?
-```
-
-**Request:**
-```bash
-GET /v1/transcripts/{id}?transcript_format=text
-```
-
-**Response:**
-```json
-{
-  "id": "transcript_123",
-  "name": "Meeting Recording",
-  "transcript_format": "text",
-  "transcript": "John Smith: Hello everyone\nJane Doe: Hi there\nJohn Smith: How are you today?",
-  "participants": [
-    {"id": "p1", "speaker": 0, "name": "John Smith"},
-    {"id": "p2", "speaker": 1, "name": "Jane Doe"}
-  ],
-  ...
-}
-```
-
-### Text Timestamped Format (`text-timestamped`)
-
-**Use case:** Transcript with timing information for navigation or reference.
-
-**Format:** `[MM:SS]` timestamp prefix before each speaker and dialogue.
-
-**Example:**
-```
-[00:00] John Smith: Hello everyone
-[00:05] Jane Doe: Hi there
-[00:12] John Smith: How are you today?
-```
-
-**Request:**
-```bash
-GET /v1/transcripts/{id}?transcript_format=text-timestamped
-```
-
-**Response:**
-```json
-{
-  "id": "transcript_123",
-  "name": "Meeting Recording",
-  "transcript_format": "text-timestamped",
-  "transcript": "[00:00] John Smith: Hello everyone\n[00:05] Jane Doe: Hi there\n[00:12] John Smith: How are you today?",
-  "participants": [
-    {"id": "p1", "speaker": 0, "name": "John Smith"},
-    {"id": "p2", "speaker": 1, "name": "Jane Doe"}
-  ],
-  ...
-}
-```
-
-### WebVTT Named Format (`webvtt-named`)
-
-**Use case:** Subtitle files for video players, accessibility tools, or video editing.
-
-**Format:** Standard WebVTT subtitle format with voice tags using participant names.
-
-**Example:**
-```
-WEBVTT
-
-00:00:00.000 --> 00:00:05.000
-<v John Smith>Hello everyone
-
-00:00:05.000 --> 00:00:12.000
-<v Jane Doe>Hi there
-
-00:00:12.000 --> 00:00:18.000
-<v John Smith>How are you today?
-```
-
-**Request:**
-```bash
-GET /v1/transcripts/{id}?transcript_format=webvtt-named
-```
-
-**Response:**
-```json
-{
-  "id": "transcript_123",
-  "name": "Meeting Recording",
-  "transcript_format": "webvtt-named",
-  "transcript": "WEBVTT\n\n00:00:00.000 --> 00:00:05.000\n<v John Smith>Hello everyone\n\n...",
-  "participants": [
-    {"id": "p1", "speaker": 0, "name": "John Smith"},
-    {"id": "p2", "speaker": 1, "name": "Jane Doe"}
-  ],
-  ...
-}
-```
-
-### JSON Format (`json`)
-
-**Use case:** Programmatic access with full timing and speaker metadata.
-
-**Format:** Array of segment objects with speaker information, text content, and precise timing.
-
-**Example:**
-```json
-[
-  {
-    "speaker": 0,
-    "speaker_name": "John Smith",
-    "text": "Hello everyone",
-    "start": 0.0,
-    "end": 5.0
-  },
-  {
-    "speaker": 1,
-    "speaker_name": "Jane Doe",
-    "text": "Hi there",
-    "start": 5.0,
-    "end": 12.0
-  },
-  {
-    "speaker": 0,
-    "speaker_name": "John Smith",
-    "text": "How are you today?",
-    "start": 12.0,
-    "end": 18.0
-  }
-]
-```
-
-**Request:**
-```bash
-GET /v1/transcripts/{id}?transcript_format=json
-```
-
-**Response:**
-```json
-{
-  "id": "transcript_123",
-  "name": "Meeting Recording",
-  "transcript_format": "json",
-  "transcript": [
-    {
-      "speaker": 0,
-      "speaker_name": "John Smith",
-      "text": "Hello everyone",
-      "start": 0.0,
-      "end": 5.0
-    },
-    {
-      "speaker": 1,
-      "speaker_name": "Jane Doe",
-      "text": "Hi there",
-      "start": 5.0,
-      "end": 12.0
-    }
-  ],
-  "participants": [
-    {"id": "p1", "speaker": 0, "name": "John Smith"},
-    {"id": "p2", "speaker": 1, "name": "Jane Doe"}
-  ],
-  ...
-}
-```
-
-## Response Structure
-
-All formats return the same base transcript metadata with an additional `transcript_format` field and format-specific `transcript` field:
-
-### Common Fields
-
- `id`: Transcript identifier
- `user_id`: Owner user ID (if authenticated)
- `name`: Transcript name
- `status`: Processing status
- `locked`: Whether transcript is locked for editing
- `duration`: Total duration in seconds
- `title`: Auto-generated or custom title
- `short_summary`: Brief summary
- `long_summary`: Detailed summary
- `created_at`: Creation timestamp
- `share_mode`: Access control setting
- `source_language`: Original audio language
- `target_language`: Translation target language
- `reviewed`: Whether transcript has been reviewed
- `meeting_id`: Associated meeting ID (if applicable)
- `source_kind`: Source type (live, file, room)
- `room_id`: Associated room ID (if applicable)
- `audio_deleted`: Whether audio has been deleted
- `participants`: Array of participant objects with speaker mappings
-
-### Format-Specific Fields
-
- `transcript_format`: The format identifier (discriminator field)
- `transcript`: The formatted transcript content (string for text/webvtt formats, array for json format)
-
-## Speaker Name Resolution
-
-All formats resolve speaker IDs to participant names when available:
-
- If a participant exists for the speaker ID, their name is used
- If no participant exists, a default name like "Speaker 0" is generated
- Speaker IDs are integers (0, 1, 2, etc.) assigned during diarization
--- a/docs/video-jitsi.md
+++ b/docs/video-jitsi.md
@@ -0,0 +1,720 @@
+# Jitsi Meet Integration Configuration Guide
+
+This guide explains how to configure Reflector to use your self-hosted Jitsi Meet installation for video meetings, recording, and participant tracking.
+
+## Overview
+
+Jitsi Meet is an open-source video conferencing platform that can be self-hosted. Reflector integrates with Jitsi Meet to:
+
+- Create secure meeting rooms with JWT authentication
+- Track participant join/leave events via Prosody webhooks
+- Record meetings using Jibri recording service
+- Process recordings for transcription and analysis
+
+## Requirements
+
+### Self-Hosted Jitsi Meet
+
+You need a complete Jitsi Meet installation including:
+
+1. **Jitsi Meet Web Interface** - The main meeting interface
+2. **Prosody XMPP Server** - Handles room management and authentication
+3. **Jicofo (JItsi COnference FOcus)** - Manages media sessions
+4. **Jitsi Videobridge (JVB)** - Handles WebRTC media routing
+5. **Jibri Recording Service** - Records meetings (optional but recommended)
+
+### System Requirements
+
+- **Domain with SSL Certificate** - Required for WebRTC functionality
+- **Prosody mod_event_sync** - For webhook event handling
+- **JWT Authentication** - For secure room access control
+- **Storage Solution** - For recording files (local or cloud)
+
+## Configuration Variables
+
+Add the following environment variables to your Reflector `.env` file:
+
+### Required Variables
+
+```bash
+# Jitsi Meet Domain (without https://)
+JITSI_DOMAIN=meet.example.com
+
+# JWT Secret for room authentication (generate with: openssl rand -hex 32)
+JITSI_JWT_SECRET=your-64-character-hex-secret-here
+
+# Webhook secret for event handling (generate with: openssl rand -hex 16)
+JITSI_WEBHOOK_SECRET=your-32-character-hex-secret-here
+```
+
+### Optional Variables
+
+```bash
+# Application identifier (should match Jitsi configuration)
+JITSI_APP_ID=reflector
+
+# JWT issuer and audience (should match Jitsi configuration)
+JITSI_JWT_ISSUER=reflector
+JITSI_JWT_AUDIENCE=jitsi
+```
+
+## Installation Steps
+
+### 1. Jitsi Meet Server Installation
+
+#### Quick Installation (Ubuntu/Debian)
+
+```bash
+# Add Jitsi repository
+curl -fsSL https://download.jitsi.org/jitsi-key.gpg.key | sudo gpg --dearmor -o /usr/share/keyrings/jitsi-keyring.gpg
+echo "deb [signed-by=/usr/share/keyrings/jitsi-keyring.gpg] https://download.jitsi.org stable/" | sudo tee /etc/apt/sources.list.d/jitsi-stable.list
+
+# Install Jitsi Meet
+sudo apt update
+sudo apt install jitsi-meet
+
+# Configure SSL certificate
+sudo /usr/share/jitsi-meet/scripts/install-letsencrypt-cert.sh
+```
+
+#### Docker Installation
+
+```bash
+# Clone Jitsi Docker repository
+git clone https://github.com/jitsi/docker-jitsi-meet
+cd docker-jitsi-meet
+
+# Copy environment template
+cp env.example .env
+
+# Edit configuration
+nano .env
+
+# Start services
+docker-compose up -d
+```
+
+### 2. JWT Authentication Setup
+
+#### Update Prosody Configuration
+
+Edit `/etc/prosody/conf.d/your-domain.cfg.lua`:
+
+```lua
+VirtualHost "meet.example.com"
+    authentication = "token"
+    app_id = "reflector"
+    app_secret = "your-jwt-secret-here"
+
+    -- Allow anonymous access for guests
+    c2s_require_encryption = false
+    admins = { "focusUser@auth.meet.example.com" }
+
+    modules_enabled = {
+        "bosh";
+        "pubsub";
+        "ping";
+        "roster";
+        "saslauth";
+        "tls";
+        "dialback";
+        "disco";
+        "carbons";
+        "pep";
+        "private";
+        "blocklist";
+        "vcard";
+        "version";
+        "uptime";
+        "time";
+        "ping";
+        "register";
+        "admin_adhoc";
+        "token_verification";
+        "event_sync";  -- Required for webhooks
+    }
+```
+
+#### Configure Jitsi Meet Interface
+
+Edit `/etc/jitsi/meet/your-domain-config.js`:
+
+```javascript
+var config = {
+    hosts: {
+        domain: 'meet.example.com',
+        muc: 'conference.meet.example.com'
+    },
+
+    // Enable JWT authentication
+    enableUserRolesBasedOnToken: true,
+
+    // Recording configuration
+    fileRecordingsEnabled: true,
+    liveStreamingEnabled: false,
+
+    // Reflector integration settings
+    prejoinPageEnabled: true,
+    requireDisplayName: true
+};
+```
+
+### 3. Webhook Event Configuration
+
+#### Install Event Sync Module
+
+```bash
+# Download the module
+cd /usr/share/jitsi-meet/prosody-plugins/
+wget https://raw.githubusercontent.com/jitsi-contrib/prosody-plugins/main/mod_event_sync.lua
+```
+
+#### Configure Event Sync
+
+Add to your Prosody configuration:
+
+```lua
+Component "conference.meet.example.com" "muc"
+    storage = "memory"
+    modules_enabled = {
+        "muc_meeting_id";
+        "muc_domain_mapper";
+        "polls";
+        "event_sync";  -- Enable event sync
+    }
+
+    -- Event sync webhook configuration
+    event_sync_url = "https://your-reflector-domain.com/v1/jitsi/events"
+    event_sync_secret = "your-webhook-secret-here"
+
+    -- Events to track
+    event_sync_events = {
+        "muc-occupant-joined",
+        "muc-occupant-left",
+        "jibri-recording-on",
+        "jibri-recording-off"
+    }
+
+#### Webhook Event Payload Examples
+
+**Participant Joined Event:**
+```json
+{
+  "event": "muc-occupant-joined",
+  "room": "reflector-my-room-uuid123",
+  "timestamp": "2025-01-15T10:30:00.000Z",
+  "data": {
+    "occupant_id": "participant-456",
+    "nick": "John Doe",
+    "role": "participant",
+    "affiliation": "none"
+  }
+}
+```
+
+**Recording Started Event:**
+```json
+{
+  "event": "jibri-recording-on",
+  "room": "reflector-my-room-uuid123",
+  "timestamp": "2025-01-15T10:32:00.000Z",
+  "data": {
+    "recording_id": "rec-789",
+    "initiator": "moderator-123"
+  }
+}
+```
+
+**Recording Completed Event:**
+```json
+{
+  "room_name": "reflector-my-room-uuid123",
+  "recording_file": "/var/recordings/rec-789.mp4",
+  "recording_status": "completed",
+  "timestamp": "2025-01-15T11:15:00.000Z"
+}
+```
+
+### 4. Jibri Recording Setup (Optional)
+
+#### Install Jibri
+
+```bash
+# Install Jibri package
+sudo apt install jibri
+
+# Create recording directory
+sudo mkdir -p /var/recordings
+sudo chown jibri:jibri /var/recordings
+```
+
+#### Configure Jibri
+
+Edit `/etc/jitsi/jibri/jibri.conf`:
+
+```hocon
+jibri {
+    recording {
+        recordings-directory = "/var/recordings"
+        finalize-script = "/opt/jitsi/jibri/finalize.sh"
+    }
+
+    api {
+        xmpp {
+            environments = [{
+                name = "prod environment"
+                xmpp-server-hosts = ["meet.example.com"]
+                xmpp-domain = "meet.example.com"
+
+                control-muc {
+                    domain = "internal.auth.meet.example.com"
+                    room-name = "JibriBrewery"
+                    nickname = "jibri-nickname"
+                }
+
+                control-login {
+                    domain = "auth.meet.example.com"
+                    username = "jibri"
+                    password = "jibri-password"
+                }
+            }]
+        }
+    }
+}
+```
+
+#### Create Finalize Script
+
+Create `/opt/jitsi/jibri/finalize.sh`:
+
+```bash
+#!/bin/bash
+# Jibri finalize script for Reflector integration
+
+RECORDING_FILE="$1"
+ROOM_NAME="$2"
+REFLECTOR_API_URL="${REFLECTOR_API_URL:-http://localhost:1250}"
+
+# Prepare webhook payload
+TIMESTAMP=$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)
+PAYLOAD=$(cat <<EOF
+{
+    "room_name": "$ROOM_NAME",
+    "recording_file": "$RECORDING_FILE",
+    "recording_status": "completed",
+    "timestamp": "$TIMESTAMP"
+}
+EOF
+)
+
+# Generate signature
+SIGNATURE=$(echo -n "$PAYLOAD" | openssl dgst -sha256 -hmac "$JITSI_WEBHOOK_SECRET" | cut -d' ' -f2)
+
+# Send webhook to Reflector
+curl -X POST "$REFLECTOR_API_URL/v1/jibri/recording-complete" \
+    -H "Content-Type: application/json" \
+    -H "X-Jitsi-Signature: $SIGNATURE" \
+    -d "$PAYLOAD"
+
+echo "Recording finalization webhook sent for room: $ROOM_NAME"
+```
+
+Make executable:
+```bash
+sudo chmod +x /opt/jitsi/jibri/finalize.sh
+```
+
+### 5. Restart Services
+
+After configuration changes:
+
+```bash
+sudo systemctl restart prosody
+sudo systemctl restart jicofo
+sudo systemctl restart jitsi-videobridge2
+sudo systemctl restart jibri
+sudo systemctl restart nginx
+```
+
+## Room Configuration
+
+### Creating Jitsi Rooms
+
+Create rooms with Jitsi platform in Reflector:
+
+```bash
+curl -X POST "https://your-reflector-domain.com/v1/rooms" \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $AUTH_TOKEN" \
+  -d '{
+    "name": "my-jitsi-room",
+    "platform": "jitsi",
+    "recording_type": "cloud",
+    "recording_trigger": "automatic-2nd-participant",
+    "is_locked": false,
+    "room_mode": "normal"
+  }'
+```
+
+### Meeting Creation
+
+Meetings automatically use JWT authentication:
+
+```bash
+curl -X POST "https://your-reflector-domain.com/v1/rooms/my-jitsi-room/meeting" \
+  -H "Authorization: Bearer $AUTH_TOKEN"
+```
+
+Response includes JWT-authenticated URLs:
+```json
+{
+  "id": "meeting-uuid",
+  "room_name": "reflector-my-jitsi-room-123456",
+  "room_url": "https://meet.example.com/room?jwt=user-token",
+  "host_room_url": "https://meet.example.com/room?jwt=moderator-token"
+}
+```
+
+## Features and Capabilities
+
+### JWT Authentication
+
+Reflector automatically generates JWT tokens with:
+- **Room Access Control** - Secure room entry
+- **User Roles** - Moderator vs participant permissions
+- **Expiration** - Configurable token lifetime (default 8 hours)
+- **Custom Claims** - Room-specific metadata
+
+### Recording Options
+
+**Recording Types:**
+- `"none"` - No recording
+- `"local"` - Local Jibri recording
+- `"cloud"` - Cloud recording (requires external storage)
+
+**Recording Triggers:**
+- `"none"` - Manual recording only
+- `"prompt"` - Prompt users to start
+- `"automatic"` - Start immediately
+- `"automatic-2nd-participant"` - Start when 2nd person joins
+
+### Event Tracking and Storage
+
+Reflector automatically stores all webhook events in the `meetings` table for comprehensive meeting analytics:
+
+**Supported Event Types:**
+- `muc-occupant-joined` - Participant joined the meeting
+- `muc-occupant-left` - Participant left the meeting
+- `jibri-recording-on` - Recording started
+- `jibri-recording-off` - Recording stopped
+- `recording_completed` - Recording file ready for processing
+
+**Event Storage Structure:**
+Each webhook event is stored as a JSON object in the `meetings.events` column:
+```json
+{
+  "type": "muc-occupant-joined",
+  "timestamp": "2025-01-15T10:30:00.123456Z",
+  "data": {
+    "timestamp": "2025-01-15T10:30:00Z",
+    "user_id": "participant-123",
+    "display_name": "John Doe"
+  }
+}
+```
+
+**Querying Stored Events:**
+```sql
+-- Get all events for a meeting
+SELECT events FROM meeting WHERE id = 'meeting-uuid';
+
+-- Count participant joins
+SELECT json_array_length(
+  json_extract(events, '$[*] ? (@.type == "muc-occupant-joined")')
+) as total_joins FROM meeting WHERE id = 'meeting-uuid';
+```
+
+## Testing and Verification
+
+### Health Check
+
+Test Jitsi webhook integration:
+
+```bash
+curl "https://your-reflector-domain.com/v1/jitsi/health"
+```
+
+Expected response:
+```json
+{
+    "status": "ok",
+    "service": "jitsi-webhooks",
+    "timestamp": "2025-01-15T10:30:00.000Z",
+    "webhook_secret_configured": true
+}
+```
+
+### JWT Token Testing
+
+Verify JWT generation works:
+```bash
+# Create a test meeting
+MEETING=$(curl -X POST "https://your-reflector-domain.com/v1/rooms/test-room/meeting" \
+  -H "Authorization: Bearer $AUTH_TOKEN" | jq -r '.room_url')
+
+echo "Test meeting URL: $MEETING"
+```
+
+### Webhook Testing
+
+#### Manual Webhook Event Testing
+
+Test participant join event:
+```bash
+# Generate proper signature
+PAYLOAD='{"event":"muc-occupant-joined","room":"reflector-test-room-uuid","timestamp":"2025-01-15T10:30:00.000Z","data":{"user_id":"test-user","display_name":"Test User"}}'
+SIGNATURE=$(echo -n "$PAYLOAD" | openssl dgst -sha256 -hmac "$JITSI_WEBHOOK_SECRET" | cut -d' ' -f2)
+
+curl -X POST "https://your-reflector-domain.com/v1/jitsi/events" \
+  -H "Content-Type: application/json" \
+  -H "X-Jitsi-Signature: $SIGNATURE" \
+  -d "$PAYLOAD"
+```
+
+Expected response:
+```json
+{
+  "status": "ok",
+  "event": "muc-occupant-joined",
+  "room": "reflector-test-room-uuid"
+}
+```
+
+#### Recording Webhook Testing
+
+Test recording completion event:
+```bash
+PAYLOAD='{"room_name":"reflector-test-room-uuid","recording_file":"/recordings/test.mp4","recording_status":"completed","timestamp":"2025-01-15T10:30:00.000Z"}'
+SIGNATURE=$(echo -n "$PAYLOAD" | openssl dgst -sha256 -hmac "$JITSI_WEBHOOK_SECRET" | cut -d' ' -f2)
+
+curl -X POST "https://your-reflector-domain.com/v1/jibri/recording-complete" \
+  -H "Content-Type: application/json" \
+  -H "X-Jitsi-Signature: $SIGNATURE" \
+  -d "$PAYLOAD"
+```
+
+#### Event Storage Verification
+
+Verify events were stored:
+```bash
+# Check meeting events via API (requires authentication)
+curl -H "Authorization: Bearer $AUTH_TOKEN" \
+  "https://your-reflector-domain.com/v1/meetings/{meeting-id}"
+```
+
+## Troubleshooting
+
+### Common Issues
+
+#### JWT Authentication Failures
+
+**Symptoms**: Users cannot join rooms, "Authentication failed" errors
+
+**Solutions**:
+1. Verify `JITSI_JWT_SECRET` matches Prosody configuration
+2. Check JWT token hasn't expired (default 8 hours)
+3. Ensure system clocks are synchronized between servers
+4. Validate JWT issuer/audience configuration matches
+
+**Debug JWT tokens**:
+```bash
+# Decode JWT payload
+echo "JWT_TOKEN_HERE" | cut -d'.' -f2 | base64 -d | jq
+```
+
+#### Webhook Events Not Received
+
+**Symptoms**: Participant counts not updating, no recording events
+
+**Solutions**:
+1. Verify `mod_event_sync` is loaded in Prosody
+2. Check webhook URL is accessible from Jitsi server
+3. Validate webhook signature generation
+4. Review Prosody and Reflector logs
+
+**Debug webhook connectivity**:
+```bash
+# Test from Jitsi server
+curl -v "https://your-reflector-domain.com/v1/jitsi/health"
+
+# Check Prosody logs
+sudo tail -f /var/log/prosody/prosody.log
+```
+
+#### Webhook Signature Verification Issues
+
+**Symptoms**: HTTP 401 "Invalid webhook signature" errors
+
+**Solutions**:
+1. Verify webhook secret matches between Jitsi and Reflector
+2. Check payload encoding (no extra whitespace)
+3. Ensure proper HMAC-SHA256 signature generation
+
+**Debug signature generation**:
+```bash
+# Test signature manually
+PAYLOAD='{"event":"test","room":"test","timestamp":"2025-01-15T10:30:00.000Z","data":{}}'
+SECRET="your-webhook-secret-here"
+
+# Generate signature (should match X-Jitsi-Signature header)
+echo -n "$PAYLOAD" | openssl dgst -sha256 -hmac "$SECRET" | cut -d' ' -f2
+
+# Test with curl
+curl -X POST "https://your-reflector-domain.com/v1/jitsi/events" \
+  -H "Content-Type: application/json" \
+  -H "X-Jitsi-Signature: $(echo -n "$PAYLOAD" | openssl dgst -sha256 -hmac "$SECRET" | cut -d' ' -f2)" \
+  -d "$PAYLOAD" -v
+```
+
+#### Event Storage Problems
+
+**Symptoms**: Events received but not stored in database
+
+**Solutions**:
+1. Check database connectivity and permissions
+2. Verify meeting exists before event processing
+3. Review Reflector application logs
+4. Ensure JSON column support in database
+
+**Debug event storage**:
+```bash
+# Check meeting exists
+curl -H "Authorization: Bearer $TOKEN" \
+  "https://your-reflector-domain.com/v1/meetings/{meeting-id}"
+
+# Monitor database queries (if using PostgreSQL)
+sudo -u postgres psql -c "SELECT * FROM pg_stat_activity WHERE query LIKE '%meeting%';"
+
+# Check Reflector logs for event processing
+sudo journalctl -u reflector -f | grep -E "(event|webhook|jitsi)"
+```
+
+#### Recording Issues
+
+**Symptoms**: Recordings not starting, finalize script errors
+
+**Solutions**:
+1. Verify Jibri service status: `sudo systemctl status jibri`
+2. Check recording directory permissions: `/var/recordings`
+3. Validate finalize script execution permissions
+4. Monitor Jibri logs: `sudo journalctl -u jibri -f`
+
+**Test finalize script**:
+```bash
+sudo -u jibri /opt/jitsi/jibri/finalize.sh "/test/recording.mp4" "test-room"
+```
+
+#### Meeting Creation Failures
+
+**Symptoms**: HTTP 500 errors when creating meetings
+
+**Solutions**:
+1. Check Reflector logs for JWT generation errors
+2. Verify all required environment variables are set
+3. Ensure Jitsi domain is accessible from Reflector
+4. Test JWT secret configuration
+
+### Debug Commands
+
+```bash
+# Verify Prosody configuration
+sudo prosodyctl check config
+
+# Check Jitsi services status
+sudo systemctl status prosody jicofo jitsi-videobridge2
+
+# Test JWT generation
+curl -X POST "https://your-reflector-domain.com/v1/rooms/test/meeting" \
+  -H "Authorization: Bearer $TOKEN" -v
+
+# Monitor webhook events
+sudo tail -f /var/log/reflector/app.log | grep jitsi
+
+# Check SSL certificates
+sudo certbot certificates
+```
+
+### Performance Optimization
+
+#### Scaling Considerations
+
+**Single Server Limits:**
+- ~50 concurrent participants per JVB instance
+- ~10 concurrent Jibri recordings
+- CPU and bandwidth become bottlenecks
+
+**Multi-Server Setup:**
+- Multiple JVB instances for scaling
+- Dedicated Jibri recording servers
+- Load balancing for high availability
+
+#### Resource Monitoring
+
+```bash
+# Monitor JVB performance
+sudo systemctl status jitsi-videobridge2
+sudo journalctl -u jitsi-videobridge2 -f
+
+# Check Prosody connections
+sudo prosodyctl mod_admin_telnet
+> c2s:show()
+> muc:rooms()
+```
+
+## Security Best Practices
+
+### JWT Security
+- Use strong, unique secrets (32+ characters)
+- Rotate JWT secrets regularly
+- Implement proper token expiration
+- Never log or expose JWT tokens
+
+### Network Security
+- Use HTTPS/WSS for all communications
+- Implement proper firewall rules
+- Consider VPN for server-to-server communication
+- Monitor for unauthorized access attempts
+
+### Recording Security
+- Encrypt recordings at rest
+- Implement access controls for recording files
+- Regular security audits of file permissions
+- Comply with data protection regulations
+
+## Migration from Whereby
+
+If migrating from Whereby to Jitsi:
+
+1. **Parallel Setup** - Configure Jitsi alongside existing Whereby
+2. **Room Migration** - Update room platform field to "jitsi"
+3. **Test Integration** - Verify meeting creation and webhooks
+4. **User Training** - Different UI and feature set
+5. **Monitor Performance** - Watch for issues during transition
+6. **Cleanup** - Remove Whereby configuration when stable
+
+## Support and Resources
+
+### Jitsi Community Resources
+- **Documentation**: [jitsi.github.io/handbook](https://jitsi.github.io/handbook/)
+- **Community Forum**: [community.jitsi.org](https://community.jitsi.org/)
+- **GitHub Issues**: [github.com/jitsi/jitsi-meet](https://github.com/jitsi/jitsi-meet)
+
+### Professional Support
+- **8x8 Commercial Support** - Professional Jitsi hosting and support
+- **Community Consulting** - Third-party Jitsi implementation services
+
+### Monitoring and Maintenance
+- Monitor system resources (CPU, memory, bandwidth)
+- Regular security updates for all components
+- Backup configuration files and certificates
+- Test disaster recovery procedures
--- a/docs/video-whereby.md
+++ b/docs/video-whereby.md
@@ -0,0 +1,276 @@
+# Whereby Integration Configuration Guide
+
+This guide explains how to configure Reflector to use Whereby as your video meeting platform for room creation, recording, and participant tracking.
+
+## Overview
+
+Whereby is a browser-based video meeting platform that provides hosted meeting rooms with recording capabilities. Reflector integrates with Whereby's API to:
+
+- Create secure meeting rooms with custom branding
+- Handle participant join/leave events via webhooks
+- Automatically record meetings to AWS S3 storage
+- Track meeting sessions and participant counts
+
+## Requirements
+
+### Whereby Account Setup
+
+1. **Whereby Account**: Sign up for a Whereby business account at [whereby.com](https://whereby.com/business)
+2. **API Access**: Request API access from Whereby support (required for programmatic room creation)
+3. **Webhook Configuration**: Configure webhooks in your Whereby dashboard to point to your Reflector instance
+
+### AWS S3 Storage
+
+Whereby requires AWS S3 for recording storage. You need:
+- AWS account with S3 access
+- Dedicated S3 bucket for Whereby recordings
+- AWS IAM credentials with S3 write permissions
+
+## Configuration Variables
+
+Add the following environment variables to your Reflector `.env` file:
+
+### Required Variables
+
+```bash
+# Whereby API Configuration
+WHEREBY_API_KEY=your-whereby-jwt-api-key
+WHEREBY_WEBHOOK_SECRET=your-webhook-secret-from-whereby
+
+# AWS S3 Storage for Recordings
+AWS_WHEREBY_ACCESS_KEY_ID=your-aws-access-key
+AWS_WHEREBY_ACCESS_KEY_SECRET=your-aws-secret-key
+RECORDING_STORAGE_AWS_BUCKET_NAME=your-s3-bucket-name
+```
+
+### Optional Variables
+
+```bash
+# Whereby API URL (defaults to production)
+WHEREBY_API_URL=https://api.whereby.dev/v1
+
+# SQS Configuration (for recording processing)
+AWS_PROCESS_RECORDING_QUEUE_URL=https://sqs.region.amazonaws.com/account/queue
+SQS_POLLING_TIMEOUT_SECONDS=60
+```
+
+## Configuration Steps
+
+### 1. Whereby API Key Setup
+
+1. **Contact Whereby Support** to request API access for your account
+2. **Generate JWT Token** in your Whereby dashboard under API settings
+3. **Copy the JWT token** and set it as `WHEREBY_API_KEY` in your environment
+
+The API key is a JWT token that looks like:
+```
+eyJ[...truncated JWT token...]
+```
+
+### 2. Webhook Configuration
+
+1. **Access Whereby Dashboard** and navigate to webhook settings
+2. **Set Webhook URL** to your Reflector instance:
+   ```
+   https://your-reflector-domain.com/v1/whereby
+   ```
+3. **Configure Events** to send the following event types:
+   - `room.client.joined` - When participants join
+   - `room.client.left` - When participants leave
+4. **Generate Webhook Secret** and set it as `WHEREBY_WEBHOOK_SECRET`
+5. **Save Configuration** in your Whereby dashboard
+
+### 3. AWS S3 Storage Setup
+
+1. **Create S3 Bucket** dedicated for Whereby recordings
+2. **Create IAM User** with programmatic access
+3. **Attach S3 Policy** with the following permissions:
+   ```json
+   {
+     "Version": "2012-10-17",
+     "Statement": [
+       {
+         "Effect": "Allow",
+         "Action": [
+           "s3:PutObject",
+           "s3:PutObjectAcl",
+           "s3:GetObject"
+         ],
+         "Resource": "arn:aws:s3:::your-bucket-name/*"
+       }
+     ]
+   }
+   ```
+4. **Configure Environment Variables** with the IAM credentials
+
+### 4. Room Configuration
+
+When creating rooms in Reflector, set the platform to use Whereby:
+
+```bash
+curl -X POST "https://your-reflector-domain.com/v1/rooms" \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $AUTH_TOKEN" \
+  -d '{
+    "name": "my-whereby-room",
+    "platform": "whereby",
+    "recording_type": "cloud",
+    "recording_trigger": "automatic-2nd-participant",
+    "is_locked": false,
+    "room_mode": "normal"
+  }'
+```
+
+## Meeting Features
+
+### Recording Options
+
+Whereby supports three recording types:
+- **`none`**: No recording
+- **`local`**: Local recording (not recommended for production)
+- **`cloud`**: Cloud recording to S3 (recommended)
+
+### Recording Triggers
+
+Control when recordings start:
+- **`none`**: No automatic recording
+- **`prompt`**: Prompt users to start recording
+- **`automatic`**: Start immediately when meeting begins
+- **`automatic-2nd-participant`**: Start when second participant joins
+
+### Room Modes
+
+- **`normal`**: Standard meeting room
+- **`group`**: Group meeting with advanced features
+
+## Webhook Event Handling
+
+Reflector automatically handles these Whereby webhook events:
+
+### Participant Tracking
+```json
+{
+  "type": "room.client.joined",
+  "data": {
+    "meetingId": "room-uuid",
+    "numClients": 2
+  }
+}
+```
+
+### Recording Events
+Whereby sends recording completion events that trigger Reflector's processing pipeline:
+- Audio transcription
+- Speaker diarization
+- Summary generation
+
+## Troubleshooting
+
+### Common Issues
+
+#### API Authentication Errors
+**Symptoms**: 401 Unauthorized errors when creating meetings
+
+**Solutions**:
+1. Verify your `WHEREBY_API_KEY` is correct and not expired
+2. Ensure you have API access enabled on your Whereby account
+3. Contact Whereby support if API access is not available
+
+#### Webhook Signature Validation Failed
+**Symptoms**: Webhook events rejected with 401 errors
+
+**Solutions**:
+1. Verify `WHEREBY_WEBHOOK_SECRET` matches your Whereby dashboard configuration
+2. Check webhook URL is correctly configured in Whereby dashboard
+3. Ensure webhook endpoint is accessible from Whereby servers
+
+#### Recording Upload Failures
+**Symptoms**: Recordings not appearing in S3 bucket
+
+**Solutions**:
+1. Verify AWS credentials have S3 write permissions
+2. Check S3 bucket name is correct and accessible
+3. Ensure AWS region settings match your bucket location
+4. Review AWS CloudTrail logs for permission issues
+
+#### Participant Count Not Updating
+**Symptoms**: Meeting participant counts remain at 0
+
+**Solutions**:
+1. Verify webhook events are being received at `/v1/whereby`
+2. Check webhook signature validation is passing
+3. Ensure meeting IDs match between Whereby and Reflector database
+
+### Debug Commands
+
+```bash
+# Test Whereby API connectivity
+curl -H "Authorization: Bearer $WHEREBY_API_KEY" \
+  https://api.whereby.dev/v1/meetings
+
+# Check webhook endpoint health
+curl https://your-reflector-domain.com/v1/whereby/health
+
+# Verify S3 bucket access
+aws s3 ls s3://your-bucket-name --profile whereby-user
+```
+
+## Security Considerations
+
+### API Key Security
+- Store API keys securely using environment variables
+- Rotate API keys regularly
+- Never commit API keys to version control
+- Use separate keys for development and production
+
+### Webhook Security
+- Always validate webhook signatures using HMAC-SHA256
+- Use HTTPS for all webhook endpoints
+- Implement rate limiting on webhook endpoints
+- Monitor webhook events for suspicious activity
+
+### Recording Privacy
+- Ensure S3 bucket access is restricted to authorized users
+- Consider encryption at rest for sensitive recordings
+- Implement retention policies for recorded content
+- Comply with data protection regulations (GDPR, etc.)
+
+## Performance Optimization
+
+### Meeting Scaling
+- Monitor concurrent meeting limits on your Whereby plan
+- Implement meeting cleanup for expired sessions
+- Use appropriate room modes for different use cases
+
+### Recording Processing
+- Configure SQS for asynchronous recording processing
+- Monitor S3 storage usage and costs
+- Implement automatic cleanup of processed recordings
+
+### Webhook Reliability
+- Implement webhook retry mechanisms
+- Monitor webhook delivery success rates
+- Log webhook events for debugging and auditing
+
+## Migration from Other Platforms
+
+If migrating from another video platform:
+
+1. **Update Room Configuration**: Change existing rooms to use `"platform": "whereby"`
+2. **Configure Webhooks**: Set up Whereby webhook endpoints
+3. **Test Integration**: Verify meeting creation and event handling
+4. **Monitor Performance**: Watch for any issues during transition
+5. **Update Documentation**: Inform users of any workflow changes
+
+## Support
+
+For Whereby-specific issues:
+- **Whereby Support**: [whereby.com/support](https://whereby.com/support)
+- **API Documentation**: [whereby.dev](https://whereby.dev)
+- **Status Page**: [status.whereby.com](https://status.whereby.com)
+
+For Reflector integration issues:
+- Check application logs for error details
+- Verify environment variable configuration
+- Test webhook connectivity and authentication
+- Review AWS permissions and S3 access
--- a/docs/video_platforms.md
+++ b/docs/video_platforms.md
@@ -0,0 +1,474 @@
+# Video Platforms Architecture (PR #529 Analysis)
+
+This document analyzes the video platforms refactoring implemented in PR #529 for daily.co integration, providing a blueprint for extending support to Jitsi and other video conferencing platforms.
+
+## Overview
+
+The video platforms refactoring introduces a clean abstraction layer that allows Reflector to support multiple video conferencing providers (Whereby, Daily.co, etc.) without changing core application logic. This architecture enables:
+
+- Seamless switching between video platforms
+- Platform-specific feature support
+- Isolated platform code organization
+- Consistent API surface across platforms
+- Feature flags for gradual migration
+
+## Architecture Components
+
+### 1. **Directory Structure**
+
+```
+server/reflector/video_platforms/
+├── __init__.py              # Public API exports
+├── base.py                  # Abstract base classes
+├── factory.py               # Platform client factory
+├── registry.py              # Platform registration system
+├── whereby.py               # Whereby implementation
+├── daily.py                 # Daily.co implementation
+└── mock.py                  # Testing implementation
+```
+
+### 2. **Core Abstract Classes**
+
+#### `VideoPlatformClient` (base.py)
+Abstract base class defining the interface all platforms must implement:
+
+```python
+class VideoPlatformClient(ABC):
+    PLATFORM_NAME: str = ""
+
+    @abstractmethod
+    async def create_meeting(self, room_name_prefix: str, end_date: datetime, room: Room) -> MeetingData
+
+    @abstractmethod
+    async def get_room_sessions(self, room_name: str) -> Dict[str, Any]
+
+    @abstractmethod
+    async def delete_room(self, room_name: str) -> bool
+
+    @abstractmethod
+    async def upload_logo(self, room_name: str, logo_path: str) -> bool
+
+    @abstractmethod
+    def verify_webhook_signature(self, body: bytes, signature: str, timestamp: Optional[str] = None) -> bool
+```
+
+#### `MeetingData` (base.py)
+Standardized meeting data structure returned by all platforms:
+
+```python
+class MeetingData(BaseModel):
+    meeting_id: str
+    room_name: str
+    room_url: str
+    host_room_url: str
+    platform: str
+    extra_data: Dict[str, Any] = {}  # Platform-specific data
+```
+
+#### `VideoPlatformConfig` (base.py)
+Unified configuration structure for all platforms:
+
+```python
+class VideoPlatformConfig(BaseModel):
+    api_key: str
+    webhook_secret: str
+    api_url: Optional[str] = None
+    subdomain: Optional[str] = None
+    s3_bucket: Optional[str] = None
+    s3_region: Optional[str] = None
+    aws_role_arn: Optional[str] = None
+    aws_access_key_id: Optional[str] = None
+    aws_access_key_secret: Optional[str] = None
+```
+
+### 3. **Platform Registration System**
+
+#### Registry Pattern (registry.py)
+- Automatic registration of built-in platforms
+- Runtime platform discovery
+- Type-safe client instantiation
+
+```python
+# Auto-registration of platforms
+_PLATFORMS: Dict[str, Type[VideoPlatformClient]] = {}
+
+def register_platform(name: str, client_class: Type[VideoPlatformClient])
+def get_platform_client(platform: str, config: VideoPlatformConfig) -> VideoPlatformClient
+```
+
+#### Factory System (factory.py)
+- Configuration management per platform
+- Platform selection logic
+- Feature flag integration
+
+```python
+def get_platform_for_room(room_id: Optional[str] = None) -> str:
+    """Determine which platform to use based on feature flags."""
+    if not settings.DAILY_MIGRATION_ENABLED:
+        return "whereby"
+
+    if room_id and room_id in settings.DAILY_MIGRATION_ROOM_IDS:
+        return "daily"
+
+    return settings.DEFAULT_VIDEO_PLATFORM
+```
+
+### 4. **Database Schema Changes**
+
+#### Room Model Updates
+Added `platform` field to track which video platform each room uses:
+
+```python
+# Database Schema
+platform_column = sqlalchemy.Column(
+    "platform",
+    sqlalchemy.String,
+    nullable=False,
+    server_default="whereby"
+)
+
+# Pydantic Model
+class Room(BaseModel):
+    platform: Literal["whereby", "daily"] = "whereby"
+```
+
+#### Meeting Model Updates
+Added `platform` field to meetings for tracking and debugging:
+
+```python
+# Database Schema
+platform_column = sqlalchemy.Column(
+    "platform",
+    sqlalchemy.String,
+    nullable=False,
+    server_default="whereby"
+)
+
+# Pydantic Model
+class Meeting(BaseModel):
+    platform: Literal["whereby", "daily"] = "whereby"
+```
+
+**Key Decision**: No platform-specific fields were added to models. Instead, the `extra_data` field in `MeetingData` handles platform-specific information, following the user's rule of using generic `provider_data` as JSON if needed.
+
+### 5. **Settings Configuration**
+
+#### Feature Flags
+```python
+# Migration control
+DAILY_MIGRATION_ENABLED: bool = True
+DAILY_MIGRATION_ROOM_IDS: list[str] = []
+DEFAULT_VIDEO_PLATFORM: str = "daily"
+
+# Daily.co specific settings
+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
+```
+
+#### Configuration Pattern
+Each platform gets its own configuration namespace while sharing common patterns:
+
+```python
+def get_platform_config(platform: str) -> VideoPlatformConfig:
+    if platform == "whereby":
+        return VideoPlatformConfig(
+            api_key=settings.WHEREBY_API_KEY or "",
+            webhook_secret=settings.WHEREBY_WEBHOOK_SECRET or "",
+            # ... whereby-specific config
+        )
+    elif platform == "daily":
+        return VideoPlatformConfig(
+            api_key=settings.DAILY_API_KEY or "",
+            webhook_secret=settings.DAILY_WEBHOOK_SECRET or "",
+            # ... daily-specific config
+        )
+```
+
+### 6. **API Integration Updates**
+
+#### Room Creation (views/rooms.py)
+Updated to use platform factory instead of direct Whereby calls:
+
+```python
+@router.post("/rooms/{room_name}/meeting")
+async def rooms_create_meeting(room_name: str, user: UserInfo):
+    # OLD: Direct Whereby integration
+    # whereby_meeting = await create_meeting("", end_date=end_date, room=room)
+
+    # NEW: Platform abstraction
+    platform = get_platform_for_room(room.id)
+    client = create_platform_client(platform)
+
+    meeting_data = await client.create_meeting(
+        room_name_prefix=room.name, end_date=end_date, room=room
+    )
+
+    await client.upload_logo(meeting_data.room_name, "./images/logo.png")
+```
+
+### 7. **Webhook Handling**
+
+#### Separate Webhook Endpoints
+Each platform gets its own webhook endpoint with platform-specific signature verification:
+
+```python
+# views/daily.py
+@router.post("/daily_webhook")
+async def daily_webhook(event: DailyWebhookEvent, request: Request):
+    # Verify Daily.co signature
+    body = await request.body()
+    signature = request.headers.get("X-Daily-Signature", "")
+
+    if not verify_daily_webhook_signature(body, signature):
+        raise HTTPException(status_code=401)
+
+    # Handle platform-specific events
+    if event.type == "participant.joined":
+        await _handle_participant_joined(event)
+```
+
+#### Consistent Event Handling
+Despite different event formats, the core business logic remains the same:
+
+```python
+async def _handle_participant_joined(event):
+    room_name = event.data.get("room", {}).get("name")  # Daily.co format
+    meeting = await meetings_controller.get_by_room_name(room_name)
+    if meeting:
+        current_count = getattr(meeting, "num_clients", 0)
+        await meetings_controller.update_meeting(
+            meeting.id, num_clients=current_count + 1
+        )
+```
+
+### 8. **Worker Task Integration**
+
+#### New Task for Daily.co Recording Processing
+Added platform-specific recording processing while maintaining the same pipeline:
+
+```python
+@shared_task
+@asynctask
+async def process_recording_from_url(recording_url: str, meeting_id: str, recording_id: str):
+    """Process recording from Direct URL (Daily.co webhook)."""
+    logger.info("Processing recording from URL for meeting: %s", meeting_id)
+    # Uses same processing pipeline as Whereby S3 recordings
+```
+
+**Key Decision**: Worker tasks remain in main worker module but could be moved to platform-specific folders as suggested by the user.
+
+### 9. **Testing Infrastructure**
+
+#### Comprehensive Test Suite
+- Unit tests for each platform client
+- Integration tests for platform switching
+- Mock platform for testing without external dependencies
+- Webhook signature verification tests
+
+```python
+class TestPlatformIntegration:
+    """Integration tests for platform switching."""
+
+    async def test_platform_switching_preserves_interface(self):
+        """Test that different platforms provide consistent interface."""
+        # Test both Mock and Daily platforms return MeetingData objects
+        # with consistent fields
+```
+
+## Implementation Patterns for Jitsi Integration
+
+Based on the daily.co implementation, here's how Jitsi should be integrated:
+
+### 1. **Jitsi Client Implementation**
+
+```python
+# video_platforms/jitsi.py
+class JitsiClient(VideoPlatformClient):
+    PLATFORM_NAME = "jitsi"
+
+    async def create_meeting(self, room_name_prefix: str, end_date: datetime, room: Room) -> MeetingData:
+        # Generate unique room name
+        jitsi_room = f"reflector-{room.name}-{int(time.time())}"
+
+        # Generate JWT tokens
+        user_jwt = self._generate_jwt(room=jitsi_room, moderator=False, exp=end_date)
+        host_jwt = self._generate_jwt(room=jitsi_room, moderator=True, exp=end_date)
+
+        return MeetingData(
+            meeting_id=generate_uuid4(),
+            room_name=jitsi_room,
+            room_url=f"https://jitsi.domain/{jitsi_room}?jwt={user_jwt}",
+            host_room_url=f"https://jitsi.domain/{jitsi_room}?jwt={host_jwt}",
+            platform=self.PLATFORM_NAME,
+            extra_data={"user_jwt": user_jwt, "host_jwt": host_jwt}
+        )
+```
+
+### 2. **Settings Integration**
+
+```python
+# settings.py
+JITSI_DOMAIN: str = "meet.jit.si"
+JITSI_JWT_SECRET: str | None = None
+JITSI_WEBHOOK_SECRET: str | None = None
+JITSI_API_URL: str | None = None  # If using Jitsi API
+```
+
+### 3. **Factory Registration**
+
+```python
+# registry.py
+def _register_builtin_platforms():
+    from .jitsi import JitsiClient
+    register_platform("jitsi", JitsiClient)
+
+# factory.py
+def get_platform_config(platform: str) -> VideoPlatformConfig:
+    elif platform == "jitsi":
+        return VideoPlatformConfig(
+            api_key="",  # Jitsi may not need API key
+            webhook_secret=settings.JITSI_WEBHOOK_SECRET or "",
+            api_url=settings.JITSI_API_URL,
+        )
+```
+
+### 4. **Webhook Integration**
+
+```python
+# views/jitsi.py
+@router.post("/jitsi/events")
+async def jitsi_events_webhook(event_data: dict):
+    # Handle Prosody event-sync webhook format
+    event_type = event_data.get("event")
+    room_name = event_data.get("room", "").split("@")[0]
+
+    if event_type == "muc-occupant-joined":
+        # Same participant handling logic as other platforms
+```
+
+## Key Benefits of This Architecture
+
+### 1. **Isolation and Organization**
+- Platform-specific code contained in separate modules
+- No platform logic leaking into core application
+- Easy to add/remove platforms without affecting others
+
+### 2. **Consistent Interface**
+- All platforms implement the same abstract methods
+- Standardized `MeetingData` structure
+- Uniform error handling and logging
+
+### 3. **Gradual Migration Support**
+- Feature flags for controlled rollouts
+- Room-specific platform selection
+- Fallback mechanisms for platform failures
+
+### 4. **Configuration Management**
+- Centralized settings per platform
+- Consistent naming patterns
+- Environment-based configuration
+
+### 5. **Testing and Quality**
+- Mock platform for testing
+- Comprehensive test coverage
+- Platform-specific test utilities
+
+## Migration Strategy Applied
+
+The daily.co implementation demonstrates a careful migration approach:
+
+### 1. **Backward Compatibility**
+- Default platform remains "whereby"
+- Existing rooms continue using Whereby unless explicitly migrated
+- Same API endpoints and response formats
+
+### 2. **Feature Flag Control**
+```python
+# Gradual rollout control
+DAILY_MIGRATION_ENABLED: bool = True
+DAILY_MIGRATION_ROOM_IDS: list[str] = []  # Specific rooms to migrate
+DEFAULT_VIDEO_PLATFORM: str = "daily"     # New rooms default
+```
+
+### 3. **Data Integrity**
+- Platform field tracks which service each room/meeting uses
+- No data loss during migration
+- Platform-specific data preserved in `extra_data`
+
+### 4. **Monitoring and Rollback**
+- Comprehensive logging of platform selection
+- Easy rollback by changing feature flags
+- Platform-specific error tracking
+
+## Recommendations for Jitsi Integration
+
+Based on this analysis and the user's requirements:
+
+### 1. **Follow the Pattern**
+- Create `video_platforms/jitsi/` directory with:
+  - `client.py` - Main JitsiClient implementation
+  - `tasks.py` - Jitsi-specific worker tasks
+  - `__init__.py` - Module exports
+
+### 2. **Settings Organization**
+- Use `JITSI_*` prefix for all Jitsi settings
+- Follow the same configuration pattern as Daily.co
+- Support both environment variables and config files
+
+### 3. **Generic Database Fields**
+- Avoid platform-specific columns in database
+- Use `provider_data` JSON field if platform-specific data needed
+- Keep `platform` field as simple string identifier
+
+### 4. **Worker Task Migration**
+According to user requirements, migrate platform-specific tasks:
+```
+video_platforms/
+├── whereby/
+│   ├── client.py  (moved from whereby.py)
+│   └── tasks.py   (moved from worker/whereby_tasks.py)
+├── daily/
+│   ├── client.py  (moved from daily.py)
+│   └── tasks.py   (moved from worker/daily_tasks.py)
+└── jitsi/
+    ├── client.py  (new JitsiClient)
+    └── tasks.py   (new Jitsi recording tasks)
+```
+
+### 5. **Webhook Architecture**
+- Create `views/jitsi.py` for Jitsi-specific webhooks
+- Follow the same signature verification pattern
+- Reuse existing participant tracking logic
+
+## Implementation Checklist for Jitsi
+
+- [ ] Create `video_platforms/jitsi/` directory structure
+- [ ] Implement `JitsiClient` following the abstract interface
+- [ ] Add Jitsi settings to configuration
+- [ ] Register Jitsi platform in factory/registry
+- [ ] Create Jitsi webhook endpoint
+- [ ] Implement JWT token generation for room access
+- [ ] Add Jitsi recording processing tasks
+- [ ] Create comprehensive test suite
+- [ ] Update database migrations for platform field
+- [ ] Document Jitsi-specific configuration
+
+## Conclusion
+
+The video platforms refactoring in PR #529 provides an excellent foundation for adding Jitsi support. The architecture is well-designed with clear separation of concerns, consistent interfaces, and excellent extensibility. The daily.co implementation demonstrates how to add a new platform while maintaining backward compatibility and providing gradual migration capabilities.
+
+The pattern should be directly applicable to Jitsi integration, with the main differences being:
+- JWT-based authentication instead of API keys
+- Different webhook event formats
+- Jibri recording pipeline integration
+- Self-hosted deployment considerations
+
+This architecture successfully achieves the user's goals of:
+1. Settings-based configuration
+2. Generic database fields (no provider-specific columns)
+3. Platform isolation in separate directories
+4. Worker task organization within platform folders
--- 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/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/README.md
+++ b/server/README.md
@@ -1,29 +1,3 @@
-## API Key Management
-
-### Finding Your User ID
-
-```bash
-# Get your OAuth sub (user ID) - requires authentication
-curl -H "Authorization: Bearer <your_jwt>" http://localhost:1250/v1/me
-# Returns: {"sub": "your-oauth-sub-here", "email": "...", ...}
-```
-
-### Creating API Keys
-
-```bash
-curl -X POST http://localhost:1250/v1/user/api-keys \
-  -H "Authorization: Bearer <your_jwt>" \
-  -H "Content-Type: application/json" \
-  -d '{"name": "My API Key"}'
-```
-
-### Using API Keys
-
-```bash
-# Use X-API-Key header instead of Authorization
-curl -H "X-API-Key: <your_api_key>" http://localhost:1250/v1/transcripts
-```
-
 ## AWS S3/SQS usage clarification

 Whereby.com uploads recordings directly to our S3 bucket when meetings end.
--- a/server/contrib/jitsi/README.md
+++ b/server/contrib/jitsi/README.md
@@ -0,0 +1,212 @@
+# Event Logger for Docker-Jitsi-Meet
+
+A Prosody module that logs Jitsi meeting events to JSONL files alongside recordings, enabling complete participant tracking and speaker statistics.
+
+## Prerequisites
+
+- Running docker-jitsi-meet installation
+- Jibri configured for recording
+
+## Installation
+
+### Step 1: Copy the Module
+
+Copy the Prosody module to your custom plugins directory:
+
+```bash
+# Create the directory if it doesn't exist
+mkdir -p ~/.jitsi-meet-cfg/prosody/prosody-plugins-custom
+
+# Copy the module
+cp mod_event_logger.lua ~/.jitsi-meet-cfg/prosody/prosody-plugins-custom/
+```
+
+### Step 2: Update Your .env File
+
+Add or modify these variables in your `.env` file:
+
+```bash
+# If XMPP_MUC_MODULES already exists, append event_logger
+# Example: XMPP_MUC_MODULES=existing_module,event_logger
+XMPP_MUC_MODULES=event_logger
+
+# Optional: Configure the module (these are defaults)
+JIBRI_RECORDINGS_PATH=/config/recordings
+JIBRI_LOG_SPEAKER_STATS=true
+JIBRI_SPEAKER_STATS_INTERVAL=10
+```
+
+**Important**: If you already have `XMPP_MUC_MODULES` defined, add `event_logger` to the comma-separated list:
+```bash
+# Existing modules + our module
+XMPP_MUC_MODULES=mod_info,mod_alert,event_logger
+```
+
+### Step 3: Modify docker-compose.yml
+
+Add a shared recordings volume so Prosody can write events alongside Jibri recordings:
+
+```yaml
+services:
+  prosody:
+    # ... existing configuration ...
+    volumes:
+      - ${CONFIG}/prosody/config:/config:Z
+      - ${CONFIG}/prosody/prosody-plugins-custom:/prosody-plugins-custom:Z
+      - ${CONFIG}/recordings:/config/recordings:Z  # Add this line
+    environment:
+      # Add if not using .env file
+      - XMPP_MUC_MODULES=${XMPP_MUC_MODULES:-event_logger}
+      - JIBRI_RECORDINGS_PATH=/config/recordings
+
+  jibri:
+    # ... existing configuration ...
+    volumes:
+      - ${CONFIG}/jibri:/config:Z
+      - ${CONFIG}/recordings:/config/recordings:Z  # Add this line
+    environment:
+      # For Reflector webhook integration (optional)
+      - REFLECTOR_WEBHOOK_URL=${REFLECTOR_WEBHOOK_URL:-}
+      - JIBRI_FINALIZE_RECORDING_SCRIPT_PATH=/config/finalize.sh
+```
+
+### Step 4: Add Finalize Script (Optional - For Reflector Integration)
+
+If you want to notify Reflector when recordings complete:
+
+```bash
+# Copy the finalize script
+cp finalize.sh ~/.jitsi-meet-cfg/jibri/finalize.sh
+chmod +x ~/.jitsi-meet-cfg/jibri/finalize.sh
+
+# Add to .env
+REFLECTOR_WEBHOOK_URL=http://your-reflector-api:8000
+```
+
+### Step 5: Restart Services
+
+```bash
+docker-compose down
+docker-compose up -d
+```
+
+## What Gets Created
+
+After a recording, you'll find in `~/.jitsi-meet-cfg/recordings/{session-id}/`:
+- `recording.mp4` - The video recording (created by Jibri)
+- `metadata.json` - Basic metadata (created by Jibri)
+- `events.jsonl` - Complete participant timeline (created by this module)
+
+## Event Format
+
+Each line in `events.jsonl` is a JSON object:
+
+```json
+{"type":"room_created","timestamp":1234567890,"room_name":"TestRoom","room_jid":"testroom@conference.meet.jitsi","meeting_url":"https://meet.jitsi/TestRoom"}
+{"type":"recording_started","timestamp":1234567891,"room_name":"TestRoom","session_id":"20240115120000_TestRoom","jibri_jid":"jibri@recorder.meet.jitsi"}
+{"type":"participant_joined","timestamp":1234567892,"room_name":"TestRoom","participant":{"jid":"user1@meet.jitsi/web","nick":"John Doe","id":"user1@meet.jitsi","is_moderator":false}}
+{"type":"speaker_active","timestamp":1234567895,"room_name":"TestRoom","speaker_jid":"user1@meet.jitsi","speaker_nick":"John Doe","duration":10}
+{"type":"participant_left","timestamp":1234567920,"room_name":"TestRoom","participant":{"jid":"user1@meet.jitsi/web","nick":"John Doe","duration_seconds":28}}
+{"type":"recording_stopped","timestamp":1234567950,"room_name":"TestRoom","session_id":"20240115120000_TestRoom","meeting_url":"https://meet.jitsi/TestRoom"}
+```
+
+## Configuration Options
+
+All configuration can be done via environment variables:
+
+| Environment Variable | Default | Description |
+|---------------------|---------|-------------|
+| `JIBRI_RECORDINGS_PATH` | `/config/recordings` | Path where recordings are stored |
+| `JIBRI_LOG_SPEAKER_STATS` | `true` | Enable speaker statistics logging |
+| `JIBRI_SPEAKER_STATS_INTERVAL` | `10` | Seconds between speaker stats updates |
+
+## Verifying Installation
+
+Check that the module is loaded:
+```bash
+docker-compose logs prosody | grep "Event Logger"
+# Should see: "Event Logger loaded - writing to /config/recordings"
+```
+
+Check for events after a recording:
+```bash
+ls -la ~/.jitsi-meet-cfg/recordings/*/events.jsonl
+cat ~/.jitsi-meet-cfg/recordings/*/events.jsonl | jq .
+```
+
+## Troubleshooting
+
+### No events.jsonl file created
+
+1. **Check module is enabled**:
+   ```bash
+   docker-compose exec prosody grep -r "event_logger" /config
+   ```
+
+2. **Verify volume permissions**:
+   ```bash
+   docker-compose exec prosody ls -la /config/recordings
+   ```
+
+3. **Check Prosody logs for errors**:
+   ```bash
+   docker-compose logs prosody | grep -i error
+   ```
+
+### Module not loading
+
+1. **Verify file exists in container**:
+   ```bash
+   docker-compose exec prosody ls -la /prosody-plugins-custom/
+   ```
+
+2. **Check XMPP_MUC_MODULES format** (must be comma-separated, no spaces):
+   - ✅ Correct: `XMPP_MUC_MODULES=mod1,mod2,event_logger`
+   - ❌ Wrong: `XMPP_MUC_MODULES=mod1, mod2, event_logger`
+
+## Common docker-compose.yml Patterns
+
+### Minimal Addition (if you trust defaults)
+```yaml
+services:
+  prosody:
+    volumes:
+      - ${CONFIG}/recordings:/config/recordings:Z  # Just add this
+```
+
+### Full Configuration
+```yaml
+services:
+  prosody:
+    volumes:
+      - ${CONFIG}/prosody/config:/config:Z
+      - ${CONFIG}/prosody/prosody-plugins-custom:/prosody-plugins-custom:Z
+      - ${CONFIG}/recordings:/config/recordings:Z
+    environment:
+      - XMPP_MUC_MODULES=event_logger
+      - JIBRI_RECORDINGS_PATH=/config/recordings
+      - JIBRI_LOG_SPEAKER_STATS=true
+      - JIBRI_SPEAKER_STATS_INTERVAL=10
+
+  jibri:
+    volumes:
+      - ${CONFIG}/jibri:/config:Z
+      - ${CONFIG}/recordings:/config/recordings:Z
+    environment:
+      - JIBRI_RECORDING_DIR=/config/recordings
+      - JIBRI_FINALIZE_RECORDING_SCRIPT_PATH=/config/finalize.sh
+```
+
+## Integration with Reflector
+
+The finalize.sh script will automatically notify Reflector when a recording completes if `REFLECTOR_WEBHOOK_URL` is set. Reflector will receive:
+
+```json
+{
+  "session_id": "20240115120000_TestRoom",
+  "path": "20240115120000_TestRoom",
+  "meeting_url": "https://meet.jitsi/TestRoom"
+}
+```
+
+Reflector then processes the recording along with the complete participant timeline from `events.jsonl`.
--- a/server/contrib/jitsi/finalize.sh
+++ b/server/contrib/jitsi/finalize.sh
@@ -0,0 +1,49 @@
+#!/bin/bash
+# Jibri finalize script to notify Reflector when recording is complete
+# This script is called by Jibri with the recording directory as argument
+
+RECORDING_PATH="$1"
+SESSION_ID=$(basename "$RECORDING_PATH")
+METADATA_FILE="$RECORDING_PATH/metadata.json"
+
+# Extract meeting URL from Jibri's metadata
+MEETING_URL=""
+if [ -f "$METADATA_FILE" ]; then
+    MEETING_URL=$(jq -r '.meeting_url' "$METADATA_FILE" 2>/dev/null || echo "")
+fi
+
+echo "[$(date)] Recording finalized: $RECORDING_PATH"
+echo "[$(date)] Session ID: $SESSION_ID"
+echo "[$(date)] Meeting URL: $MEETING_URL"
+
+# Check if events.jsonl was created by our Prosody module
+if [ -f "$RECORDING_PATH/events.jsonl" ]; then
+    EVENT_COUNT=$(wc -l < "$RECORDING_PATH/events.jsonl")
+    echo "[$(date)] Found events.jsonl with $EVENT_COUNT events"
+else
+    echo "[$(date)] Warning: No events.jsonl found"
+fi
+
+# Notify Reflector if webhook URL is configured
+if [ -n "$REFLECTOR_WEBHOOK_URL" ]; then
+    echo "[$(date)] Notifying Reflector at: $REFLECTOR_WEBHOOK_URL"
+
+    RESPONSE=$(curl -s -w "\n%{http_code}" -X POST "$REFLECTOR_WEBHOOK_URL/api/v1/jibri/recording-ready" \
+        -H "Content-Type: application/json" \
+        -d "{\"session_id\":\"$SESSION_ID\",\"path\":\"$SESSION_ID\",\"meeting_url\":\"$MEETING_URL\"}")
+
+    HTTP_CODE=$(echo "$RESPONSE" | tail -n1)
+    BODY=$(echo "$RESPONSE" | sed '$d')
+
+    if [ "$HTTP_CODE" = "200" ]; then
+        echo "[$(date)] Reflector notified successfully"
+        echo "[$(date)] Response: $BODY"
+    else
+        echo "[$(date)] Failed to notify Reflector. HTTP code: $HTTP_CODE"
+        echo "[$(date)] Response: $BODY"
+    fi
+else
+    echo "[$(date)] No REFLECTOR_WEBHOOK_URL configured, skipping notification"
+fi
+
+echo "[$(date)] Finalize script completed"
--- a/server/contrib/jitsi/mod_event_logger.lua
+++ b/server/contrib/jitsi/mod_event_logger.lua
@@ -0,0 +1,372 @@
+local json = require "util.json"
+local st = require "util.stanza"
+local jid_bare = require "util.jid".bare
+
+local recordings_path = os.getenv("JIBRI_RECORDINGS_PATH") or
+                       module:get_option_string("jibri_recordings_path", "/recordings")
+
+-- room_jid -> { session_id, participants = {jid -> info} }
+local active_recordings = {}
+-- room_jid -> { participants = {jid -> info}, created_at }
+local room_states = {}
+
+local function get_timestamp()
+    return os.time()
+end
+
+local function write_event(session_id, event)
+    if not session_id then
+        module:log("warn", "No session_id for event: %s", event.type)
+        return
+    end
+
+    local session_dir = string.format("%s/%s", recordings_path, session_id)
+    local event_file = string.format("%s/events.jsonl", session_dir)
+
+    module:log("info", "Writing event %s to %s", event.type, event_file)
+
+    -- Create directory
+    local mkdir_cmd = string.format("mkdir -p '%s' 2>&1", session_dir)
+    local mkdir_result = os.execute(mkdir_cmd)
+    module:log("debug", "mkdir result: %s", tostring(mkdir_result))
+
+    local file, err = io.open(event_file, "a")
+    if file then
+        local json_str = json.encode(event)
+        file:write(json_str .. "\n")
+        file:close()
+        module:log("info", "Successfully wrote event %s", event.type)
+    else
+        module:log("error", "Failed to write event to %s: %s", event_file, err)
+    end
+end
+
+local function extract_participant_info(occupant)
+    local info = {
+        jid = occupant.jid,
+        bare_jid = occupant.bare_jid,
+        nick = occupant.nick,
+        display_name = nil,
+        role = occupant.role
+    }
+
+    local presence = occupant:get_presence()
+    if presence then
+        local nick_element = presence:get_child("nick", "http://jabber.org/protocol/nick")
+        if nick_element then
+            info.display_name = nick_element:get_text()
+        end
+
+        local identity = presence:get_child("identity")
+        if identity then
+            local user = identity:get_child("user")
+            if user then
+                local name = user:get_child("name")
+                if name then
+                    info.display_name = name:get_text()
+                end
+
+                local id_element = user:get_child("id")
+                if id_element then
+                    info.id = id_element:get_text()
+                end
+            end
+        end
+
+        if not info.display_name and occupant.nick then
+            local _, _, resource = occupant.nick:match("([^@]+)@([^/]+)/(.+)")
+            if resource then
+                info.display_name = resource
+            end
+        end
+    end
+
+    return info
+end
+
+local function get_room_participant_count(room)
+    local count = 0
+    for _ in room:each_occupant() do
+        count = count + 1
+    end
+    return count
+end
+
+local function snapshot_room_participants(room)
+    local participants = {}
+    local total = 0
+    local skipped = 0
+
+    module:log("info", "Snapshotting room participants")
+
+    for _, occupant in room:each_occupant() do
+        total = total + 1
+        -- Skip recorders (Jibri)
+        if occupant.bare_jid and (occupant.bare_jid:match("^recorder@") or
+                                  occupant.bare_jid:match("^jibri@")) then
+            skipped = skipped + 1
+        else
+            local info = extract_participant_info(occupant)
+            participants[occupant.jid] = info
+            module:log("debug", "Added participant: %s", info.display_name or info.bare_jid)
+        end
+    end
+
+    module:log("info", "Snapshot: %d total, %d participants", total, total - skipped)
+    return participants
+end
+
+-- Import utility functions if available
+local util = module:require "util";
+local get_room_from_jid = util.get_room_from_jid;
+local room_jid_match_rewrite = util.room_jid_match_rewrite;
+
+-- Main IQ handler for Jibri stanzas
+module:hook("pre-iq/full", function(event)
+    local stanza = event.stanza
+    if stanza.name ~= "iq" then
+        return
+    end
+
+    local jibri = stanza:get_child('jibri', 'http://jitsi.org/protocol/jibri')
+    if not jibri then
+        return
+    end
+
+    module:log("info", "=== Jibri IQ intercepted ===")
+
+    local action = jibri.attr.action
+    local session_id = jibri.attr.session_id
+    local room_jid = jibri.attr.room
+    local recording_mode = jibri.attr.recording_mode
+    local app_data = jibri.attr.app_data
+
+    module:log("info", "Jibri %s - session: %s, room: %s, mode: %s",
+               action or "?", session_id or "?", room_jid or "?", recording_mode or "?")
+
+    if not room_jid or not session_id then
+        module:log("warn", "Missing room_jid or session_id")
+        return
+    end
+
+    -- Get the room using util function
+    local room = get_room_from_jid(room_jid_match_rewrite(jid_bare(stanza.attr.to)))
+    if not room then
+        -- Try with the room_jid directly
+        room = get_room_from_jid(room_jid)
+    end
+
+    if not room then
+        module:log("error", "Room not found for jid: %s", room_jid)
+        return
+    end
+
+    module:log("info", "Room found: %s", room:get_name() or room_jid)
+
+    if action == "start" then
+        module:log("info", "Recording START for session %s", session_id)
+
+        -- Count and snapshot participants
+        local participant_count = 0
+        for _ in room:each_occupant() do
+            participant_count = participant_count + 1
+        end
+
+        local participants = snapshot_room_participants(room)
+        local participant_list = {}
+        for jid, info in pairs(participants) do
+            table.insert(participant_list, info)
+        end
+
+        active_recordings[room_jid] = {
+            session_id = session_id,
+            participants = participants,
+            started_at = get_timestamp()
+        }
+
+        write_event(session_id, {
+            type = "recording_started",
+            timestamp = get_timestamp(),
+            room_jid = room_jid,
+            room_name = room:get_name(),
+            session_id = session_id,
+            recording_mode = recording_mode,
+            app_data = app_data,
+            participant_count = participant_count,
+            participants_at_start = participant_list
+        })
+
+    elseif action == "stop" then
+        module:log("info", "Recording STOP for session %s", session_id)
+
+        local recording = active_recordings[room_jid]
+        if recording and recording.session_id == session_id then
+            write_event(session_id, {
+                type = "recording_stopped",
+                timestamp = get_timestamp(),
+                room_jid = room_jid,
+                room_name = room:get_name(),
+                session_id = session_id,
+                duration = get_timestamp() - recording.started_at,
+                participant_count = get_room_participant_count(room)
+            })
+
+            active_recordings[room_jid] = nil
+        else
+            module:log("warn", "No active recording found for room %s", room_jid)
+        end
+    end
+end);
+
+-- Room and participant event hooks
+local function setup_room_hooks(host_module)
+    module:log("info", "Setting up room hooks on %s", host_module.host or "unknown")
+
+    -- Room created
+    host_module:hook("muc-room-created", function(event)
+        local room = event.room
+        local room_jid = room.jid
+
+        room_states[room_jid] = {
+            participants = {},
+            created_at = get_timestamp()
+        }
+
+        module:log("info", "Room created: %s", room_jid)
+    end)
+
+    -- Room destroyed
+    host_module:hook("muc-room-destroyed", function(event)
+        local room = event.room
+        local room_jid = room.jid
+
+        room_states[room_jid] = nil
+        active_recordings[room_jid] = nil
+
+        module:log("info", "Room destroyed: %s", room_jid)
+    end)
+
+    -- Occupant joined
+    host_module:hook("muc-occupant-joined", function(event)
+        local room = event.room
+        local occupant = event.occupant
+        local room_jid = room.jid
+
+        -- Skip recorders
+        if occupant.bare_jid and (occupant.bare_jid:match("^recorder@") or
+                                   occupant.bare_jid:match("^jibri@")) then
+            return
+        end
+
+        local participant_info = extract_participant_info(occupant)
+
+        -- Update room state
+        if room_states[room_jid] then
+            room_states[room_jid].participants[occupant.jid] = participant_info
+        end
+
+        -- Log to active recording if exists
+        local recording = active_recordings[room_jid]
+        if recording then
+            recording.participants[occupant.jid] = participant_info
+
+            write_event(recording.session_id, {
+                type = "participant_joined",
+                timestamp = get_timestamp(),
+                room_jid = room_jid,
+                room_name = room:get_name(),
+                participant = participant_info,
+                participant_count = get_room_participant_count(room)
+            })
+        end
+
+        module:log("info", "Participant joined %s: %s (%d total)",
+                   room:get_name() or room_jid,
+                   participant_info.display_name or participant_info.bare_jid,
+                   get_room_participant_count(room))
+    end)
+
+    -- Occupant left
+    host_module:hook("muc-occupant-left", function(event)
+        local room = event.room
+        local occupant = event.occupant
+        local room_jid = room.jid
+
+        -- Skip recorders
+        if occupant.bare_jid and (occupant.bare_jid:match("^recorder@") or
+                                   occupant.bare_jid:match("^jibri@")) then
+            return
+        end
+
+        local participant_info = extract_participant_info(occupant)
+
+        -- Update room state
+        if room_states[room_jid] then
+            room_states[room_jid].participants[occupant.jid] = nil
+        end
+
+        -- Log to active recording if exists
+        local recording = active_recordings[room_jid]
+        if recording then
+            if recording.participants[occupant.jid] then
+                recording.participants[occupant.jid] = nil
+            end
+
+            write_event(recording.session_id, {
+                type = "participant_left",
+                timestamp = get_timestamp(),
+                room_jid = room_jid,
+                room_name = room:get_name(),
+                participant = participant_info,
+                participant_count = get_room_participant_count(room)
+            })
+        end
+
+        module:log("info", "Participant left %s: %s (%d remaining)",
+                   room:get_name() or room_jid,
+                   participant_info.display_name or participant_info.bare_jid,
+                   get_room_participant_count(room))
+    end)
+end
+
+-- Module initialization
+local current_host = module:get_host()
+local host_type = module:get_host_type()
+
+module:log("info", "Event Logger loading on %s (type: %s)", current_host, host_type or "unknown")
+module:log("info", "Recording path: %s", recordings_path)
+
+-- Setup room hooks based on host type
+if host_type == "component" and current_host:match("^[^.]+%.") then
+    setup_room_hooks(module)
+else
+    -- Try to find and hook to MUC component
+    local process_host_module = util.process_host_module
+    local muc_component_host = module:get_option_string("muc_component") or
+                              module:get_option_string("main_muc")
+
+    if not muc_component_host then
+        local possible_hosts = {
+            "muc." .. current_host,
+            "conference." .. current_host,
+            "rooms." .. current_host
+        }
+
+        for _, host in ipairs(possible_hosts) do
+            if prosody.hosts[host] then
+                muc_component_host = host
+                module:log("info", "Auto-detected MUC component: %s", muc_component_host)
+                break
+            end
+        end
+    end
+
+    if muc_component_host then
+        process_host_module(muc_component_host, function(host_module, host)
+            module:log("info", "Hooking to MUC events on %s", host)
+            setup_room_hooks(host_module)
+        end)
+    else
+        module:log("error", "Could not find MUC component")
+    end
+end
--- a/server/docs/gpu/api-transcription.md
+++ b/server/docs/gpu/api-transcription.md
@@ -190,5 +190,5 @@ Use the pytest-based conformance tests to validate any new implementation (inclu
 ```
 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
+uv run -m pytest -m gpu_modal --no-cov server/tests/test_gpu_modal_transcript.py
 ```
--- a/server/docs/platform-jitsi.md
+++ b/server/docs/platform-jitsi.md
@@ -0,0 +1,493 @@
+# Jitsi Integration Configuration Guide
+
+This guide provides step-by-step instructions for configuring Reflector to work with a self-hosted Jitsi Meet installation for video meetings and recording.
+
+## Prerequisites
+
+Before configuring Jitsi integration, ensure you have:
+
+- **Self-hosted Jitsi Meet installation** (version 2.0.8922 or later recommended)
+- **Jibri recording service** configured and running
+- **Prosody XMPP server** with mod_event_sync module installed
+- **Docker or system deployment** of Reflector with access to environment variables
+- **SSL certificates** for secure communication between services
+
+## Environment Configuration
+
+Add the following environment variables to your Reflector deployment:
+
+### Required Settings
+
+```bash
+# Jitsi Meet domain (without https://)
+JITSI_DOMAIN=meet.example.com
+
+# JWT secret for room authentication (generate with: openssl rand -hex 32)
+JITSI_JWT_SECRET=your-64-character-hex-secret-here
+
+# Webhook secret for secure event handling (generate with: openssl rand -hex 16)
+JITSI_WEBHOOK_SECRET=your-32-character-hex-secret-here
+
+# Application identifier (should match Jitsi configuration)
+JITSI_APP_ID=reflector
+
+# JWT issuer and audience (should match Jitsi configuration)
+JITSI_JWT_ISSUER=reflector
+JITSI_JWT_AUDIENCE=jitsi
+```
+
+### Example .env Configuration
+
+```bash
+# Add to your server/.env file
+JITSI_DOMAIN=meet.mycompany.com
+JITSI_JWT_SECRET=$(openssl rand -hex 32)
+JITSI_WEBHOOK_SECRET=$(openssl rand -hex 16)
+JITSI_APP_ID=reflector
+JITSI_JWT_ISSUER=reflector
+JITSI_JWT_AUDIENCE=jitsi
+```
+
+## Jitsi Meet Server Configuration
+
+### 1. JWT Authentication Setup
+
+Edit `/etc/prosody/conf.d/[YOUR_DOMAIN].cfg.lua`:
+
+```lua
+VirtualHost "meet.example.com"
+    authentication = "token"
+    app_id = "reflector"
+    app_secret = "your-jwt-secret-here"
+
+    -- Allow anonymous access for non-authenticated users
+    c2s_require_encryption = false
+    admins = { "focusUser@auth.meet.example.com" }
+
+    modules_enabled = {
+        "bosh";
+        "pubsub";
+        "ping";
+        "roster";
+        "saslauth";
+        "tls";
+        "dialback";
+        "disco";
+        "carbons";
+        "pep";
+        "private";
+        "blocklist";
+        "vcard";
+        "version";
+        "uptime";
+        "time";
+        "ping";
+        "register";
+        "admin_adhoc";
+        "token_verification";
+        "event_sync";  -- Required for webhook events
+    }
+```
+
+### 2. Room Access Control
+
+Edit `/etc/jitsi/meet/meet.example.com-config.js`:
+
+```javascript
+var config = {
+    hosts: {
+        domain: 'meet.example.com',
+        muc: 'conference.meet.example.com'
+    },
+
+    // Enable JWT authentication
+    enableUserRolesBasedOnToken: true,
+
+    // Recording configuration
+    fileRecordingsEnabled: true,
+    liveStreamingEnabled: false,
+
+    // Reflector-specific settings
+    prejoinPageEnabled: true,
+    requireDisplayName: true,
+};
+```
+
+### 3. Interface Configuration
+
+Edit `/usr/share/jitsi-meet/interface_config.js`:
+
+```javascript
+var interfaceConfig = {
+    // Customize for Reflector branding
+    APP_NAME: 'Reflector Meeting',
+    DEFAULT_WELCOME_PAGE_LOGO_URL: 'https://your-domain.com/logo.png',
+
+    // Hide unnecessary buttons
+    TOOLBAR_BUTTONS: [
+        'microphone', 'camera', 'closedcaptions', 'desktop',
+        'fullscreen', 'fodeviceselection', 'hangup',
+        'chat', 'recording', 'livestreaming', 'etherpad',
+        'sharedvideo', 'settings', 'raisehand', 'videoquality',
+        'filmstrip', 'invite', 'feedback', 'stats', 'shortcuts',
+        'tileview', 'videobackgroundblur', 'download', 'help',
+        'mute-everyone'
+    ]
+};
+```
+
+## Jibri Configuration
+
+### 1. Recording Service Setup
+
+Edit `/etc/jitsi/jibri/jibri.conf`:
+
+```hocon
+jibri {
+    recording {
+        recordings-directory = "/var/recordings"
+        finalize-script = "/opt/jitsi/jibri/finalize.sh"
+    }
+
+    api {
+        xmpp {
+            environments = [{
+                name = "prod environment"
+                xmpp-server-hosts = ["meet.example.com"]
+                xmpp-domain = "meet.example.com"
+
+                control-muc {
+                    domain = "internal.auth.meet.example.com"
+                    room-name = "JibriBrewery"
+                    nickname = "jibri-nickname"
+                }
+
+                control-login {
+                    domain = "auth.meet.example.com"
+                    username = "jibri"
+                    password = "jibri-password"
+                }
+            }]
+        }
+    }
+}
+```
+
+### 2. Finalize Script Setup
+
+Create `/opt/jitsi/jibri/finalize.sh`:
+
+```bash
+#!/bin/bash
+# Jibri finalize script for Reflector integration
+
+RECORDING_FILE="$1"
+ROOM_NAME="$2"
+REFLECTOR_API_URL="${REFLECTOR_API_URL:-http://localhost:1250}"
+WEBHOOK_SECRET="${JITSI_WEBHOOK_SECRET}"
+
+# Generate webhook signature
+generate_signature() {
+    local payload="$1"
+    echo -n "$payload" | openssl dgst -sha256 -hmac "$WEBHOOK_SECRET" | cut -d' ' -f2
+}
+
+# Prepare webhook payload
+TIMESTAMP=$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)
+PAYLOAD=$(cat <<EOF
+{
+    "room_name": "$ROOM_NAME",
+    "recording_file": "$RECORDING_FILE",
+    "recording_status": "completed",
+    "timestamp": "$TIMESTAMP"
+}
+EOF
+)
+
+# Generate signature
+SIGNATURE=$(generate_signature "$PAYLOAD")
+
+# Send webhook to Reflector
+curl -X POST "$REFLECTOR_API_URL/v1/jibri/recording-complete" \
+    -H "Content-Type: application/json" \
+    -H "X-Jitsi-Signature: $SIGNATURE" \
+    -d "$PAYLOAD" \
+    --max-time 30
+
+echo "Recording finalization webhook sent for room: $ROOM_NAME"
+```
+
+Make the script executable:
+
+```bash
+chmod +x /opt/jitsi/jibri/finalize.sh
+```
+
+## Prosody Event Configuration
+
+### 1. Event-Sync Module Installation
+
+Install the mod_event_sync module:
+
+```bash
+# Download the module
+cd /usr/share/jitsi-meet/prosody-plugins/
+wget https://raw.githubusercontent.com/jitsi-contrib/prosody-plugins/main/mod_event_sync.lua
+
+# Or if using git
+git clone https://github.com/jitsi-contrib/prosody-plugins.git
+cp prosody-plugins/mod_event_sync.lua /usr/share/jitsi-meet/prosody-plugins/
+```
+
+### 2. Webhook Configuration
+
+Add to `/etc/prosody/conf.d/[YOUR_DOMAIN].cfg.lua`:
+
+```lua
+Component "conference.meet.example.com" "muc"
+    storage = "memory"
+    modules_enabled = {
+        "muc_meeting_id";
+        "muc_domain_mapper";
+        "polls";
+        "event_sync";  -- Enable event sync
+    }
+
+    -- Event sync webhook configuration
+    event_sync_url = "https://your-reflector-domain.com/v1/jitsi/events"
+    event_sync_secret = "your-webhook-secret-here"
+
+    -- Events to track
+    event_sync_events = {
+        "muc-occupant-joined",
+        "muc-occupant-left",
+        "jibri-recording-on",
+        "jibri-recording-off"
+    }
+```
+
+### 3. Restart Services
+
+After configuration changes, restart all services:
+
+```bash
+systemctl restart prosody
+systemctl restart jicofo
+systemctl restart jitsi-videobridge2
+systemctl restart jibri
+systemctl restart nginx
+```
+
+## Reflector Room Configuration
+
+### 1. Create Jitsi Room
+
+When creating rooms in Reflector, set the platform field:
+
+```bash
+curl -X POST "https://your-reflector-domain.com/v1/rooms" \
+    -H "Authorization: Bearer $AUTH_TOKEN" \
+    -H "Content-Type: application/json" \
+    -d '{
+        "name": "my-jitsi-room",
+        "platform": "jitsi",
+        "recording_type": "cloud",
+        "recording_trigger": "automatic-2nd-participant",
+        "is_locked": false,
+        "room_mode": "normal"
+    }'
+```
+
+### 2. Meeting Creation
+
+Meetings will automatically use Jitsi when the room platform is set to "jitsi":
+
+```bash
+curl -X POST "https://your-reflector-domain.com/v1/rooms/my-jitsi-room/meeting" \
+    -H "Authorization: Bearer $AUTH_TOKEN"
+```
+
+## Testing the Integration
+
+### 1. Health Check
+
+Verify Jitsi webhook configuration:
+
+```bash
+curl "https://your-reflector-domain.com/v1/jitsi/health"
+```
+
+Expected response:
+```json
+{
+    "status": "ok",
+    "service": "jitsi-webhooks",
+    "timestamp": "2025-01-15T10:30:00.000Z",
+    "webhook_secret_configured": true
+}
+```
+
+### 2. Room Creation Test
+
+1. Create a Jitsi room via Reflector API
+2. Start a meeting - should generate Jitsi Meet URL with JWT token
+3. Join with multiple participants - should trigger participant events
+4. Start recording - should trigger Jibri recording workflow
+
+### 3. Webhook Event Test
+
+Monitor Reflector logs for incoming webhook events:
+
+```bash
+# Check for participant events
+curl -X POST "https://your-reflector-domain.com/v1/jitsi/events" \
+    -H "Content-Type: application/json" \
+    -H "X-Jitsi-Signature: test-signature" \
+    -d '{
+        "event": "muc-occupant-joined",
+        "room": "test-room-name",
+        "timestamp": "2025-01-15T10:30:00.000Z",
+        "data": {}
+    }'
+```
+
+## Troubleshooting
+
+### Common Issues
+
+#### JWT Authentication Failures
+
+**Symptoms:** Users can't join rooms, "Authentication failed" errors
+
+**Solutions:**
+1. Verify JWT secret matches between Jitsi and Reflector
+2. Check JWT token expiration (default 8 hours)
+3. Ensure system clocks are synchronized
+4. Validate JWT issuer/audience configuration
+
+```bash
+# Debug JWT tokens
+echo "JWT_TOKEN_HERE" | cut -d'.' -f2 | base64 -d | jq
+```
+
+#### Webhook Events Not Received
+
+**Symptoms:** Participant counts not updating, recording events missing
+
+**Solutions:**
+1. Verify event_sync module is loaded in Prosody
+2. Check webhook URL accessibility from Jitsi server
+3. Validate webhook signature generation
+4. Review Prosody and Reflector logs
+
+```bash
+# Test webhook connectivity
+curl -v "https://your-reflector-domain.com/v1/jitsi/health"
+
+# Check Prosody logs
+tail -f /var/log/prosody/prosody.log
+
+# Check Reflector logs
+docker logs your-reflector-container
+```
+
+#### Recording Issues
+
+**Symptoms:** Recordings not starting, finalize script errors
+
+**Solutions:**
+1. Verify Jibri service status and configuration
+2. Check recording directory permissions
+3. Validate finalize script execution permissions
+4. Monitor Jibri logs for errors
+
+```bash
+# Check Jibri status
+systemctl status jibri
+
+# Test finalize script
+sudo -u jibri /opt/jitsi/jibri/finalize.sh "/test/recording.mp4" "test-room"
+
+# Check Jibri logs
+journalctl -u jibri -f
+```
+
+### Debug Commands
+
+```bash
+# Verify Jitsi configuration
+prosodyctl check config
+
+# Test JWT generation
+curl -X POST "https://your-reflector-domain.com/v1/rooms/test/meeting" \
+    -H "Authorization: Bearer $TOKEN" -v
+
+# Monitor webhook events
+tail -f /var/log/reflector/app.log | grep jitsi
+
+# Check room participant counts
+curl "https://your-reflector-domain.com/v1/rooms" \
+    -H "Authorization: Bearer $TOKEN" | jq '.data[].num_clients'
+```
+
+### Performance Optimization
+
+#### For High-Concurrent Usage
+
+1. **Jitsi Videobridge Tuning:**
+```bash
+# /etc/jitsi/videobridge/sip-communicator.properties
+org.jitsi.videobridge.STATISTICS_INTERVAL=5000
+org.jitsi.videobridge.load.INITIAL_STREAM_LIMIT=50
+```
+
+2. **Database Connection Pooling:**
+```python
+# In your Reflector settings
+DATABASE_POOL_SIZE=20
+DATABASE_MAX_OVERFLOW=30
+```
+
+3. **Redis Configuration:**
+```bash
+# For webhook event caching
+REDIS_URL=redis://localhost:6379/1
+WEBHOOK_EVENT_TTL=3600
+```
+
+## Security Considerations
+
+### Network Security
+- Use HTTPS/WSS for all communications
+- Implement proper firewall rules
+- Consider VPN for server-to-server communication
+
+### Authentication Security
+- Rotate JWT secrets regularly
+- Use strong webhook secrets (32+ characters)
+- Implement rate limiting on webhook endpoints
+
+### Recording Security
+- Encrypt recordings at rest
+- Implement access controls for recording files
+- Regular security audits of file permissions
+
+## Support
+
+For additional support:
+
+1. **Reflector Issues:** Check GitHub issues or create new ones
+2. **Jitsi Community:** [Community Forum](https://community.jitsi.org/)
+3. **Documentation:** [Jitsi Developer Guide](https://jitsi.github.io/handbook/)
+
+## Migration from Whereby
+
+If migrating from Whereby integration:
+
+1. Update existing rooms to use "jitsi" platform
+2. Verify webhook configurations are updated
+3. Test recording workflows thoroughly
+4. Monitor participant event accuracy
+5. Update any custom integrations using meeting APIs
+
+The platform abstraction layer ensures smooth migration with minimal API changes.
--- a/server/docs/video-platforms/README.md
+++ b/server/docs/video-platforms/README.md
@@ -1,236 +0,0 @@
-# Reflector Architecture: Whereby + Daily.co Recording Storage
-
-## System Overview
-
-```mermaid
-graph TB
-    subgraph "Actors"
-        APP[Our App<br/>Reflector]
-        WHEREBY[Whereby Service<br/>External]
-        DAILY[Daily.co Service<br/>External]
-    end
-
-    subgraph "AWS S3 Buckets"
-        TRANSCRIPT_BUCKET[Transcript Bucket<br/>reflector-transcripts<br/>Output: Processed MP3s]
-        WHEREBY_BUCKET[Whereby Bucket<br/>reflector-whereby-recordings<br/>Input: Raw MP4s]
-        DAILY_BUCKET[Daily.co Bucket<br/>reflector-dailyco-recordings<br/>Input: Raw WebM tracks]
-    end
-
-    subgraph "AWS Infrastructure"
-        SQS[SQS Queue<br/>Whereby notifications]
-    end
-
-    subgraph "Database"
-        DB[(PostgreSQL<br/>Recordings, Transcripts, Meetings)]
-    end
-
-    APP -->|Write processed| TRANSCRIPT_BUCKET
-    APP -->|Read/Delete| WHEREBY_BUCKET
-    APP -->|Read/Delete| DAILY_BUCKET
-    APP -->|Poll| SQS
-    APP -->|Store metadata| DB
-
-    WHEREBY -->|Write recordings| WHEREBY_BUCKET
-    WHEREBY_BUCKET -->|S3 Event| SQS
-    WHEREBY -->|Participant webhooks<br/>room.client.joined/left| APP
-
-    DAILY -->|Write recordings| DAILY_BUCKET
-    DAILY -->|Recording webhook<br/>recording.ready-to-download| APP
-```
-
-**Note on Webhook vs S3 Event for Recording Processing:**
- **Whereby**: Uses S3 Events → SQS for recording availability (S3 as source of truth, no race conditions)
- **Daily.co**: Uses webhooks for recording availability (more immediate, built-in reliability)
- **Both**: Use webhooks for participant tracking (real-time updates)
-
-## Credentials & Permissions
-
-```mermaid
-graph LR
-    subgraph "Master Credentials"
-        MASTER[TRANSCRIPT_STORAGE_AWS_*<br/>Access Key ID + Secret]
-    end
-
-    subgraph "Whereby Upload Credentials"
-        WHEREBY_CREDS[AWS_WHEREBY_ACCESS_KEY_*<br/>Access Key ID + Secret]
-    end
-
-    subgraph "Daily.co Upload Role"
-        DAILY_ROLE[DAILY_STORAGE_AWS_ROLE_ARN<br/>IAM Role ARN]
-    end
-
-    subgraph "Our App Uses"
-        MASTER -->|Read/Write/Delete| TRANSCRIPT_BUCKET[Transcript Bucket]
-        MASTER -->|Read/Delete| WHEREBY_BUCKET[Whereby Bucket]
-        MASTER -->|Read/Delete| DAILY_BUCKET[Daily.co Bucket]
-        MASTER -->|Poll/Delete| SQS[SQS Queue]
-    end
-
-    subgraph "We Give To Services"
-        WHEREBY_CREDS -->|Passed in API call| WHEREBY_SERVICE[Whereby Service]
-        WHEREBY_SERVICE -->|Write Only| WHEREBY_BUCKET
-
-        DAILY_ROLE -->|Passed in API call| DAILY_SERVICE[Daily.co Service]
-        DAILY_SERVICE -->|Assume Role| DAILY_ROLE
-        DAILY_SERVICE -->|Write Only| DAILY_BUCKET
-    end
-```
-
-# Video Platform Recording Integration
-
-This document explains how Reflector receives and identifies multitrack audio recordings from different video platforms.
-
-## Platform Comparison
-
-| Platform | Delivery Method | Track Identification |
-|----------|----------------|---------------------|
-| **Daily.co** | Webhook | Explicit track list in payload |
-| **Whereby** | SQS (S3 notifications) | Single file per notification |
-
---
-
-## Daily.co
-
-**Note:** Primary discovery via polling (`poll_daily_recordings`), webhooks as backup.
-
-Daily.co uses **webhooks** to notify Reflector when recordings are ready.
-
-### How It Works
-
-1. **Daily.co sends webhook** when recording is ready
-   - Event type: `recording.ready-to-download`
-   - Endpoint: `/v1/daily/webhook` (`reflector/views/daily.py:46-102`)
-
-2. **Webhook payload explicitly includes track list**:
-```json
-{
-  "recording_id": "7443ee0a-dab1-40eb-b316-33d6c0d5ff88",
-  "room_name": "daily-20251020193458",
-  "tracks": [
-    {
-      "type": "audio",
-      "s3Key": "monadical/daily-20251020193458/1760988935484-52f7f48b-fbab-431f-9a50-87b9abfc8255-cam-audio-1760988935922",
-      "size": 831843
-    },
-    {
-      "type": "audio",
-      "s3Key": "monadical/daily-20251020193458/1760988935484-a37c35e3-6f8e-4274-a482-e9d0f102a732-cam-audio-1760988943823",
-      "size": 408438
-    },
-    {
-      "type": "video",
-      "s3Key": "monadical/daily-20251020193458/...-video.webm",
-      "size": 30000000
-    }
-  ]
-}
-```
-
-3. **System extracts audio tracks** (`daily.py:211`):
-```python
-track_keys = [t.s3Key for t in tracks if t.type == "audio"]
-```
-
-4. **Triggers multitrack processing** (`daily.py:213-218`):
-```python
-process_multitrack_recording.delay(
-    bucket_name=bucket_name,  # reflector-dailyco-local
-    room_name=room_name,      # daily-20251020193458
-    recording_id=recording_id, # 7443ee0a-dab1-40eb-b316-33d6c0d5ff88
-    track_keys=track_keys      # Only audio s3Keys
-)
-```
-
-### Key Advantage: No Ambiguity
-
-Even though multiple meetings may share the same S3 bucket/folder (`monadical/`), **there's no ambiguity** because:
- Each webhook payload contains the exact `s3Key` list for that specific `recording_id`
- No need to scan folders or guess which files belong together
- Each track's s3Key includes the room timestamp subfolder (e.g., `daily-20251020193458/`)
-
-The room name includes timestamp (`daily-20251020193458`) to keep recordings organized, but **the webhook's explicit track list is what prevents mixing files from different meetings**.
-
-### Track Timeline Extraction
-
-Daily.co provides timing information in two places:
-
-**1. PyAV WebM Metadata (current approach)**:
-```python
-# Read from WebM container stream metadata
-stream.start_time = 8.130s  # Meeting-relative timing
-```
-
-**2. Filename Timestamps (alternative approach, commit 3bae9076)**:
-```
-Filename format: {recording_start_ts}-{uuid}-cam-audio-{track_start_ts}.webm
-Example: 1760988935484-52f7f48b-fbab-431f-9a50-87b9abfc8255-cam-audio-1760988935922.webm
-
-Parse timestamps:
- recording_start_ts: 1760988935484 (Unix ms)
- track_start_ts: 1760988935922 (Unix ms)
- offset: (1760988935922 - 1760988935484) / 1000 = 0.438s
-```
-
-**Time Difference (PyAV vs Filename)**:
-```
-Track 0:
-  Filename offset: 438ms
-  PyAV metadata:   229ms
-  Difference:      209ms
-
-Track 1:
-  Filename offset: 8339ms
-  PyAV metadata:   8130ms
-  Difference:      209ms
-```
-
-**Consistent 209ms delta** suggests network/encoding delay between file upload initiation (filename) and actual audio stream start (metadata).
-
-**Current implementation uses PyAV metadata** because:
- More accurate (represents when audio actually started)
- Padding BEFORE transcription produces correct Whisper timestamps automatically
- No manual offset adjustment needed during transcript merge
-
-### Why Re-encoding During Padding
-
-Padding coincidentally involves re-encoding, which is important for Daily.co + Whisper:
-
-**Problem:** Daily.co skips frames in recordings when microphone is muted or paused
- WebM containers have gaps where audio frames should be
- Whisper doesn't understand these gaps and produces incorrect timestamps
- Example: 5s of audio with 2s muted → file has frames only for 3s, Whisper thinks duration is 3s
-
-**Solution:** Re-encoding via PyAV filter graph (`adelay` + `aresample`)
- Restores missing frames as silence
- Produces continuous audio stream without gaps
- Whisper now sees correct duration and produces accurate timestamps
-
-**Why combined with padding:**
- Already re-encoding for padding (adding initial silence)
- More performant to do both operations in single PyAV pipeline
- Padded values needed for mixdown anyway (creating final MP3)
-
-Implementation: `main_multitrack_pipeline.py:_apply_audio_padding_streaming()`
-
---
-
-## Whereby (SQS-based)
-
-Whereby uses **AWS SQS** (via S3 notifications) to notify Reflector when files are uploaded.
-
-### How It Works
-
-1. **Whereby uploads recording** to S3
-2. **S3 sends notification** to SQS queue (one notification per file)
-3. **Reflector polls SQS queue** (`worker/process.py:process_messages()`)
-4. **System processes single file** (`worker/process.py:process_recording()`)
-
-### Key Difference from Daily.co
-
-**Whereby (SQS):** System receives S3 notification "file X was created" - only knows about one file at a time, would need to scan folder to find related files
-
-**Daily.co (Webhook):** Daily explicitly tells system which files belong together in the webhook payload
-
---
-
-
--- a/server/docs/webhook.md
+++ b/server/docs/webhook.md
@@ -14,7 +14,7 @@ Webhooks are configured at the room level with two fields:

 ### `transcript.completed`

-Triggered when a transcript has been fully processed, including transcription, diarization, summarization, topic detection and calendar event integration.
+Triggered when a transcript has been fully processed, including transcription, diarization, summarization, and topic detection.

 ### `test`

@@ -128,27 +128,6 @@ This event includes a convenient URL for accessing the transcript:
  "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"
-      }
-    ]
  }
 }
 ```
--- 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,30 +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
-#WHEREBY_STORAGE_AWS_ACCESS_KEY_ID=your-aws-key
-#WHEREBY_STORAGE_AWS_SECRET_ACCESS_KEY=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
-#DAILY_WEBHOOK_UUID=  # Auto-populated by recreate_daily_webhook.py script
-#DAILYCO_STORAGE_AWS_ROLE_ARN=...  # IAM role ARN for Daily.co S3 access
-#DAILYCO_STORAGE_AWS_BUCKET_NAME=reflector-dailyco
-#DAILYCO_STORAGE_AWS_REGION=us-west-2
-
-## Whereby (optional separate bucket)
-#WHEREBY_STORAGE_AWS_BUCKET_NAME=reflector-whereby
-#WHEREBY_STORAGE_AWS_REGION=us-east-1
-
-## Platform Configuration
-#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
--- a/server/gpu/modal_deployments/reflector_transcriber_parakeet.py
+++ b/server/gpu/modal_deployments/reflector_transcriber_parakeet.py
@@ -77,13 +77,13 @@ 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",
-        "librosa==0.11.0",
+        "librosa==0.10.1",
        "requests",
-        "silero-vad==6.2.0",
+        "silero-vad==5.1.0",
        "torch",
    )
    .entrypoint([])  # silence chatty logs by container on start
@@ -306,7 +306,6 @@ class TranscriberParakeetFile:
        ) -> Generator[TimeSegment, None, None]:
            """Generate speech segments using VAD with start/end sample indices"""
            vad_iterator = VADIterator(self.vad_model, sampling_rate=SAMPLERATE)
-            audio_duration = len(audio_array) / float(SAMPLERATE)
            window_size = VAD_CONFIG["window_size"]
            start = None

@@ -333,10 +332,6 @@ class TranscriberParakeetFile:
                    yield TimeSegment(start_time, end_time)
                    start = None

-            if start is not None:
-                start_time = start / float(SAMPLERATE)
-                yield TimeSegment(start_time, audio_duration)
-
            vad_iterator.reset_states()

        def batch_speech_segments(
--- a/server/gpu/modal_deployments/reflector_translator.py
+++ b/server/gpu/modal_deployments/reflector_translator.py
--- a/server/migrations/versions/2890b5104577_add_events_column_to_meetings_table.py
+++ b/server/migrations/versions/2890b5104577_add_events_column_to_meetings_table.py
@@ -0,0 +1,38 @@
+"""Add events column to meetings table
+
+Revision ID: 2890b5104577
+Revises: 6e6ea8e607c5
+Create Date: 2025-09-02 17:51:41.620777
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "2890b5104577"
+down_revision: Union[str, None] = "6e6ea8e607c5"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("meeting", schema=None) as batch_op:
+        batch_op.add_column(
+            sa.Column(
+                "events", sa.JSON(), server_default=sa.text("'[]'"), nullable=False
+            )
+        )
+
+    # ### 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_column("events")
+
+    # ### end Alembic commands ###
--- a/server/migrations/versions/2b92a1b03caa_add_daily_participant_session_table_.py
+++ b/server/migrations/versions/2b92a1b03caa_add_daily_participant_session_table_.py
@@ -1,79 +0,0 @@
-"""add daily participant session table with immutable left_at
-
-Revision ID: 2b92a1b03caa
-Revises: f8294b31f022
-Create Date: 2025-11-13 20:29:30.486577
-
-"""
-
-from typing import Sequence, Union
-
-import sqlalchemy as sa
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "2b92a1b03caa"
-down_revision: Union[str, None] = "f8294b31f022"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # Create table
-    op.create_table(
-        "daily_participant_session",
-        sa.Column("id", sa.String(), nullable=False),
-        sa.Column("meeting_id", sa.String(), nullable=False),
-        sa.Column("room_id", sa.String(), nullable=False),
-        sa.Column("session_id", sa.String(), nullable=False),
-        sa.Column("user_id", sa.String(), nullable=True),
-        sa.Column("user_name", sa.String(), nullable=False),
-        sa.Column("joined_at", sa.DateTime(timezone=True), nullable=False),
-        sa.Column("left_at", sa.DateTime(timezone=True), nullable=True),
-        sa.ForeignKeyConstraint(["meeting_id"], ["meeting.id"], ondelete="CASCADE"),
-        sa.ForeignKeyConstraint(["room_id"], ["room.id"], ondelete="CASCADE"),
-        sa.PrimaryKeyConstraint("id"),
-    )
-    with op.batch_alter_table("daily_participant_session", schema=None) as batch_op:
-        batch_op.create_index(
-            "idx_daily_session_meeting_left", ["meeting_id", "left_at"], unique=False
-        )
-        batch_op.create_index("idx_daily_session_room", ["room_id"], unique=False)
-
-    # Create trigger function to prevent left_at from being updated once set
-    op.execute("""
-        CREATE OR REPLACE FUNCTION prevent_left_at_update()
-        RETURNS TRIGGER AS $$
-        BEGIN
-            IF OLD.left_at IS NOT NULL THEN
-                RAISE EXCEPTION 'left_at is immutable once set';
-            END IF;
-            RETURN NEW;
-        END;
-        $$ LANGUAGE plpgsql;
-    """)
-
-    # Create trigger
-    op.execute("""
-        CREATE TRIGGER prevent_left_at_update_trigger
-        BEFORE UPDATE ON daily_participant_session
-        FOR EACH ROW
-        EXECUTE FUNCTION prevent_left_at_update();
-    """)
-
-
-def downgrade() -> None:
-    # Drop trigger
-    op.execute(
-        "DROP TRIGGER IF EXISTS prevent_left_at_update_trigger ON daily_participant_session;"
-    )
-
-    # Drop trigger function
-    op.execute("DROP FUNCTION IF EXISTS prevent_left_at_update();")
-
-    # Drop indexes and table
-    with op.batch_alter_table("daily_participant_session", schema=None) as batch_op:
-        batch_op.drop_index("idx_daily_session_room")
-        batch_op.drop_index("idx_daily_session_meeting_left")
-
-    op.drop_table("daily_participant_session")
--- a/server/migrations/versions/5d6b9df9b045_make_room_platform_non_nullable_with_.py
+++ b/server/migrations/versions/5d6b9df9b045_make_room_platform_non_nullable_with_.py
@@ -1,30 +0,0 @@
-"""Make room platform non-nullable with dynamic default
-
-Revision ID: 5d6b9df9b045
-Revises: 2b92a1b03caa
-Create Date: 2025-11-21 13:22:25.756584
-
-"""
-
-from typing import Sequence, Union
-
-import sqlalchemy as sa
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "5d6b9df9b045"
-down_revision: Union[str, None] = "2b92a1b03caa"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    op.execute("UPDATE room SET platform = 'whereby' WHERE platform IS NULL")
-
-    with op.batch_alter_table("room", schema=None) as batch_op:
-        batch_op.alter_column("platform", existing_type=sa.String(), nullable=False)
-
-
-def downgrade() -> None:
-    with op.batch_alter_table("room", schema=None) as batch_op:
-        batch_op.alter_column("platform", existing_type=sa.String(), nullable=True)
--- 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/6dec9fb5b46c_make_meeting_room_id_required_and_add_.py
+++ b/server/migrations/versions/6dec9fb5b46c_make_meeting_room_id_required_and_add_.py
@@ -8,6 +8,7 @@ Create Date: 2025-09-10 10:47:06.006819

 from typing import Sequence, Union

+import sqlalchemy as sa
 from alembic import op

 # revision identifiers, used by Alembic.
@@ -20,6 +21,7 @@ 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=False)
        batch_op.create_foreign_key(
            None, "room", ["room_id"], ["id"], ondelete="CASCADE"
        )
@@ -31,5 +33,6 @@ 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")
+        batch_op.alter_column("room_id", existing_type=sa.VARCHAR(), nullable=True)

    # ### end Alembic commands ###
--- a/server/migrations/versions/6e6ea8e607c5_add_videoplatform_enum_for_rooms_and_.py
+++ b/server/migrations/versions/6e6ea8e607c5_add_videoplatform_enum_for_rooms_and_.py
@@ -1,8 +1,8 @@
-"""add_platform_support
+"""Add VideoPlatform enum for rooms and meetings

-Revision ID: 1e49625677e4
-Revises: 9e3f7b2a4c8e
-Create Date: 2025-10-08 13:17:29.943612
+Revision ID: 6e6ea8e607c5
+Revises: 61882a919591
+Create Date: 2025-09-02 17:33:21.022214

 """

@@ -12,39 +12,33 @@ import sqlalchemy as sa
 from alembic import op

 # revision identifiers, used by Alembic.
-revision: str = "1e49625677e4"
-down_revision: Union[str, None] = "9e3f7b2a4c8e"
+revision: str = "6e6ea8e607c5"
+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:
-    """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=True,
-                server_default=None,
-            )
-        )
-
+    # ### commands auto generated by Alembic - please adjust! ###
    with op.batch_alter_table("meeting", schema=None) as batch_op:
        batch_op.add_column(
-            sa.Column(
-                "platform",
-                sa.String(),
-                nullable=False,
-                server_default="whereby",
-            )
+            sa.Column("platform", sa.String(), server_default="whereby", nullable=False)
        )

+    with op.batch_alter_table("room", schema=None) as batch_op:
+        batch_op.add_column(
+            sa.Column("platform", sa.String(), server_default="whereby", nullable=False)
+        )
+
+    # ### end Alembic commands ###
+

 def downgrade() -> None:
-    """Remove platform field."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("room", schema=None) as batch_op:
+        batch_op.drop_column("platform")
+
    with op.batch_alter_table("meeting", schema=None) as batch_op:
        batch_op.drop_column("platform")

-    with op.batch_alter_table("room", schema=None) as batch_op:
-        batch_op.drop_column("platform")
+    # ### end Alembic commands ###
--- a/server/migrations/versions/9e3f7b2a4c8e_add_user_api_keys.py
+++ b/server/migrations/versions/9e3f7b2a4c8e_add_user_api_keys.py
@@ -1,38 +0,0 @@
-"""add user api keys
-
-Revision ID: 9e3f7b2a4c8e
-Revises: dc035ff72fd5
-Create Date: 2025-10-17 00:00:00.000000
-
-"""
-
-from typing import Sequence, Union
-
-import sqlalchemy as sa
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "9e3f7b2a4c8e"
-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:
-    op.create_table(
-        "user_api_key",
-        sa.Column("id", sa.String(), nullable=False),
-        sa.Column("user_id", sa.String(), nullable=False),
-        sa.Column("key_hash", sa.String(), nullable=False),
-        sa.Column("name", sa.String(), nullable=True),
-        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
-        sa.PrimaryKeyConstraint("id"),
-    )
-
-    with op.batch_alter_table("user_api_key", schema=None) as batch_op:
-        batch_op.create_index("idx_user_api_key_hash", ["key_hash"], unique=True)
-        batch_op.create_index("idx_user_api_key_user_id", ["user_id"], unique=False)
-
-
-def downgrade() -> None:
-    op.drop_table("user_api_key")
--- a/server/migrations/versions/bbafedfa510c_add_user_table.py
+++ b/server/migrations/versions/bbafedfa510c_add_user_table.py
@@ -1,38 +0,0 @@
-"""add user table
-
-Revision ID: bbafedfa510c
-Revises: 5d6b9df9b045
-Create Date: 2025-11-19 21:06:30.543262
-
-"""
-
-from typing import Sequence, Union
-
-import sqlalchemy as sa
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "bbafedfa510c"
-down_revision: Union[str, None] = "5d6b9df9b045"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    op.create_table(
-        "user",
-        sa.Column("id", sa.String(), nullable=False),
-        sa.Column("email", sa.String(), nullable=False),
-        sa.Column("authentik_uid", sa.String(), nullable=False),
-        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
-        sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
-        sa.PrimaryKeyConstraint("id"),
-    )
-
-    with op.batch_alter_table("user", schema=None) as batch_op:
-        batch_op.create_index("idx_user_authentik_uid", ["authentik_uid"], unique=True)
-        batch_op.create_index("idx_user_email", ["email"], unique=False)
-
-
-def downgrade() -> None:
-    op.drop_table("user")
--- 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/f8294b31f022_add_track_keys.py
+++ b/server/migrations/versions/f8294b31f022_add_track_keys.py
@@ -1,28 +0,0 @@
-"""add_track_keys
-
-Revision ID: f8294b31f022
-Revises: 1e49625677e4
-Create Date: 2025-10-27 18:52:17.589167
-
-"""
-
-from typing import Sequence, Union
-
-import sqlalchemy as sa
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "f8294b31f022"
-down_revision: Union[str, None] = "1e49625677e4"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    with op.batch_alter_table("recording", schema=None) as batch_op:
-        batch_op.add_column(sa.Column("track_keys", sa.JSON(), nullable=True))
-
-
-def downgrade() -> None:
-    with op.batch_alter_table("recording", schema=None) as batch_op:
-        batch_op.drop_column("track_keys")
--- 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,7 @@ dependencies = [
    "llama-index-llms-openai-like>=0.4.0",
    "pytest-env>=1.1.5",
    "webvtt-py>=0.5.0",
-    "icalendar>=6.0.0",
+    "PyJWT>=2.8.0",
 ]

 [dependency-groups]
@@ -112,27 +114,25 @@ 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]
 select = [
    "I",       # isort - import sorting
    "F401",    # unused imports
-    "E402",    # module level import not at top of file
    "PLC0415", # import-outside-top-level - detect inline imports
 ]

 [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,9 @@ 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.video_platforms.jitsi import router as jitsi_router
+from reflector.video_platforms.whereby import router as whereby_router
+from reflector.views.jibri_webhook import router as jibri_webhook_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,9 +29,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_api_keys import router as user_api_keys_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

 try:
@@ -68,12 +67,6 @@ app.add_middleware(
    allow_headers=["*"],
 )

-
-@app.get("/health")
-async def health():
-    return {"status": "healthy"}
-
-
 # metrics
 instrumentator = Instrumentator(
    excluded_handlers=["/docs", "/metrics"],
@@ -93,11 +86,10 @@ 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_api_keys_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")
+app.include_router(jitsi_router, prefix="/v1")
+app.include_router(jibri_webhook_router)  # No /v1 prefix, uses /api/v1/jibri
 add_pagination(app)

 # prepare celery
--- a/server/reflector/asynctask.py
+++ b/server/reflector/asynctask.py
@@ -1,19 +1,13 @@
 import asyncio
 import functools
-from uuid import uuid4
-
-from celery import current_task

 from reflector.db import get_database
-from reflector.llm import llm_session_id


 def asynctask(f):
    @functools.wraps(f)
    def wrapper(*args, **kwargs):
        async def run_with_db():
-            task_id = current_task.request.id if current_task else None
-            llm_session_id.set(task_id or f"random-{uuid4().hex}")
            database = get_database()
            await database.connect()
            try:
--- a/server/reflector/auth/auth_jwt.py
+++ b/server/reflector/auth/auth_jwt.py
@@ -1,18 +1,14 @@
-from typing import Annotated, List, Optional
+from typing import Annotated, Optional

 from fastapi import Depends, HTTPException
-from fastapi.security import APIKeyHeader, OAuth2PasswordBearer
+from fastapi.security import OAuth2PasswordBearer
 from jose import JWTError, jwt
 from pydantic import BaseModel

-from reflector.db.user_api_keys import user_api_keys_controller
-from reflector.db.users import user_controller
 from reflector.logger import logger
 from reflector.settings import settings
-from reflector.utils import generate_uuid4

 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token", auto_error=False)
-api_key_header = APIKeyHeader(name="X-API-Key", auto_error=False)

 jwt_public_key = open(f"reflector/auth/jwt/keys/{settings.AUTH_JWT_PUBLIC_KEY}").read()
 jwt_algorithm = settings.AUTH_JWT_ALGORITHM
@@ -30,7 +26,7 @@ class JWTException(Exception):

 class UserInfo(BaseModel):
    sub: str
-    email: Optional[str] = None
+    email: str

    def __getitem__(self, key):
        return getattr(self, key)
@@ -62,65 +58,33 @@ def authenticated(token: Annotated[str, Depends(oauth2_scheme)]):
    return None


-async def _authenticate_user(
-    jwt_token: Optional[str],
-    api_key: Optional[str],
-    jwtauth: JWTAuth,
-) -> UserInfo | None:
-    user_infos: List[UserInfo] = []
-    if api_key:
-        user_api_key = await user_api_keys_controller.verify_key(api_key)
-        if user_api_key:
-            user_infos.append(UserInfo(sub=user_api_key.user_id, email=None))
-
-    if jwt_token:
-        try:
-            payload = jwtauth.verify_token(jwt_token)
-            authentik_uid = payload["sub"]
-            email = payload["email"]
-
-            user = await user_controller.get_by_authentik_uid(authentik_uid)
-            if not user:
-                logger.info(
-                    f"Creating new user on first login: {authentik_uid} ({email})"
-                )
-                user = await user_controller.create_or_update(
-                    id=generate_uuid4(),
-                    authentik_uid=authentik_uid,
-                    email=email,
-                )
-
-            user_infos.append(UserInfo(sub=user.id, email=email))
-        except JWTError as e:
-            logger.error(f"JWT error: {e}")
-            raise HTTPException(status_code=401, detail="Invalid authentication")
-
-    if len(user_infos) == 0:
-        return None
-
-    if len(set([x.sub for x in user_infos])) > 1:
-        raise JWTException(
-            status_code=401,
-            detail="Invalid authentication: more than one user provided",
-        )
-
-    return user_infos[0]
-
-
-async def current_user(
-    jwt_token: Annotated[Optional[str], Depends(oauth2_scheme)],
-    api_key: Annotated[Optional[str], Depends(api_key_header)],
+def current_user(
+    token: Annotated[Optional[str], Depends(oauth2_scheme)],
    jwtauth: JWTAuth = Depends(),
 ):
-    user = await _authenticate_user(jwt_token, api_key, jwtauth)
-    if user is None:
+    if token is None:
        raise HTTPException(status_code=401, detail="Not authenticated")
-    return user
+    try:
+        payload = jwtauth.verify_token(token)
+        sub = payload["sub"]
+        return UserInfo(sub=sub)
+    except JWTError as e:
+        logger.error(f"JWT error: {e}")
+        raise HTTPException(status_code=401, detail="Invalid authentication")


-async def current_user_optional(
-    jwt_token: Annotated[Optional[str], Depends(oauth2_scheme)],
-    api_key: Annotated[Optional[str], Depends(api_key_header)],
+def current_user_optional(
+    token: Annotated[Optional[str], Depends(oauth2_scheme)],
    jwtauth: JWTAuth = Depends(),
 ):
-    return await _authenticate_user(jwt_token, api_key, jwtauth)
+    # we accept no token, but if one is provided, it must be a valid one.
+    if token is None:
+        return None
+    try:
+        payload = jwtauth.verify_token(token)
+        sub = payload["sub"]
+        email = payload["email"]
+        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/dailyco_api/README.md
+++ b/server/reflector/dailyco_api/README.md
@@ -1,6 +0,0 @@
-anything about Daily.co api interaction
-
- webhook event shapes
- REST api client
-
-No REST api client existing found in the wild; the official lib is about working with videocall as a bot
--- a/server/reflector/dailyco_api/init.py
+++ b/server/reflector/dailyco_api/init.py
@@ -1,108 +0,0 @@
-"""
-Daily.co API Module
-"""
-
-# Client
-from .client import DailyApiClient, DailyApiError
-
-# Request models
-from .requests import (
-    CreateMeetingTokenRequest,
-    CreateRoomRequest,
-    CreateWebhookRequest,
-    MeetingTokenProperties,
-    RecordingsBucketConfig,
-    RoomProperties,
-    UpdateWebhookRequest,
-)
-
-# Response models
-from .responses import (
-    MeetingParticipant,
-    MeetingParticipantsResponse,
-    MeetingResponse,
-    MeetingTokenResponse,
-    RecordingResponse,
-    RecordingS3Info,
-    RoomPresenceParticipant,
-    RoomPresenceResponse,
-    RoomResponse,
-    WebhookResponse,
-)
-
-# Webhook utilities
-from .webhook_utils import (
-    extract_room_name,
-    parse_participant_joined,
-    parse_participant_left,
-    parse_recording_error,
-    parse_recording_ready,
-    parse_recording_started,
-    parse_webhook_payload,
-    verify_webhook_signature,
-)
-
-# Webhook models
-from .webhooks import (
-    DailyTrack,
-    DailyWebhookEvent,
-    DailyWebhookEventUnion,
-    ParticipantJoinedEvent,
-    ParticipantJoinedPayload,
-    ParticipantLeftEvent,
-    ParticipantLeftPayload,
-    RecordingErrorEvent,
-    RecordingErrorPayload,
-    RecordingReadyEvent,
-    RecordingReadyToDownloadPayload,
-    RecordingStartedEvent,
-    RecordingStartedPayload,
-)
-
-__all__ = [
-    # Client
-    "DailyApiClient",
-    "DailyApiError",
-    # Requests
-    "CreateRoomRequest",
-    "RoomProperties",
-    "RecordingsBucketConfig",
-    "CreateMeetingTokenRequest",
-    "MeetingTokenProperties",
-    "CreateWebhookRequest",
-    "UpdateWebhookRequest",
-    # Responses
-    "RoomResponse",
-    "RoomPresenceResponse",
-    "RoomPresenceParticipant",
-    "MeetingParticipantsResponse",
-    "MeetingParticipant",
-    "MeetingResponse",
-    "RecordingResponse",
-    "RecordingS3Info",
-    "MeetingTokenResponse",
-    "WebhookResponse",
-    # Webhooks
-    "DailyWebhookEvent",
-    "DailyWebhookEventUnion",
-    "DailyTrack",
-    "ParticipantJoinedEvent",
-    "ParticipantJoinedPayload",
-    "ParticipantLeftEvent",
-    "ParticipantLeftPayload",
-    "RecordingStartedEvent",
-    "RecordingStartedPayload",
-    "RecordingReadyEvent",
-    "RecordingReadyToDownloadPayload",
-    "RecordingErrorEvent",
-    "RecordingErrorPayload",
-    # Webhook utilities
-    "verify_webhook_signature",
-    "extract_room_name",
-    "parse_webhook_payload",
-    "parse_participant_joined",
-    "parse_participant_left",
-    "parse_recording_started",
-    "parse_recording_ready",
-    "parse_recording_error",
-]
--- a/server/reflector/dailyco_api/client.py
+++ b/server/reflector/dailyco_api/client.py
@@ -1,573 +0,0 @@
-"""
-Daily.co API Client
-
-Complete async client for Daily.co REST API with Pydantic models.
-
-Reference: https://docs.daily.co/reference/rest-api
-"""
-
-from http import HTTPStatus
-from typing import Any
-
-import httpx
-import structlog
-
-from reflector.utils.string import NonEmptyString
-
-from .requests import (
-    CreateMeetingTokenRequest,
-    CreateRoomRequest,
-    CreateWebhookRequest,
-    UpdateWebhookRequest,
-)
-from .responses import (
-    MeetingParticipantsResponse,
-    MeetingResponse,
-    MeetingTokenResponse,
-    RecordingResponse,
-    RoomPresenceResponse,
-    RoomResponse,
-    WebhookResponse,
-)
-
-logger = structlog.get_logger(__name__)
-
-
-class DailyApiError(Exception):
-    """Daily.co API error with full request/response context."""
-
-    def __init__(self, operation: str, response: httpx.Response):
-        self.operation = operation
-        self.response = response
-        self.status_code = response.status_code
-        self.response_body = response.text
-        self.url = str(response.url)
-        self.request_body = (
-            response.request.content.decode() if response.request.content else None
-        )
-
-        super().__init__(
-            f"Daily.co API error: {operation} failed with status {self.status_code}"
-        )
-
-
-class DailyApiClient:
-    """
-    Complete async client for Daily.co REST API.
-
-    Usage:
-        # Direct usage
-        client = DailyApiClient(api_key="your_api_key")
-        room = await client.create_room(CreateRoomRequest(name="my-room"))
-        await client.close()  # Clean up when done
-
-        # Context manager (recommended)
-        async with DailyApiClient(api_key="your_api_key") as client:
-            room = await client.create_room(CreateRoomRequest(name="my-room"))
-    """
-
-    BASE_URL = "https://api.daily.co/v1"
-    DEFAULT_TIMEOUT = 10.0
-
-    def __init__(
-        self,
-        api_key: NonEmptyString,
-        webhook_secret: NonEmptyString | None = None,
-        timeout: float = DEFAULT_TIMEOUT,
-        base_url: NonEmptyString | None = None,
-    ):
-        """
-        Initialize Daily.co API client.
-
-        Args:
-            api_key: Daily.co API key (Bearer token)
-            webhook_secret: Base64-encoded HMAC secret for webhook verification.
-                Must match the 'hmac' value provided when creating webhooks.
-                Generate with: base64.b64encode(os.urandom(32)).decode()
-            timeout: Default request timeout in seconds
-            base_url: Override base URL (for testing)
-        """
-        self.api_key = api_key
-        self.webhook_secret = webhook_secret
-        self.timeout = timeout
-        self.base_url = base_url or self.BASE_URL
-
-        self.headers = {
-            "Authorization": f"Bearer {api_key}",
-            "Content-Type": "application/json",
-        }
-
-        self._client: httpx.AsyncClient | None = None
-
-    async def __aenter__(self):
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        await self.close()
-
-    async def _get_client(self) -> httpx.AsyncClient:
-        if self._client is None:
-            self._client = httpx.AsyncClient(timeout=self.timeout)
-        return self._client
-
-    async def close(self):
-        if self._client is not None:
-            await self._client.aclose()
-            self._client = None
-
-    async def _handle_response(
-        self, response: httpx.Response, operation: str
-    ) -> dict[str, Any]:
-        """
-        Handle API response with error logging.
-
-        Args:
-            response: HTTP response
-            operation: Operation name for logging (e.g., "create_room")
-
-        Returns:
-            Parsed JSON response
-
-        Raises:
-            DailyApiError: If request failed with full context
-        """
-        if response.status_code >= 400:
-            logger.error(
-                f"Daily.co API error: {operation}",
-                status_code=response.status_code,
-                response_body=response.text,
-                request_body=response.request.content.decode()
-                if response.request.content
-                else None,
-                url=str(response.url),
-            )
-            raise DailyApiError(operation, response)
-
-        return response.json()
-
-    # ============================================================================
-    # ROOMS
-    # ============================================================================
-
-    async def create_room(self, request: CreateRoomRequest) -> RoomResponse:
-        """
-        Create a new Daily.co room.
-
-        Reference: https://docs.daily.co/reference/rest-api/rooms/create-room
-
-        Args:
-            request: Room creation request with name, privacy, and properties
-
-        Returns:
-            Created room data including URL and ID
-
-        Raises:
-            httpx.HTTPStatusError: If API request fails
-        """
-        client = await self._get_client()
-        response = await client.post(
-            f"{self.base_url}/rooms",
-            headers=self.headers,
-            json=request.model_dump(exclude_none=True),
-        )
-
-        data = await self._handle_response(response, "create_room")
-        return RoomResponse(**data)
-
-    async def get_room(self, room_name: NonEmptyString) -> RoomResponse:
-        """
-        Get room configuration.
-
-        Args:
-            room_name: Daily.co room name
-
-        Returns:
-            Room configuration data
-
-        Raises:
-            httpx.HTTPStatusError: If API request fails
-        """
-        client = await self._get_client()
-        response = await client.get(
-            f"{self.base_url}/rooms/{room_name}",
-            headers=self.headers,
-        )
-
-        data = await self._handle_response(response, "get_room")
-        return RoomResponse(**data)
-
-    async def get_room_presence(
-        self, room_name: NonEmptyString
-    ) -> RoomPresenceResponse:
-        """
-        Get current participants in a room (real-time presence).
-
-        Reference: https://docs.daily.co/reference/rest-api/rooms/get-room-presence
-
-        Args:
-            room_name: Daily.co room name
-
-        Returns:
-            List of currently present participants with join time and duration
-
-        Raises:
-            httpx.HTTPStatusError: If API request fails
-        """
-        client = await self._get_client()
-        response = await client.get(
-            f"{self.base_url}/rooms/{room_name}/presence",
-            headers=self.headers,
-        )
-
-        data = await self._handle_response(response, "get_room_presence")
-        return RoomPresenceResponse(**data)
-
-    async def delete_room(self, room_name: NonEmptyString) -> None:
-        """
-        Delete a room (idempotent - succeeds even if room doesn't exist).
-
-        Reference: https://docs.daily.co/reference/rest-api/rooms/delete-room
-
-        Args:
-            room_name: Daily.co room name
-
-        Raises:
-            httpx.HTTPStatusError: If API request fails (except 404)
-        """
-        client = await self._get_client()
-        response = await client.delete(
-            f"{self.base_url}/rooms/{room_name}",
-            headers=self.headers,
-        )
-
-        # Idempotent delete - 404 means already deleted
-        if response.status_code == HTTPStatus.NOT_FOUND:
-            logger.debug("Room not found (already deleted)", room_name=room_name)
-            return
-
-        await self._handle_response(response, "delete_room")
-
-    # ============================================================================
-    # MEETINGS
-    # ============================================================================
-
-    async def get_meeting(self, meeting_id: NonEmptyString) -> MeetingResponse:
-        """
-        Get full meeting information including participants.
-
-        Reference: https://docs.daily.co/reference/rest-api/meetings/get-meeting-information
-
-        Args:
-            meeting_id: Daily.co meeting/session ID
-
-        Returns:
-            Meeting metadata including room, duration, participants, and status
-
-        Raises:
-            httpx.HTTPStatusError: If API request fails
-        """
-        client = await self._get_client()
-        response = await client.get(
-            f"{self.base_url}/meetings/{meeting_id}",
-            headers=self.headers,
-        )
-
-        data = await self._handle_response(response, "get_meeting")
-        return MeetingResponse(**data)
-
-    async def get_meeting_participants(
-        self,
-        meeting_id: NonEmptyString,
-        limit: int | None = None,
-        joined_after: NonEmptyString | None = None,
-        joined_before: NonEmptyString | None = None,
-    ) -> MeetingParticipantsResponse:
-        """
-        Get historical participant data from a completed meeting (paginated).
-
-        Reference: https://docs.daily.co/reference/rest-api/meetings/get-meeting-participants
-
-        Args:
-            meeting_id: Daily.co meeting/session ID
-            limit: Maximum number of participant records to return
-            joined_after: Return participants who joined after this participant_id
-            joined_before: Return participants who joined before this participant_id
-
-        Returns:
-            List of participants with join times and duration
-
-        Raises:
-            httpx.HTTPStatusError: If API request fails (404 when no more participants)
-
-        Note:
-            For pagination, use joined_after with the last participant_id from previous response.
-            Returns 404 when no more participants remain.
-        """
-        params = {}
-        if limit is not None:
-            params["limit"] = limit
-        if joined_after is not None:
-            params["joined_after"] = joined_after
-        if joined_before is not None:
-            params["joined_before"] = joined_before
-
-        client = await self._get_client()
-        response = await client.get(
-            f"{self.base_url}/meetings/{meeting_id}/participants",
-            headers=self.headers,
-            params=params,
-        )
-
-        data = await self._handle_response(response, "get_meeting_participants")
-        return MeetingParticipantsResponse(**data)
-
-    # ============================================================================
-    # RECORDINGS
-    # ============================================================================
-
-    async def get_recording(self, recording_id: NonEmptyString) -> RecordingResponse:
-        """
-        https://docs.daily.co/reference/rest-api/recordings/get-recording-information
-        Get recording metadata and status.
-        """
-        client = await self._get_client()
-        response = await client.get(
-            f"{self.base_url}/recordings/{recording_id}",
-            headers=self.headers,
-        )
-
-        data = await self._handle_response(response, "get_recording")
-        return RecordingResponse(**data)
-
-    async def list_recordings(
-        self,
-        room_name: NonEmptyString | None = None,
-        starting_after: str | None = None,
-        ending_before: str | None = None,
-        limit: int = 100,
-    ) -> list[RecordingResponse]:
-        """
-        List recordings with optional filters.
-
-        Reference: https://docs.daily.co/reference/rest-api/recordings
-
-        Args:
-            room_name: Filter by room name
-            starting_after: Pagination cursor - recording ID to start after
-            ending_before: Pagination cursor - recording ID to end before
-            limit: Max results per page (default 100, max 100)
-
-        Note: starting_after/ending_before are pagination cursors (recording IDs),
-        NOT time filters. API returns recordings in reverse chronological order.
-        """
-        client = await self._get_client()
-
-        params = {"limit": limit}
-        if room_name:
-            params["room_name"] = room_name
-        if starting_after:
-            params["starting_after"] = starting_after
-        if ending_before:
-            params["ending_before"] = ending_before
-
-        response = await client.get(
-            f"{self.base_url}/recordings",
-            headers=self.headers,
-            params=params,
-        )
-
-        data = await self._handle_response(response, "list_recordings")
-
-        if not isinstance(data, dict) or "data" not in data:
-            logger.error(
-                "Daily.co API returned unexpected format for list_recordings",
-                data_type=type(data).__name__,
-                data_keys=list(data.keys()) if isinstance(data, dict) else None,
-                data_sample=str(data)[:500],
-                room_name=room_name,
-                operation="list_recordings",
-            )
-            raise httpx.HTTPStatusError(
-                message=f"Unexpected response format from list_recordings: {type(data).__name__}",
-                request=response.request,
-                response=response,
-            )
-
-        return [RecordingResponse(**r) for r in data["data"]]
-
-    # ============================================================================
-    # MEETING TOKENS
-    # ============================================================================
-
-    async def create_meeting_token(
-        self, request: CreateMeetingTokenRequest
-    ) -> MeetingTokenResponse:
-        """
-        Create a meeting token for participant authentication.
-
-        Reference: https://docs.daily.co/reference/rest-api/meeting-tokens/create-meeting-token
-
-        Args:
-            request: Token properties including room name, user_id, permissions
-
-        Returns:
-            JWT meeting token
-
-        Raises:
-            httpx.HTTPStatusError: If API request fails
-        """
-        client = await self._get_client()
-        response = await client.post(
-            f"{self.base_url}/meeting-tokens",
-            headers=self.headers,
-            json=request.model_dump(exclude_none=True),
-        )
-
-        data = await self._handle_response(response, "create_meeting_token")
-        return MeetingTokenResponse(**data)
-
-    # ============================================================================
-    # WEBHOOKS
-    # ============================================================================
-
-    async def list_webhooks(self) -> list[WebhookResponse]:
-        """
-        List all configured webhooks for this account.
-
-        Reference: https://docs.daily.co/reference/rest-api/webhooks
-
-        Returns:
-            List of webhook configurations
-
-        Raises:
-            httpx.HTTPStatusError: If API request fails
-        """
-        client = await self._get_client()
-        response = await client.get(
-            f"{self.base_url}/webhooks",
-            headers=self.headers,
-        )
-
-        data = await self._handle_response(response, "list_webhooks")
-
-        # Daily.co returns array directly (not paginated)
-        if isinstance(data, list):
-            return [WebhookResponse(**wh) for wh in data]
-
-        # Future-proof: handle potential pagination envelope
-        if isinstance(data, dict) and "data" in data:
-            return [WebhookResponse(**wh) for wh in data["data"]]
-
-        logger.warning("Unexpected webhook list response format", data=data)
-        return []
-
-    async def create_webhook(self, request: CreateWebhookRequest) -> WebhookResponse:
-        """
-        Create a new webhook subscription.
-
-        Reference: https://docs.daily.co/reference/rest-api/webhooks
-
-        Args:
-            request: Webhook configuration with URL, event types, and HMAC secret
-
-        Returns:
-            Created webhook with UUID and state
-
-        Raises:
-            httpx.HTTPStatusError: If API request fails
-        """
-        client = await self._get_client()
-        response = await client.post(
-            f"{self.base_url}/webhooks",
-            headers=self.headers,
-            json=request.model_dump(exclude_none=True),
-        )
-
-        data = await self._handle_response(response, "create_webhook")
-        return WebhookResponse(**data)
-
-    async def update_webhook(
-        self, webhook_uuid: NonEmptyString, request: UpdateWebhookRequest
-    ) -> WebhookResponse:
-        """
-        Update webhook configuration.
-
-        Note: Daily.co may not support PATCH for all fields.
-        Common pattern is delete + recreate.
-
-        Reference: https://docs.daily.co/reference/rest-api/webhooks
-
-        Args:
-            webhook_uuid: Webhook UUID to update
-            request: Updated webhook configuration
-
-        Returns:
-            Updated webhook configuration
-
-        Raises:
-            httpx.HTTPStatusError: If API request fails
-        """
-        client = await self._get_client()
-        response = await client.patch(
-            f"{self.base_url}/webhooks/{webhook_uuid}",
-            headers=self.headers,
-            json=request.model_dump(exclude_none=True),
-        )
-
-        data = await self._handle_response(response, "update_webhook")
-        return WebhookResponse(**data)
-
-    async def delete_webhook(self, webhook_uuid: NonEmptyString) -> None:
-        """
-        Delete a webhook.
-
-        Reference: https://docs.daily.co/reference/rest-api/webhooks
-
-        Args:
-            webhook_uuid: Webhook UUID to delete
-
-        Raises:
-            httpx.HTTPStatusError: If webhook not found or deletion fails
-        """
-        client = await self._get_client()
-        response = await client.delete(
-            f"{self.base_url}/webhooks/{webhook_uuid}",
-            headers=self.headers,
-        )
-
-        await self._handle_response(response, "delete_webhook")
-
-    # ============================================================================
-    # HELPER METHODS
-    # ============================================================================
-
-    async def find_webhook_by_url(self, url: NonEmptyString) -> WebhookResponse | None:
-        """
-        Find a webhook by its URL.
-
-        Args:
-            url: Webhook endpoint URL to search for
-
-        Returns:
-            Webhook if found, None otherwise
-        """
-        webhooks = await self.list_webhooks()
-        for webhook in webhooks:
-            if webhook.url == url:
-                return webhook
-        return None
-
-    async def find_webhooks_by_pattern(
-        self, pattern: NonEmptyString
-    ) -> list[WebhookResponse]:
-        """
-        Find webhooks matching a URL pattern (e.g., 'ngrok').
-
-        Args:
-            pattern: String to match in webhook URLs
-
-        Returns:
-            List of matching webhooks
-        """
-        webhooks = await self.list_webhooks()
-        return [wh for wh in webhooks if pattern in wh.url]
--- a/server/reflector/dailyco_api/requests.py
+++ b/server/reflector/dailyco_api/requests.py
@@ -1,162 +0,0 @@
-"""
-Daily.co API Request Models
-
-Reference: https://docs.daily.co/reference/rest-api
-"""
-
-from typing import List, Literal
-
-from pydantic import BaseModel, Field
-
-from reflector.utils.string import NonEmptyString
-
-
-class RecordingsBucketConfig(BaseModel):
-    """
-    S3 bucket configuration for raw-tracks recordings.
-
-    Reference: https://docs.daily.co/reference/rest-api/rooms/create-room
-    """
-
-    bucket_name: NonEmptyString = Field(description="S3 bucket name")
-    bucket_region: NonEmptyString = Field(description="AWS region (e.g., 'us-east-1')")
-    assume_role_arn: NonEmptyString = Field(
-        description="AWS IAM role ARN that Daily.co will assume to write recordings"
-    )
-    allow_api_access: bool = Field(
-        default=True,
-        description="Whether to allow API access to recording metadata",
-    )
-
-
-class RoomProperties(BaseModel):
-    """
-    Room configuration properties.
-    """
-
-    enable_recording: Literal["cloud", "local", "raw-tracks"] | None = Field(
-        default=None,
-        description="Recording mode: 'cloud' for mixed, 'local' for local recording, 'raw-tracks' for multitrack, None to disable",
-    )
-    enable_chat: bool = Field(default=True, description="Enable in-meeting chat")
-    enable_screenshare: bool = Field(default=True, description="Enable screen sharing")
-    enable_knocking: bool = Field(
-        default=False,
-        description="Enable knocking for private rooms (allows participants to request access)",
-    )
-    start_video_off: bool = Field(
-        default=False, description="Start with video off for all participants"
-    )
-    start_audio_off: bool = Field(
-        default=False, description="Start with audio muted for all participants"
-    )
-    exp: int | None = Field(
-        None, description="Room expiration timestamp (Unix epoch seconds)"
-    )
-    recordings_bucket: RecordingsBucketConfig | None = Field(
-        None, description="S3 bucket configuration for raw-tracks recordings"
-    )
-
-
-class CreateRoomRequest(BaseModel):
-    """
-    Request to create a new Daily.co room.
-
-    Reference: https://docs.daily.co/reference/rest-api/rooms/create-room
-    """
-
-    name: NonEmptyString = Field(description="Room name (must be unique within domain)")
-    privacy: Literal["public", "private"] = Field(
-        default="public", description="Room privacy setting"
-    )
-    properties: RoomProperties = Field(
-        default_factory=RoomProperties, description="Room configuration properties"
-    )
-
-
-class MeetingTokenProperties(BaseModel):
-    """
-    Properties for meeting token creation.
-
-    Reference: https://docs.daily.co/reference/rest-api/meeting-tokens/create-meeting-token
-    """
-
-    room_name: NonEmptyString = Field(description="Room name this token is valid for")
-    user_id: NonEmptyString | None = Field(
-        None, description="User identifier to associate with token"
-    )
-    is_owner: bool = Field(
-        default=False, description="Grant owner privileges to token holder"
-    )
-    start_cloud_recording: bool = Field(
-        default=False, description="Automatically start cloud recording on join"
-    )
-    enable_recording_ui: bool = Field(
-        default=True, description="Show recording controls in UI"
-    )
-    eject_at_token_exp: bool = Field(
-        default=False, description="Eject participant when token expires"
-    )
-    nbf: int | None = Field(
-        None, description="Not-before timestamp (Unix epoch seconds)"
-    )
-    exp: int | None = Field(
-        None, description="Expiration timestamp (Unix epoch seconds)"
-    )
-
-
-class CreateMeetingTokenRequest(BaseModel):
-    """
-    Request to create a meeting token for participant authentication.
-
-    Reference: https://docs.daily.co/reference/rest-api/meeting-tokens/create-meeting-token
-    """
-
-    properties: MeetingTokenProperties = Field(description="Token properties")
-
-
-class CreateWebhookRequest(BaseModel):
-    """
-    Request to create a webhook subscription.
-
-    Reference: https://docs.daily.co/reference/rest-api/webhooks
-    """
-
-    url: NonEmptyString = Field(description="Webhook endpoint URL (must be HTTPS)")
-    eventTypes: List[
-        Literal[
-            "participant.joined",
-            "participant.left",
-            "recording.started",
-            "recording.ready-to-download",
-            "recording.error",
-        ]
-    ] = Field(
-        description="Array of event types to subscribe to (only events we handle)"
-    )
-    hmac: NonEmptyString = Field(
-        description="Base64-encoded HMAC secret for webhook signature verification"
-    )
-    basicAuth: NonEmptyString | None = Field(
-        None, description="Optional basic auth credentials for webhook endpoint"
-    )
-
-
-class UpdateWebhookRequest(BaseModel):
-    """
-    Request to update an existing webhook.
-
-    Note: Daily.co API may not support PATCH for webhooks.
-    Common pattern is to delete and recreate.
-
-    Reference: https://docs.daily.co/reference/rest-api/webhooks
-    """
-
-    url: NonEmptyString | None = Field(None, description="New webhook endpoint URL")
-    eventTypes: List[NonEmptyString] | None = Field(
-        None, description="New array of event types"
-    )
-    hmac: NonEmptyString | None = Field(None, description="New HMAC secret")
-    basicAuth: NonEmptyString | None = Field(
-        None, description="New basic auth credentials"
-    )
--- a/server/reflector/dailyco_api/responses.py
+++ b/server/reflector/dailyco_api/responses.py
@@ -1,193 +0,0 @@
-"""
-Daily.co API Response Models
-"""
-
-from typing import Any, Dict, List, Literal
-
-from pydantic import BaseModel, Field
-
-from reflector.dailyco_api.webhooks import DailyTrack
-from reflector.utils.string import NonEmptyString
-
-# not documented in daily; we fill it according to observations
-RecordingStatus = Literal["in-progress", "finished"]
-
-
-class RoomResponse(BaseModel):
-    """
-    Response from room creation or retrieval.
-
-    Reference: https://docs.daily.co/reference/rest-api/rooms/create-room
-    """
-
-    id: NonEmptyString = Field(description="Unique room identifier (UUID)")
-    name: NonEmptyString = Field(description="Room name used in URLs")
-    api_created: bool = Field(description="Whether room was created via API")
-    privacy: Literal["public", "private"] = Field(description="Room privacy setting")
-    url: NonEmptyString = Field(description="Full room URL")
-    created_at: NonEmptyString = Field(description="ISO 8601 creation timestamp")
-    config: Dict[NonEmptyString, Any] = Field(
-        default_factory=dict, description="Room configuration properties"
-    )
-
-
-class RoomPresenceParticipant(BaseModel):
-    """
-    Participant presence information in a room.
-
-    Reference: https://docs.daily.co/reference/rest-api/rooms/get-room-presence
-    """
-
-    room: NonEmptyString = Field(description="Room name")
-    id: NonEmptyString = Field(description="Participant session ID")
-    userId: NonEmptyString | None = Field(None, description="User ID if provided")
-    userName: NonEmptyString | None = Field(None, description="User display name")
-    joinTime: NonEmptyString = Field(description="ISO 8601 join timestamp")
-    duration: int = Field(description="Duration in room (seconds)")
-
-
-class RoomPresenceResponse(BaseModel):
-    """
-    Response from room presence endpoint.
-
-    Reference: https://docs.daily.co/reference/rest-api/rooms/get-room-presence
-    """
-
-    total_count: int = Field(
-        description="Total number of participants currently in room"
-    )
-    data: List[RoomPresenceParticipant] = Field(
-        default_factory=list, description="Array of participant presence data"
-    )
-
-
-class MeetingParticipant(BaseModel):
-    """
-    Historical participant data from a meeting.
-
-    Reference: https://docs.daily.co/reference/rest-api/meetings/get-meeting-participants
-    """
-
-    user_id: NonEmptyString | None = Field(None, description="User identifier")
-    participant_id: NonEmptyString = Field(description="Participant session identifier")
-    user_name: NonEmptyString | None = Field(None, description="User display name")
-    join_time: int = Field(description="Join timestamp (Unix epoch seconds)")
-    duration: int = Field(description="Duration in meeting (seconds)")
-
-
-class MeetingParticipantsResponse(BaseModel):
-    """
-    Response from meeting participants endpoint.
-
-    Reference: https://docs.daily.co/reference/rest-api/meetings/get-meeting-participants
-    """
-
-    data: List[MeetingParticipant] = Field(
-        default_factory=list, description="Array of participant data"
-    )
-
-
-class MeetingResponse(BaseModel):
-    """
-    Response from meeting information endpoint.
-
-    Reference: https://docs.daily.co/reference/rest-api/meetings/get-meeting-information
-    """
-
-    id: NonEmptyString = Field(description="Meeting session identifier (UUID)")
-    room: NonEmptyString = Field(description="Room name where meeting occurred")
-    start_time: int = Field(
-        description="Meeting start Unix timestamp (~15s granularity)"
-    )
-    duration: int = Field(description="Total meeting duration in seconds")
-    ongoing: bool = Field(description="Whether meeting is currently active")
-    max_participants: int = Field(description="Peak concurrent participant count")
-    participants: List[MeetingParticipant] = Field(
-        default_factory=list, description="Array of participant session data"
-    )
-
-
-class RecordingS3Info(BaseModel):
-    """
-    S3 bucket information for a recording.
-
-    Reference: https://docs.daily.co/reference/rest-api/recordings
-    """
-
-    bucket_name: NonEmptyString
-    bucket_region: NonEmptyString
-    endpoint: NonEmptyString | None = None
-
-
-class RecordingResponse(BaseModel):
-    """
-    Response from recording retrieval endpoint.
-
-    Reference: https://docs.daily.co/reference/rest-api/recordings
-    """
-
-    id: NonEmptyString = Field(description="Recording identifier")
-    room_name: NonEmptyString = Field(description="Room where recording occurred")
-    start_ts: int = Field(description="Recording start timestamp (Unix epoch seconds)")
-    status: RecordingStatus = Field(
-        description="Recording status ('in-progress' or 'finished')"
-    )
-    max_participants: int | None = Field(
-        None, description="Maximum participants during recording (may be missing)"
-    )
-    duration: int = Field(description="Recording duration in seconds")
-    share_token: NonEmptyString | None = Field(
-        None, description="Token for sharing recording"
-    )
-    s3: RecordingS3Info | None = Field(None, description="S3 bucket information")
-    tracks: list[DailyTrack] = Field(
-        default_factory=list,
-        description="Track list for raw-tracks recordings (always array, never null)",
-    )
-    # this is not a mistake but a deliberate Daily.co naming decision
-    mtgSessionId: NonEmptyString | None = Field(
-        None, description="Meeting session identifier (may be missing)"
-    )
-
-
-class MeetingTokenResponse(BaseModel):
-    """
-    Response from meeting token creation.
-
-    Reference: https://docs.daily.co/reference/rest-api/meeting-tokens/create-meeting-token
-    """
-
-    token: NonEmptyString = Field(
-        description="JWT meeting token for participant authentication"
-    )
-
-
-class WebhookResponse(BaseModel):
-    """
-    Response from webhook creation or retrieval.
-
-    Reference: https://docs.daily.co/reference/rest-api/webhooks
-    """
-
-    uuid: NonEmptyString = Field(description="Unique webhook identifier")
-    url: NonEmptyString = Field(description="Webhook endpoint URL")
-    hmac: NonEmptyString | None = Field(
-        None, description="Base64-encoded HMAC secret for signature verification"
-    )
-    basicAuth: NonEmptyString | None = Field(
-        None, description="Basic auth credentials if configured"
-    )
-    eventTypes: List[NonEmptyString] = Field(
-        default_factory=list,
-        description="Array of event types (e.g., ['recording.started', 'participant.joined'])",
-    )
-    state: Literal["ACTIVE", "FAILED"] = Field(
-        description="Webhook state - FAILED after 3+ consecutive failures"
-    )
-    failedCount: int = Field(default=0, description="Number of consecutive failures")
-    lastMomentPushed: NonEmptyString | None = Field(
-        None, description="ISO 8601 timestamp of last successful push"
-    )
-    domainId: NonEmptyString = Field(description="Daily.co domain/account identifier")
-    createdAt: NonEmptyString = Field(description="ISO 8601 creation timestamp")
-    updatedAt: NonEmptyString = Field(description="ISO 8601 last update timestamp")
--- a/server/reflector/dailyco_api/webhook_utils.py
+++ b/server/reflector/dailyco_api/webhook_utils.py
@@ -1,228 +0,0 @@
-"""
-Daily.co Webhook Utilities
-
-Utilities for verifying and parsing Daily.co webhook events.
-
-Reference: https://docs.daily.co/reference/rest-api/webhooks
-"""
-
-import base64
-import hmac
-from hashlib import sha256
-
-import structlog
-
-from .webhooks import (
-    DailyWebhookEvent,
-    ParticipantJoinedPayload,
-    ParticipantLeftPayload,
-    RecordingErrorPayload,
-    RecordingReadyToDownloadPayload,
-    RecordingStartedPayload,
-)
-
-logger = structlog.get_logger(__name__)
-
-
-def verify_webhook_signature(
-    body: bytes,
-    signature: str,
-    timestamp: str,
-    webhook_secret: str,
-) -> bool:
-    """
-    Verify Daily.co webhook signature using HMAC-SHA256.
-
-    Daily.co signature verification:
-    1. Base64-decode the webhook secret
-    2. Create signed content: timestamp + '.' + body
-    3. Compute HMAC-SHA256(secret, signed_content)
-    4. Base64-encode the result
-    5. Compare with provided signature using constant-time comparison
-
-    Reference: https://docs.daily.co/reference/rest-api/webhooks
-
-    Args:
-        body: Raw request body bytes
-        signature: X-Webhook-Signature header value
-        timestamp: X-Webhook-Timestamp header value
-        webhook_secret: Base64-encoded HMAC secret
-
-    Returns:
-        True if signature is valid, False otherwise
-
-    Example:
-        >>> body = b'{"version":"1.0.0","type":"participant.joined",...}'
-        >>> signature = "abc123..."
-        >>> timestamp = "1234567890"
-        >>> secret = "your-base64-secret"
-        >>> is_valid = verify_webhook_signature(body, signature, timestamp, secret)
-    """
-    if not signature or not timestamp or not webhook_secret:
-        logger.warning(
-            "Missing required data for webhook verification",
-            has_signature=bool(signature),
-            has_timestamp=bool(timestamp),
-            has_secret=bool(webhook_secret),
-        )
-        return False
-
-    try:
-        secret_bytes = base64.b64decode(webhook_secret)
-        signed_content = timestamp.encode() + b"." + body
-        expected = hmac.new(secret_bytes, signed_content, sha256).digest()
-        expected_b64 = base64.b64encode(expected).decode()
-
-        # Constant-time comparison to prevent timing attacks
-        return hmac.compare_digest(expected_b64, signature)
-
-    except (base64.binascii.Error, ValueError, TypeError, UnicodeDecodeError) as e:
-        logger.error(
-            "Webhook signature verification failed",
-            error=str(e),
-            error_type=type(e).__name__,
-        )
-        return False
-
-
-def extract_room_name(event: DailyWebhookEvent) -> str | None:
-    """
-    Extract room name from Daily.co webhook event payload.
-
-    Args:
-        event: Parsed webhook event
-
-    Returns:
-        Room name if present and is a string, None otherwise
-
-    Example:
-        >>> event = DailyWebhookEvent(**webhook_payload)
-        >>> room_name = extract_room_name(event)
-    """
-    room = event.payload.get("room_name")
-    # Ensure we return a string, not any falsy value that might be in payload
-    return room if isinstance(room, str) else None
-
-
-def parse_participant_joined(event: DailyWebhookEvent) -> ParticipantJoinedPayload:
-    """
-    Parse participant.joined webhook event payload.
-
-    Args:
-        event: Webhook event with type "participant.joined"
-
-    Returns:
-        Parsed participant joined payload
-
-    Raises:
-        pydantic.ValidationError: If payload doesn't match expected schema
-    """
-    return ParticipantJoinedPayload(**event.payload)
-
-
-def parse_participant_left(event: DailyWebhookEvent) -> ParticipantLeftPayload:
-    """
-    Parse participant.left webhook event payload.
-
-    Args:
-        event: Webhook event with type "participant.left"
-
-    Returns:
-        Parsed participant left payload
-
-    Raises:
-        pydantic.ValidationError: If payload doesn't match expected schema
-    """
-    return ParticipantLeftPayload(**event.payload)
-
-
-def parse_recording_started(event: DailyWebhookEvent) -> RecordingStartedPayload:
-    """
-    Parse recording.started webhook event payload.
-
-    Args:
-        event: Webhook event with type "recording.started"
-
-    Returns:
-        Parsed recording started payload
-
-    Raises:
-        pydantic.ValidationError: If payload doesn't match expected schema
-    """
-    return RecordingStartedPayload(**event.payload)
-
-
-def parse_recording_ready(
-    event: DailyWebhookEvent,
-) -> RecordingReadyToDownloadPayload:
-    """
-    Parse recording.ready-to-download webhook event payload.
-
-    This event is sent when raw-tracks recordings are complete and uploaded to S3.
-    The payload includes a 'tracks' array with individual audio/video files.
-
-    Args:
-        event: Webhook event with type "recording.ready-to-download"
-
-    Returns:
-        Parsed recording ready payload with tracks array
-
-    Raises:
-        pydantic.ValidationError: If payload doesn't match expected schema
-
-    Example:
-        >>> event = DailyWebhookEvent(**webhook_payload)
-        >>> if event.type == "recording.ready-to-download":
-        ...     payload = parse_recording_ready(event)
-        ...     audio_tracks = [t for t in payload.tracks if t.type == "audio"]
-    """
-    return RecordingReadyToDownloadPayload(**event.payload)
-
-
-def parse_recording_error(event: DailyWebhookEvent) -> RecordingErrorPayload:
-    """
-    Parse recording.error webhook event payload.
-
-    Args:
-        event: Webhook event with type "recording.error"
-
-    Returns:
-        Parsed recording error payload
-
-    Raises:
-        pydantic.ValidationError: If payload doesn't match expected schema
-    """
-    return RecordingErrorPayload(**event.payload)
-
-
-WEBHOOK_PARSERS = {
-    "participant.joined": parse_participant_joined,
-    "participant.left": parse_participant_left,
-    "recording.started": parse_recording_started,
-    "recording.ready-to-download": parse_recording_ready,
-    "recording.error": parse_recording_error,
-}
-
-
-def parse_webhook_payload(event: DailyWebhookEvent):
-    """
-    Parse webhook event payload based on event type.
-
-    Args:
-        event: Webhook event
-
-    Returns:
-        Typed payload model based on event type, or raw dict if unknown
-
-    Example:
-        >>> event = DailyWebhookEvent(**webhook_payload)
-        >>> payload = parse_webhook_payload(event)
-        >>> if isinstance(payload, ParticipantJoinedPayload):
-        ...     print(f"User {payload.user_name} joined")
-    """
-    parser = WEBHOOK_PARSERS.get(event.type)
-    if parser:
-        return parser(event)
-    else:
-        logger.warning("Unknown webhook event type", event_type=event.type)
-        return event.payload
--- a/server/reflector/dailyco_api/webhooks.py
+++ b/server/reflector/dailyco_api/webhooks.py
@@ -1,271 +0,0 @@
-"""
-Daily.co Webhook Event Models
-
-Reference: https://docs.daily.co/reference/rest-api/webhooks
-"""
-
-from typing import Annotated, Any, Dict, Literal, Union
-
-from pydantic import BaseModel, Field, field_validator
-
-from reflector.utils.string import NonEmptyString
-
-
-def normalize_timestamp_to_int(v):
-    """
-    Normalize float timestamps to int by truncating decimal part.
-
-    Daily.co sometimes sends timestamps as floats (e.g., 1708972279.96).
-    Pydantic expects int for fields typed as `int`.
-    """
-    if v is None:
-        return v
-    if isinstance(v, float):
-        return int(v)
-    return v
-
-
-WebhookEventType = Literal[
-    "participant.joined",
-    "participant.left",
-    "recording.started",
-    "recording.ready-to-download",
-    "recording.error",
-]
-
-
-class DailyTrack(BaseModel):
-    """
-    Individual audio or video track from a multitrack recording.
-
-    Reference: https://docs.daily.co/reference/rest-api/recordings
-    """
-
-    type: Literal["audio", "video"]
-    s3Key: NonEmptyString = Field(description="S3 object key for the track file")
-    size: int = Field(description="File size in bytes")
-
-
-class DailyWebhookEvent(BaseModel):
-    """
-    Base structure for all Daily.co webhook events.
-    All events share five common fields documented below.
-
-    Reference: https://docs.daily.co/reference/rest-api/webhooks
-    """
-
-    version: NonEmptyString = Field(
-        description="Represents the version of the event. This uses semantic versioning to inform a consumer if the payload has introduced any breaking changes"
-    )
-    type: WebhookEventType = Field(
-        description="Represents the type of the event described in the payload"
-    )
-    id: NonEmptyString = Field(
-        description="An identifier representing this specific event"
-    )
-    payload: Dict[NonEmptyString, Any] = Field(
-        description="An object representing the event, whose fields are described in the corresponding payload class"
-    )
-    event_ts: int = Field(
-        description="Documenting when the webhook itself was sent. This timestamp is different than the time of the event the webhook describes. For example, a recording.started event will contain a start_ts timestamp of when the actual recording started, and a slightly later event_ts timestamp indicating when the webhook event was sent"
-    )
-
-    _normalize_event_ts = field_validator("event_ts", mode="before")(
-        normalize_timestamp_to_int
-    )
-
-
-class ParticipantJoinedPayload(BaseModel):
-    """
-    Payload for participant.joined webhook event.
-
-    Reference: https://docs.daily.co/reference/rest-api/webhooks/events/participant-joined
-    """
-
-    room_name: NonEmptyString | None = Field(None, description="Daily.co room name")
-    session_id: NonEmptyString = Field(description="Daily.co session identifier")
-    user_id: NonEmptyString = Field(description="User identifier (may be encoded)")
-    user_name: NonEmptyString | None = Field(None, description="User display name")
-    joined_at: int = Field(description="Join timestamp in Unix epoch seconds")
-
-    _normalize_joined_at = field_validator("joined_at", mode="before")(
-        normalize_timestamp_to_int
-    )
-
-
-class ParticipantLeftPayload(BaseModel):
-    """
-    Payload for participant.left webhook event.
-
-    Reference: https://docs.daily.co/reference/rest-api/webhooks/events/participant-left
-    """
-
-    room_name: NonEmptyString | None = Field(None, description="Daily.co room name")
-    session_id: NonEmptyString = Field(description="Daily.co session identifier")
-    user_id: NonEmptyString = Field(description="User identifier (may be encoded)")
-    user_name: NonEmptyString | None = Field(None, description="User display name")
-    joined_at: int = Field(description="Join timestamp in Unix epoch seconds")
-    duration: int | None = Field(
-        None, description="Duration of participation in seconds"
-    )
-
-    _normalize_joined_at = field_validator("joined_at", mode="before")(
-        normalize_timestamp_to_int
-    )
-
-
-class RecordingStartedPayload(BaseModel):
-    """
-    Payload for recording.started webhook event.
-
-    Reference: https://docs.daily.co/reference/rest-api/webhooks/events/recording-started
-    """
-
-    room_name: NonEmptyString | None = Field(None, description="Daily.co room name")
-    recording_id: NonEmptyString = Field(description="Recording identifier")
-    start_ts: int | None = Field(None, description="Recording start timestamp")
-
-    _normalize_start_ts = field_validator("start_ts", mode="before")(
-        normalize_timestamp_to_int
-    )
-
-
-class RecordingReadyToDownloadPayload(BaseModel):
-    """
-    Payload for recording.ready-to-download webhook event.
-    This is sent when raw-tracks recordings are complete and uploaded to S3.
-
-    Reference: https://docs.daily.co/reference/rest-api/webhooks/events/recording-ready-to-download
-    """
-
-    type: Literal["cloud", "raw-tracks"] = Field(
-        description="The type of recording that was generated"
-    )
-    recording_id: NonEmptyString = Field(
-        description="An ID identifying the recording that was generated"
-    )
-    room_name: NonEmptyString = Field(
-        description="The name of the room where the recording was made"
-    )
-    start_ts: int = Field(
-        description="The Unix epoch time in seconds representing when the recording started"
-    )
-    status: Literal["finished"] = Field(
-        description="The status of the given recording (always 'finished' in ready-to-download webhook, see RecordingStatus in responses.py for full API statuses)"
-    )
-    max_participants: int = Field(
-        description="The number of participants on the call that were recorded"
-    )
-    duration: int = Field(description="The duration in seconds of the call")
-    s3_key: NonEmptyString = Field(
-        description="The location of the recording in the provided S3 bucket"
-    )
-    share_token: NonEmptyString | None = Field(
-        None, description="undocumented documented secret field"
-    )
-    tracks: list[DailyTrack] | None = Field(
-        None,
-        description="If the recording is a raw-tracks recording, a tracks field will be provided. If role permissions have been removed, the tracks field may be null",
-    )
-
-    _normalize_start_ts = field_validator("start_ts", mode="before")(
-        normalize_timestamp_to_int
-    )
-
-
-class RecordingErrorPayload(BaseModel):
-    """
-    Payload for recording.error webhook event.
-
-    Reference: https://docs.daily.co/reference/rest-api/webhooks/events/recording-error
-    """
-
-    action: Literal["clourd-recording-err", "cloud-recording-error"] = Field(
-        description="A string describing the event that was emitted (both variants are documented)"
-    )
-    error_msg: NonEmptyString = Field(description="The error message returned")
-    instance_id: NonEmptyString = Field(
-        description="The recording instance ID that was passed into the start recording command"
-    )
-    room_name: NonEmptyString = Field(
-        description="The name of the room where the recording was made"
-    )
-    timestamp: int = Field(
-        description="The Unix epoch time in seconds representing when the error was emitted"
-    )
-
-    _normalize_timestamp = field_validator("timestamp", mode="before")(
-        normalize_timestamp_to_int
-    )
-
-
-class ParticipantJoinedEvent(BaseModel):
-    version: NonEmptyString
-    type: Literal["participant.joined"]
-    id: NonEmptyString
-    payload: ParticipantJoinedPayload
-    event_ts: int
-
-    _normalize_event_ts = field_validator("event_ts", mode="before")(
-        normalize_timestamp_to_int
-    )
-
-
-class ParticipantLeftEvent(BaseModel):
-    version: NonEmptyString
-    type: Literal["participant.left"]
-    id: NonEmptyString
-    payload: ParticipantLeftPayload
-    event_ts: int
-
-    _normalize_event_ts = field_validator("event_ts", mode="before")(
-        normalize_timestamp_to_int
-    )
-
-
-class RecordingStartedEvent(BaseModel):
-    version: NonEmptyString
-    type: Literal["recording.started"]
-    id: NonEmptyString
-    payload: RecordingStartedPayload
-    event_ts: int
-
-    _normalize_event_ts = field_validator("event_ts", mode="before")(
-        normalize_timestamp_to_int
-    )
-
-
-class RecordingReadyEvent(BaseModel):
-    version: NonEmptyString
-    type: Literal["recording.ready-to-download"]
-    id: NonEmptyString
-    payload: RecordingReadyToDownloadPayload
-    event_ts: int
-
-    _normalize_event_ts = field_validator("event_ts", mode="before")(
-        normalize_timestamp_to_int
-    )
-
-
-class RecordingErrorEvent(BaseModel):
-    version: NonEmptyString
-    type: Literal["recording.error"]
-    id: NonEmptyString
-    payload: RecordingErrorPayload
-    event_ts: int
-
-    _normalize_event_ts = field_validator("event_ts", mode="before")(
-        normalize_timestamp_to_int
-    )
-
-
-DailyWebhookEventUnion = Annotated[
-    Union[
-        ParticipantJoinedEvent,
-        ParticipantLeftEvent,
-        RecordingStartedEvent,
-        RecordingReadyEvent,
-        RecordingErrorEvent,
-    ],
-    Field(discriminator="type"),
-]
--- a/server/reflector/db/init.py
+++ b/server/reflector/db/init.py
@@ -24,14 +24,10 @@ def get_database() -> databases.Database:


 # import models
-import reflector.db.calendar_events  # noqa
-import reflector.db.daily_participant_sessions  # noqa
 import reflector.db.meetings  # noqa
 import reflector.db.recordings  # noqa
 import reflector.db.rooms  # noqa
 import reflector.db.transcripts  # noqa
-import reflector.db.user_api_keys  # noqa
-import reflector.db.users  # noqa

 kwargs = {}
 if "postgres" not in settings.DATABASE_URL:
--- 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/daily_participant_sessions.py
+++ b/server/reflector/db/daily_participant_sessions.py
@@ -1,229 +0,0 @@
-"""Daily.co participant session tracking.
-
-Stores webhook data for participant.joined and participant.left events to provide
-historical session information (Daily.co API only returns current participants).
-"""
-
-from datetime import datetime
-
-import sqlalchemy as sa
-from pydantic import BaseModel
-from sqlalchemy.dialects.postgresql import insert
-
-from reflector.db import get_database, metadata
-from reflector.utils.string import NonEmptyString
-
-daily_participant_sessions = sa.Table(
-    "daily_participant_session",
-    metadata,
-    sa.Column("id", sa.String, primary_key=True),
-    sa.Column(
-        "meeting_id",
-        sa.String,
-        sa.ForeignKey("meeting.id", ondelete="CASCADE"),
-        nullable=False,
-    ),
-    sa.Column(
-        "room_id",
-        sa.String,
-        sa.ForeignKey("room.id", ondelete="CASCADE"),
-        nullable=False,
-    ),
-    sa.Column("session_id", sa.String, nullable=False),
-    sa.Column("user_id", sa.String, nullable=True),
-    sa.Column("user_name", sa.String, nullable=False),
-    sa.Column("joined_at", sa.DateTime(timezone=True), nullable=False),
-    sa.Column("left_at", sa.DateTime(timezone=True), nullable=True),
-    sa.Index("idx_daily_session_meeting_left", "meeting_id", "left_at"),
-    sa.Index("idx_daily_session_room", "room_id"),
-)
-
-
-class DailyParticipantSession(BaseModel):
-    """Daily.co participant session record.
-
-    Tracks when a participant joined and left a meeting. Populated from webhooks:
-    - participant.joined: Creates record with left_at=None
-    - participant.left: Updates record with left_at
-
-    ID format: {meeting_id}:{user_id}:{joined_at_ms}
-    - Ensures idempotency (duplicate webhooks don't create duplicates)
-    - Allows same user to rejoin (different joined_at = different session)
-
-    Duration is calculated as: left_at - joined_at (not stored)
-    """
-
-    id: NonEmptyString
-    meeting_id: NonEmptyString
-    room_id: NonEmptyString
-    session_id: NonEmptyString  # Daily.co's session_id (identifies room session)
-    user_id: NonEmptyString | None = None
-    user_name: str
-    joined_at: datetime
-    left_at: datetime | None = None
-
-
-class DailyParticipantSessionController:
-    """Controller for Daily.co participant session persistence."""
-
-    async def get_by_id(self, id: str) -> DailyParticipantSession | None:
-        """Get a session by its ID."""
-        query = daily_participant_sessions.select().where(
-            daily_participant_sessions.c.id == id
-        )
-        result = await get_database().fetch_one(query)
-        return DailyParticipantSession(**result) if result else None
-
-    async def get_open_session(
-        self, meeting_id: NonEmptyString, session_id: NonEmptyString
-    ) -> DailyParticipantSession | None:
-        """Get the open (not left) session for a user in a meeting."""
-        query = daily_participant_sessions.select().where(
-            sa.and_(
-                daily_participant_sessions.c.meeting_id == meeting_id,
-                daily_participant_sessions.c.session_id == session_id,
-                daily_participant_sessions.c.left_at.is_(None),
-            )
-        )
-        results = await get_database().fetch_all(query)
-
-        if len(results) > 1:
-            raise ValueError(
-                f"Multiple open sessions for daily session {session_id} in meeting {meeting_id}: "
-                f"found {len(results)} sessions"
-            )
-
-        return DailyParticipantSession(**results[0]) if results else None
-
-    async def upsert_joined(self, session: DailyParticipantSession) -> None:
-        """Insert or update when participant.joined webhook arrives.
-
-        Idempotent: Duplicate webhooks with same ID are safely ignored.
-        Out-of-order: If left webhook arrived first, preserves left_at.
-        """
-        query = insert(daily_participant_sessions).values(**session.model_dump())
-        query = query.on_conflict_do_update(
-            index_elements=["id"],
-            set_={"user_name": session.user_name},
-        )
-        await get_database().execute(query)
-
-    async def upsert_left(self, session: DailyParticipantSession) -> None:
-        """Update session when participant.left webhook arrives.
-
-        Finds the open session for this user in this meeting and updates left_at.
-        Works around Daily.co webhook timestamp inconsistency (joined_at differs by ~4ms between webhooks).
-
-        Handles three cases:
-        1. Normal flow: open session exists → updates left_at
-        2. Out-of-order: left arrives first → creates new record with left data
-        3. Duplicate: left arrives again → idempotent (DB trigger prevents left_at modification)
-        """
-        if session.left_at is None:
-            raise ValueError("left_at is required for upsert_left")
-
-        if session.left_at <= session.joined_at:
-            raise ValueError(
-                f"left_at ({session.left_at}) must be after joined_at ({session.joined_at})"
-            )
-
-        # Find existing open session (works around timestamp mismatch in webhooks)
-        existing = await self.get_open_session(session.meeting_id, session.session_id)
-
-        if existing:
-            # Update existing open session
-            query = (
-                daily_participant_sessions.update()
-                .where(daily_participant_sessions.c.id == existing.id)
-                .values(left_at=session.left_at)
-            )
-            await get_database().execute(query)
-        else:
-            # Out-of-order or first webhook: insert new record
-            query = insert(daily_participant_sessions).values(**session.model_dump())
-            query = query.on_conflict_do_nothing(index_elements=["id"])
-            await get_database().execute(query)
-
-    async def get_by_meeting(self, meeting_id: str) -> list[DailyParticipantSession]:
-        """Get all participant sessions for a meeting (active and ended)."""
-        query = daily_participant_sessions.select().where(
-            daily_participant_sessions.c.meeting_id == meeting_id
-        )
-        results = await get_database().fetch_all(query)
-        return [DailyParticipantSession(**result) for result in results]
-
-    async def get_active_by_meeting(
-        self, meeting_id: str
-    ) -> list[DailyParticipantSession]:
-        """Get only active (not left) participant sessions for a meeting."""
-        query = daily_participant_sessions.select().where(
-            sa.and_(
-                daily_participant_sessions.c.meeting_id == meeting_id,
-                daily_participant_sessions.c.left_at.is_(None),
-            )
-        )
-        results = await get_database().fetch_all(query)
-        return [DailyParticipantSession(**result) for result in results]
-
-    async def get_all_sessions_for_meeting(
-        self, meeting_id: NonEmptyString
-    ) -> dict[NonEmptyString, DailyParticipantSession]:
-        query = daily_participant_sessions.select().where(
-            daily_participant_sessions.c.meeting_id == meeting_id
-        )
-        results = await get_database().fetch_all(query)
-        # TODO DailySessionId custom type
-        return {row["session_id"]: DailyParticipantSession(**row) for row in results}
-
-    async def batch_upsert_sessions(
-        self, sessions: list[DailyParticipantSession]
-    ) -> None:
-        """Upsert multiple sessions in single query.
-
-        Uses ON CONFLICT for idempotency. Updates user_name on conflict since they may change it during a meeting.
-
-        """
-        if not sessions:
-            return
-
-        values = [session.model_dump() for session in sessions]
-        query = insert(daily_participant_sessions).values(values)
-        query = query.on_conflict_do_update(
-            index_elements=["id"],
-            set_={
-                # Preserve existing left_at to prevent race conditions
-                "left_at": sa.func.coalesce(
-                    daily_participant_sessions.c.left_at,
-                    query.excluded.left_at,
-                ),
-                "user_name": query.excluded.user_name,
-            },
-        )
-        await get_database().execute(query)
-
-    async def batch_close_sessions(
-        self, session_ids: list[NonEmptyString], left_at: datetime
-    ) -> None:
-        """Mark multiple sessions as left in single query.
-
-        Only updates sessions where left_at is NULL (protects already-closed sessions).
-
-        Left_at mismatch for existing sessions is ignored, assumed to be not important issue if ever happens.
-        """
-        if not session_ids:
-            return
-
-        query = (
-            daily_participant_sessions.update()
-            .where(
-                sa.and_(
-                    daily_participant_sessions.c.id.in_(session_ids),
-                    daily_participant_sessions.c.left_at.is_(None),
-                )
-            )
-            .values(left_at=left_at)
-        )
-        await get_database().execute(query)
-
-
-daily_participant_sessions_controller = DailyParticipantSessionController()
--- a/server/reflector/db/meetings.py
+++ b/server/reflector/db/meetings.py
@@ -1,15 +1,12 @@
-from datetime import datetime
-from typing import Any, Literal
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Literal

 import sqlalchemy as sa
 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.schemas.platform import WHEREBY_PLATFORM, Platform
+from reflector.db.rooms import Room, VideoPlatform
 from reflector.utils import generate_uuid4
-from reflector.utils.string import assert_equal

 meetings = sa.Table(
    "meeting",
@@ -47,24 +44,15 @@ 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=assert_equal(WHEREBY_PLATFORM, "whereby"),
-    ),
+    sa.Column("platform", sa.String, nullable=False, server_default="whereby"),
+    sa.Column("events", sa.JSON, nullable=False, server_default=sa.text("'[]'")),
    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(
@@ -102,14 +90,12 @@ class Meeting(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"
    num_clients: int = 0
-    is_active: bool = True
-    calendar_event_id: str | None = None
-    calendar_metadata: dict[str, Any] | None = None
-    platform: Platform = WHEREBY_PLATFORM
+    platform: VideoPlatform = VideoPlatform.WHEREBY
+    events: List[Dict[str, Any]] = Field(default_factory=list)


 class MeetingController:
@@ -122,8 +108,6 @@ class MeetingController:
        start_date: datetime,
        end_date: datetime,
        room: Room,
-        calendar_event_id: str | None = None,
-        calendar_metadata: dict[str, Any] | None = None,
    ):
        meeting = Meeting(
            id=id,
@@ -137,45 +121,28 @@ class MeetingController:
            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=room.platform,
        )
        query = meetings.insert().values(**meeting.model_dump())
        await get_database().execute(query)
        return meeting

-    async def get_all_active(self, platform: str | None = None) -> list[Meeting]:
-        conditions = [meetings.c.is_active]
-        if platform is not None:
-            conditions.append(meetings.c.platform == platform)
-        query = meetings.select().where(sa.and_(*conditions))
-        results = await get_database().fetch_all(query)
-        return [Meeting(**result) for result in results]
+    async def get_all_active(self) -> list[Meeting]:
+        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:
-        """
-        Get a meeting by room name.
-        For backward compatibility, returns the most recent meeting.
-        """
-        query = (
-            meetings.select()
-            .where(meetings.c.room_name == room_name)
-            .order_by(meetings.c.end_date.desc())
-        )
+        query = meetings.select().where(meetings.c.room_name == room_name)
        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:
-        """
-        Get latest active meeting for a room.
-        For backward compatibility, returns the most recent active meeting.
-        """
        end_date = getattr(meetings.c, "end_date")
        query = (
            meetings.select()
@@ -191,66 +158,11 @@ class MeetingController:
        result = await get_database().fetch_one(query)
        if not result:
            return None
+
        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, room: Room | None = None
-    ) -> Meeting | None:
+    async def get_by_id(self, meeting_id: str, **kwargs) -> Meeting | None:
        query = meetings.select().where(meetings.c.id == meeting_id)
-
-        if room:
-            query = query.where(meetings.c.room_id == room.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, room: Room
-    ) -> Meeting | None:
-        query = meetings.select().where(
-            meetings.c.calendar_event_id == calendar_event_id
-        )
-        if room:
-            query = query.where(meetings.c.room_id == room.id)
        result = await get_database().fetch_one(query)
        if not result:
            return None
@@ -260,27 +172,67 @@ class MeetingController:
        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) -> None:
-        """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 add_event(
+        self, meeting_id: str, event_type: str, event_data: Dict[str, Any] = None
+    ):
+        """Add an event to a meeting's events list."""
+        if event_data is None:
+            event_data = {}

-    async def decrement_num_clients(self, meeting_id: str) -> None:
-        """Atomically decrement participant count (min 0)."""
-        query = (
+        event = {
+            "type": event_type,
+            "timestamp": datetime.now(tz=timezone.utc).isoformat(),
+            "data": event_data,
+        }
+
+        # Get current events
+        query = meetings.select().where(meetings.c.id == meeting_id)
+        result = await get_database().fetch_one(query)
+        if not result:
+            return
+
+        current_events = result["events"] or []
+        current_events.append(event)
+
+        # Update with new events list
+        update_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
-                )
-            )
+            .values(events=current_events)
        )
-        await get_database().execute(query)
+        await get_database().execute(update_query)
+
+    async def participant_joined(
+        self, meeting_id: str, participant_data: Dict[str, Any] = None
+    ):
+        """Record a participant joined event."""
+        await self.add_event(meeting_id, "participant_joined", participant_data)
+
+    async def participant_left(
+        self, meeting_id: str, participant_data: Dict[str, Any] = None
+    ):
+        """Record a participant left event."""
+        await self.add_event(meeting_id, "participant_left", participant_data)
+
+    async def recording_started(
+        self, meeting_id: str, recording_data: Dict[str, Any] = None
+    ):
+        """Record a recording started event."""
+        await self.add_event(meeting_id, "recording_started", recording_data)
+
+    async def recording_stopped(
+        self, meeting_id: str, recording_data: Dict[str, Any] = None
+    ):
+        """Record a recording stopped event."""
+        await self.add_event(meeting_id, "recording_stopped", recording_data)
+
+    async def get_events(self, meeting_id: str) -> List[Dict[str, Any]]:
+        """Get all events for a meeting."""
+        query = meetings.select().where(meetings.c.id == meeting_id)
+        result = await get_database().fetch_one(query)
+        if not result:
+            return []
+        return result["events"] or []


 class MeetingConsentController:
@@ -305,6 +257,7 @@ class MeetingConsentController:
        return MeetingConsent(**result)

    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/recordings.py
+++ b/server/reflector/db/recordings.py
@@ -21,7 +21,6 @@ recordings = sa.Table(
        server_default="pending",
    ),
    sa.Column("meeting_id", sa.String),
-    sa.Column("track_keys", sa.JSON, nullable=True),
    sa.Index("idx_recording_meeting_id", "meeting_id"),
 )

@@ -29,20 +28,10 @@ recordings = sa.Table(
 class Recording(BaseModel):
    id: str = Field(default_factory=generate_uuid4)
    bucket_name: str
-    # for single-track
    object_key: str
    recorded_at: datetime
    status: Literal["pending", "processing", "completed", "failed"] = "pending"
    meeting_id: str | None = None
-    # for multitrack reprocessing
-    # track_keys can be empty list [] if recording finished but no audio was captured (silence/muted)
-    # None means not a multitrack recording, [] means multitrack with no tracks
-    track_keys: list[str] | None = None
-
-    @property
-    def is_multitrack(self) -> bool:
-        """True if recording has separate audio tracks (1+ tracks counts as multitrack)."""
-        return self.track_keys is not None and len(self.track_keys) > 0


 class RecordingController:
@@ -51,14 +40,12 @@ class RecordingController:
        await get_database().execute(query)
        return recording

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

-    async def get_by_object_key(
-        self, bucket_name: str, object_key: str
-    ) -> Recording | None:
+    async def get_by_object_key(self, bucket_name: str, object_key: str) -> Recording:
        query = recordings.select().where(
            recordings.c.bucket_name == bucket_name,
            recordings.c.object_key == object_key,
@@ -70,14 +57,5 @@ class RecordingController:
        query = recordings.delete().where(recordings.c.id == id)
        await get_database().execute(query)

-    # no check for existence
-    async def get_by_ids(self, recording_ids: list[str]) -> list[Recording]:
-        if not recording_ids:
-            return []
-
-        query = recordings.select().where(recordings.c.id.in_(recording_ids))
-        results = await get_database().fetch_all(query)
-        return [Recording(**row) for row in results]
-

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

@@ -9,10 +10,14 @@ from pydantic import BaseModel, Field
 from sqlalchemy.sql import false, or_

 from reflector.db import get_database, metadata
-from reflector.schemas.platform import Platform
-from reflector.settings import settings
 from reflector.utils import generate_uuid4

+
+class VideoPlatform(StrEnum):
+    WHEREBY = "whereby"
+    JITSI = "jitsi"
+
+
 rooms = sqlalchemy.Table(
    "room",
    metadata,
@@ -45,20 +50,10 @@ rooms = sqlalchemy.Table(
    ),
    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,
+        "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 +68,13 @@ 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 = Field(default_factory=lambda: settings.DEFAULT_VIDEO_PLATFORM)
+    platform: VideoPlatform = VideoPlatform.WHEREBY


 class RoomController:
@@ -135,10 +125,7 @@ class RoomController:
        is_shared: bool,
        webhook_url: str = "",
        webhook_secret: str = "",
-        ics_url: str | None = None,
-        ics_fetch_interval: int = 300,
-        ics_enabled: bool = False,
-        platform: Platform = settings.DEFAULT_VIDEO_PLATFORM,
+        platform: str = "whereby",
    ):
        """
        Add a new room
@@ -146,26 +133,21 @@ class RoomController:
        if webhook_url and not webhook_secret:
            webhook_secret = secrets.token_urlsafe(32)

-        room_data = {
-            "name": name,
-            "user_id": user_id,
-            "zulip_auto_post": zulip_auto_post,
-            "zulip_stream": zulip_stream,
-            "zulip_topic": zulip_topic,
-            "is_locked": is_locked,
-            "room_mode": room_mode,
-            "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,
-        }
-
-        room = Room(**room_data)
+        room = Room(
+            name=name,
+            user_id=user_id,
+            zulip_auto_post=zulip_auto_post,
+            zulip_stream=zulip_stream,
+            zulip_topic=zulip_topic,
+            is_locked=is_locked,
+            room_mode=room_mode,
+            recording_type=recording_type,
+            recording_trigger=recording_trigger,
+            is_shared=is_shared,
+            webhook_url=webhook_url,
+            webhook_secret=webhook_secret,
+            platform=platform,
+        )
        query = rooms.insert().values(**room.model_dump())
        try:
            await get_database().execute(query)
@@ -229,13 +211,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
@@ -135,8 +135,6 @@ class SearchParameters(BaseModel):
    user_id: str | None = None
    room_id: str | None = None
    source_kind: SourceKind | None = None
-    from_datetime: datetime | None = None
-    to_datetime: datetime | None = None


 class SearchResultDB(BaseModel):
@@ -404,14 +402,6 @@ class SearchController:
            base_query = base_query.where(
                transcripts.c.source_kind == params.source_kind
            )
-        if params.from_datetime:
-            base_query = base_query.where(
-                transcripts.c.created_at >= params.from_datetime
-            )
-        if params.to_datetime:
-            base_query = base_query.where(
-                transcripts.c.created_at <= params.to_datetime
-            )

        if params.query_text is not None:
            order_by = sqlalchemy.desc(sqlalchemy.text("rank"))
--- a/server/reflector/db/transcripts.py
+++ b/server/reflector/db/transcripts.py
@@ -21,7 +21,7 @@ from reflector.db.utils import is_postgresql
 from reflector.logger import logger
 from reflector.processors.types import Word as ProcessorWord
 from reflector.settings import settings
-from reflector.storage import get_transcripts_storage
+from reflector.storage import get_recordings_storage, get_transcripts_storage
 from reflector.utils import generate_uuid4
 from reflector.utils.webvtt import topics_to_webvtt

@@ -186,7 +186,6 @@ class TranscriptParticipant(BaseModel):
    id: str = Field(default_factory=generate_uuid4)
    speaker: int | None
    name: str
-    user_id: str | None = None


 class Transcript(BaseModel):
@@ -624,9 +623,7 @@ class TranscriptController:
                )
                if recording:
                    try:
-                        await get_transcripts_storage().delete_file(
-                            recording.object_key, bucket=recording.bucket_name
-                        )
+                        await get_recordings_storage().delete_file(recording.object_key)
                    except Exception as e:
                        logger.warning(
                            "Failed to delete recording object from S3",
@@ -650,19 +647,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):
        """
@@ -728,13 +712,11 @@ class TranscriptController:
        """
        Download audio from storage
        """
-        storage = get_transcripts_storage()
-        try:
-            with open(transcript.audio_mp3_filename, "wb") as f:
-                await storage.stream_to_fileobj(transcript.storage_audio_path, f)
-        except Exception:
-            transcript.audio_mp3_filename.unlink(missing_ok=True)
-            raise
+        transcript.audio_mp3_filename.write_bytes(
+            await get_transcripts_storage().get_file(
+                transcript.storage_audio_path,
+            )
+        )

    async def upsert_participant(
        self,
--- a/server/reflector/db/user_api_keys.py
+++ b/server/reflector/db/user_api_keys.py
@@ -1,91 +0,0 @@
-import hmac
-import secrets
-from datetime import datetime, timezone
-from hashlib import sha256
-
-import sqlalchemy
-from pydantic import BaseModel, Field
-
-from reflector.db import get_database, metadata
-from reflector.settings import settings
-from reflector.utils import generate_uuid4
-from reflector.utils.string import NonEmptyString
-
-user_api_keys = sqlalchemy.Table(
-    "user_api_key",
-    metadata,
-    sqlalchemy.Column("id", sqlalchemy.String, primary_key=True),
-    sqlalchemy.Column("user_id", sqlalchemy.String, nullable=False),
-    sqlalchemy.Column("key_hash", sqlalchemy.String, nullable=False),
-    sqlalchemy.Column("name", sqlalchemy.String, nullable=True),
-    sqlalchemy.Column("created_at", sqlalchemy.DateTime(timezone=True), nullable=False),
-    sqlalchemy.Index("idx_user_api_key_hash", "key_hash", unique=True),
-    sqlalchemy.Index("idx_user_api_key_user_id", "user_id"),
-)
-
-
-class UserApiKey(BaseModel):
-    id: NonEmptyString = Field(default_factory=generate_uuid4)
-    user_id: NonEmptyString
-    key_hash: NonEmptyString
-    name: NonEmptyString | None = None
-    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
-
-
-class UserApiKeyController:
-    @staticmethod
-    def generate_key() -> NonEmptyString:
-        return secrets.token_urlsafe(48)
-
-    @staticmethod
-    def hash_key(key: NonEmptyString) -> str:
-        return hmac.new(
-            settings.SECRET_KEY.encode(), key.encode(), digestmod=sha256
-        ).hexdigest()
-
-    @classmethod
-    async def create_key(
-        cls,
-        user_id: NonEmptyString,
-        name: NonEmptyString | None = None,
-    ) -> tuple[UserApiKey, NonEmptyString]:
-        plaintext = cls.generate_key()
-        api_key = UserApiKey(
-            user_id=user_id,
-            key_hash=cls.hash_key(plaintext),
-            name=name,
-        )
-        query = user_api_keys.insert().values(**api_key.model_dump())
-        await get_database().execute(query)
-        return api_key, plaintext
-
-    @classmethod
-    async def verify_key(cls, plaintext_key: NonEmptyString) -> UserApiKey | None:
-        key_hash = cls.hash_key(plaintext_key)
-        query = user_api_keys.select().where(
-            user_api_keys.c.key_hash == key_hash,
-        )
-        result = await get_database().fetch_one(query)
-        return UserApiKey(**result) if result else None
-
-    @staticmethod
-    async def list_by_user_id(user_id: NonEmptyString) -> list[UserApiKey]:
-        query = (
-            user_api_keys.select()
-            .where(user_api_keys.c.user_id == user_id)
-            .order_by(user_api_keys.c.created_at.desc())
-        )
-        results = await get_database().fetch_all(query)
-        return [UserApiKey(**r) for r in results]
-
-    @staticmethod
-    async def delete_key(key_id: NonEmptyString, user_id: NonEmptyString) -> bool:
-        query = user_api_keys.delete().where(
-            (user_api_keys.c.id == key_id) & (user_api_keys.c.user_id == user_id)
-        )
-        result = await get_database().execute(query)
-        # asyncpg returns None for DELETE, consider it success if no exception
-        return result is None or result > 0
-
-
-user_api_keys_controller = UserApiKeyController()
--- a/server/reflector/db/users.py
+++ b/server/reflector/db/users.py
@@ -1,98 +0,0 @@
-"""User table for storing Authentik user information."""
-
-from datetime import datetime, timezone
-
-import sqlalchemy
-from pydantic import BaseModel, Field
-
-from reflector.db import get_database, metadata
-from reflector.utils import generate_uuid4
-from reflector.utils.string import NonEmptyString
-
-users = sqlalchemy.Table(
-    "user",
-    metadata,
-    sqlalchemy.Column("id", sqlalchemy.String, primary_key=True),
-    sqlalchemy.Column("email", sqlalchemy.String, nullable=False),
-    sqlalchemy.Column("authentik_uid", sqlalchemy.String, nullable=False),
-    sqlalchemy.Column("created_at", sqlalchemy.DateTime(timezone=True), nullable=False),
-    sqlalchemy.Column("updated_at", sqlalchemy.DateTime(timezone=True), nullable=False),
-    sqlalchemy.Index("idx_user_authentik_uid", "authentik_uid", unique=True),
-    sqlalchemy.Index("idx_user_email", "email", unique=False),
-)
-
-
-class User(BaseModel):
-    id: NonEmptyString = Field(default_factory=generate_uuid4)
-    email: NonEmptyString
-    authentik_uid: NonEmptyString
-    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
-    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
-
-
-class UserController:
-    @staticmethod
-    async def get_by_id(user_id: NonEmptyString) -> User | None:
-        query = users.select().where(users.c.id == user_id)
-        result = await get_database().fetch_one(query)
-        return User(**result) if result else None
-
-    @staticmethod
-    async def get_by_authentik_uid(authentik_uid: NonEmptyString) -> User | None:
-        query = users.select().where(users.c.authentik_uid == authentik_uid)
-        result = await get_database().fetch_one(query)
-        return User(**result) if result else None
-
-    @staticmethod
-    async def get_by_email(email: NonEmptyString) -> User | None:
-        query = users.select().where(users.c.email == email)
-        result = await get_database().fetch_one(query)
-        return User(**result) if result else None
-
-    @staticmethod
-    async def create_or_update(
-        id: NonEmptyString, authentik_uid: NonEmptyString, email: NonEmptyString
-    ) -> User:
-        existing = await UserController.get_by_authentik_uid(authentik_uid)
-        now = datetime.now(timezone.utc)
-
-        if existing:
-            query = (
-                users.update()
-                .where(users.c.authentik_uid == authentik_uid)
-                .values(email=email, updated_at=now)
-            )
-            await get_database().execute(query)
-            return User(
-                id=existing.id,
-                authentik_uid=authentik_uid,
-                email=email,
-                created_at=existing.created_at,
-                updated_at=now,
-            )
-        else:
-            user = User(
-                id=id,
-                authentik_uid=authentik_uid,
-                email=email,
-                created_at=now,
-                updated_at=now,
-            )
-            query = users.insert().values(**user.model_dump())
-            await get_database().execute(query)
-            return user
-
-    @staticmethod
-    async def list_all() -> list[User]:
-        query = users.select().order_by(users.c.created_at.desc())
-        results = await get_database().fetch_all(query)
-        return [User(**r) for r in results]
-
-    @staticmethod
-    async def get_by_ids(user_ids: list[NonEmptyString]) -> dict[str, User]:
-        query = users.select().where(users.c.id.in_(user_ids))
-        results = await get_database().fetch_all(query)
-        return {user.id: User(**user) for user in results}
-
-
-user_controller = UserController()
--- a/server/reflector/jibri_events.py
+++ b/server/reflector/jibri_events.py
@@ -0,0 +1,227 @@
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from pydantic import BaseModel
+from typing_extensions import TypedDict
+
+
+class ParticipantInfo(BaseModel):
+    jid: str
+    nick: str
+    id: str
+    is_moderator: bool = False
+
+
+class ParticipantLeftInfo(BaseModel):
+    jid: str
+    nick: Optional[str] = None
+    duration_seconds: Optional[int] = None
+
+
+class RoomCreatedEvent(BaseModel):
+    type: Literal["room_created"]
+    timestamp: int
+    room_name: str
+    room_jid: str
+    meeting_url: str
+
+
+class RecordingStartedEvent(BaseModel):
+    type: Literal["recording_started"]
+    timestamp: int
+    room_name: str
+    session_id: str
+    jibri_jid: str
+
+
+class RecordingStoppedEvent(BaseModel):
+    type: Literal["recording_stopped"]
+    timestamp: int
+    room_name: str
+    session_id: str
+    meeting_url: str
+
+
+class ParticipantJoinedEvent(BaseModel):
+    type: Literal["participant_joined"]
+    timestamp: int
+    room_name: str
+    participant: ParticipantInfo
+
+
+class ParticipantLeftEvent(BaseModel):
+    type: Literal["participant_left"]
+    timestamp: int
+    room_name: str
+    participant: ParticipantLeftInfo
+
+
+class SpeakerActiveEvent(BaseModel):
+    type: Literal["speaker_active"]
+    timestamp: int
+    room_name: str
+    speaker_jid: str
+    speaker_nick: str
+    duration: int
+
+
+class DominantSpeakerChangedEvent(BaseModel):
+    type: Literal["dominant_speaker_changed"]
+    timestamp: int
+    room_name: str
+    previous: str
+    current: str
+
+
+JitsiEvent = Union[
+    RoomCreatedEvent,
+    RecordingStartedEvent,
+    RecordingStoppedEvent,
+    ParticipantJoinedEvent,
+    ParticipantLeftEvent,
+    SpeakerActiveEvent,
+    DominantSpeakerChangedEvent,
+]
+
+
+class RoomInfo(TypedDict):
+    name: str
+    jid: str
+    created_at: int
+    meeting_url: str
+    recording_stopped_at: Optional[int]
+
+
+class ParticipantData(TypedDict):
+    jid: str
+    nick: str
+    id: str
+    is_moderator: bool
+    joined_at: int
+    left_at: Optional[int]
+    duration: Optional[int]
+    events: List[str]
+
+
+class SpeakerStats(TypedDict):
+    total_time: int
+    nick: str
+
+
+class ParsedMetadata(TypedDict):
+    room: RoomInfo
+    participants: List[ParticipantData]
+    speaker_stats: Dict[str, SpeakerStats]
+    event_count: int
+
+
+class JitsiEventParser:
+    def parse_event(self, event_data: Dict[str, Any]) -> Optional[JitsiEvent]:
+        event_type = event_data.get("type")
+
+        try:
+            if event_type == "room_created":
+                return RoomCreatedEvent(**event_data)
+            elif event_type == "recording_started":
+                return RecordingStartedEvent(**event_data)
+            elif event_type == "recording_stopped":
+                return RecordingStoppedEvent(**event_data)
+            elif event_type == "participant_joined":
+                return ParticipantJoinedEvent(**event_data)
+            elif event_type == "participant_left":
+                return ParticipantLeftEvent(**event_data)
+            elif event_type == "speaker_active":
+                return SpeakerActiveEvent(**event_data)
+            elif event_type == "dominant_speaker_changed":
+                return DominantSpeakerChangedEvent(**event_data)
+            else:
+                return None
+        except Exception:
+            return None
+
+    def parse_events_file(self, recording_path: str) -> ParsedMetadata:
+        events_file = Path(recording_path) / "events.jsonl"
+
+        room_info: RoomInfo = {
+            "name": "",
+            "jid": "",
+            "created_at": 0,
+            "meeting_url": "",
+            "recording_stopped_at": None,
+        }
+
+        if not events_file.exists():
+            return ParsedMetadata(
+                room=room_info, participants=[], speaker_stats={}, event_count=0
+            )
+
+        events: List[JitsiEvent] = []
+        participants: Dict[str, ParticipantData] = {}
+        speaker_stats: Dict[str, SpeakerStats] = {}
+
+        with open(events_file, "r") as f:
+            for line in f:
+                if not line.strip():
+                    continue
+
+                try:
+                    event_data = json.loads(line)
+                    event = self.parse_event(event_data)
+
+                    if event is None:
+                        continue
+
+                    events.append(event)
+
+                    if isinstance(event, RoomCreatedEvent):
+                        room_info = {
+                            "name": event.room_name,
+                            "jid": event.room_jid,
+                            "created_at": event.timestamp,
+                            "meeting_url": event.meeting_url,
+                            "recording_stopped_at": None,
+                        }
+
+                    elif isinstance(event, ParticipantJoinedEvent):
+                        participants[event.participant.id] = {
+                            "jid": event.participant.jid,
+                            "nick": event.participant.nick,
+                            "id": event.participant.id,
+                            "is_moderator": event.participant.is_moderator,
+                            "joined_at": event.timestamp,
+                            "left_at": None,
+                            "duration": None,
+                            "events": ["joined"],
+                        }
+
+                    elif isinstance(event, ParticipantLeftEvent):
+                        participant_id = event.participant.jid.split("/")[0]
+                        if participant_id in participants:
+                            participants[participant_id]["left_at"] = event.timestamp
+                            participants[participant_id]["duration"] = (
+                                event.participant.duration_seconds
+                            )
+                            participants[participant_id]["events"].append("left")
+
+                    elif isinstance(event, SpeakerActiveEvent):
+                        if event.speaker_jid not in speaker_stats:
+                            speaker_stats[event.speaker_jid] = {
+                                "total_time": 0,
+                                "nick": event.speaker_nick,
+                            }
+                        speaker_stats[event.speaker_jid]["total_time"] += event.duration
+
+                    elif isinstance(event, RecordingStoppedEvent):
+                        room_info["recording_stopped_at"] = event.timestamp
+                        room_info["meeting_url"] = event.meeting_url
+
+                except (json.JSONDecodeError, Exception):
+                    continue
+
+        return ParsedMetadata(
+            room=room_info,
+            participants=list(participants.values()),
+            speaker_stats=speaker_stats,
+            event_count=len(events),
+        )
--- a/server/reflector/llm.py
+++ b/server/reflector/llm.py
@@ -1,29 +1,13 @@
-import logging
-from contextvars import ContextVar
-from typing import Generic, Type, TypeVar
-from uuid import uuid4
+from typing import Type, TypeVar

 from llama_index.core import Settings
 from llama_index.core.output_parsers import PydanticOutputParser
+from llama_index.core.program import LLMTextCompletionProgram
 from llama_index.core.response_synthesizers import TreeSummarize
-from llama_index.core.workflow import (
-    Context,
-    Event,
-    StartEvent,
-    StopEvent,
-    Workflow,
-    step,
-)
 from llama_index.llms.openai_like import OpenAILike
-from pydantic import BaseModel, ValidationError
+from pydantic import BaseModel

 T = TypeVar("T", bound=BaseModel)
-OutputT = TypeVar("OutputT", bound=BaseModel)
-
-# Session ID for LiteLLM request grouping - set per processing run
-llm_session_id: ContextVar[str | None] = ContextVar("llm_session_id", default=None)
-
-logger = logging.getLogger(__name__)

 STRUCTURED_RESPONSE_PROMPT_TEMPLATE = """
 Based on the following analysis, provide the information in the requested JSON format:
@@ -35,158 +19,6 @@ Analysis:
 """


-class LLMParseError(Exception):
-    """Raised when LLM output cannot be parsed after retries."""
-
-    def __init__(self, output_cls: Type[BaseModel], error_msg: str, attempts: int):
-        self.output_cls = output_cls
-        self.error_msg = error_msg
-        self.attempts = attempts
-        super().__init__(
-            f"Failed to parse {output_cls.__name__} after {attempts} attempts: {error_msg}"
-        )
-
-
-class ExtractionDone(Event):
-    """Event emitted when LLM JSON formatting completes."""
-
-    output: str
-
-
-class ValidationErrorEvent(Event):
-    """Event emitted when validation fails."""
-
-    error: str
-    wrong_output: str
-
-
-class StructuredOutputWorkflow(Workflow, Generic[OutputT]):
-    """Workflow for structured output extraction with validation retry.
-
-    This workflow handles parse/validation retries only. Network error retries
-    are handled internally by Settings.llm (OpenAILike max_retries=3).
-    The caller should NOT wrap this workflow in additional retry logic.
-    """
-
-    def __init__(
-        self,
-        output_cls: Type[OutputT],
-        max_retries: int = 3,
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-        self.output_cls: Type[OutputT] = output_cls
-        self.max_retries = max_retries
-        self.output_parser = PydanticOutputParser(output_cls)
-
-    @step
-    async def extract(
-        self, ctx: Context, ev: StartEvent | ValidationErrorEvent
-    ) -> StopEvent | ExtractionDone:
-        """Extract structured data from text using two-step LLM process.
-
-        Step 1 (first call only): TreeSummarize generates text analysis
-        Step 2 (every call): Settings.llm.acomplete formats analysis as JSON
-        """
-        current_retries = await ctx.store.get("retries", default=0)
-        await ctx.store.set("retries", current_retries + 1)
-
-        if current_retries >= self.max_retries:
-            last_error = await ctx.store.get("last_error", default=None)
-            logger.error(
-                f"Max retries ({self.max_retries}) reached for {self.output_cls.__name__}"
-            )
-            return StopEvent(result={"error": last_error, "attempts": current_retries})
-
-        if isinstance(ev, StartEvent):
-            # First call: run TreeSummarize to get analysis, store in context
-            prompt = ev.get("prompt")
-            texts = ev.get("texts")
-            tone_name = ev.get("tone_name")
-            if not prompt or not isinstance(texts, list):
-                raise ValueError(
-                    "StartEvent must contain 'prompt' (str) and 'texts' (list)"
-                )
-
-            summarizer = TreeSummarize(verbose=False)
-            analysis = await summarizer.aget_response(
-                prompt, texts, tone_name=tone_name
-            )
-            await ctx.store.set("analysis", str(analysis))
-            reflection = ""
-        else:
-            # Retry: reuse analysis from context
-            analysis = await ctx.store.get("analysis")
-            if not analysis:
-                raise RuntimeError("Internal error: analysis not found in context")
-
-            wrong_output = ev.wrong_output
-            if len(wrong_output) > 2000:
-                wrong_output = wrong_output[:2000] + "... [truncated]"
-            reflection = (
-                f"\n\nYour previous response could not be parsed:\n{wrong_output}\n\n"
-                f"Error:\n{ev.error}\n\n"
-                "Please try again. Return ONLY valid JSON matching the schema above, "
-                "with no markdown formatting or extra text."
-            )
-
-        # Step 2: Format analysis as JSON using LLM completion
-        format_instructions = self.output_parser.format(
-            "Please structure the above information in the following JSON format:"
-        )
-
-        json_prompt = STRUCTURED_RESPONSE_PROMPT_TEMPLATE.format(
-            analysis=analysis,
-            format_instructions=format_instructions + reflection,
-        )
-
-        # Network retries handled by OpenAILike (max_retries=3)
-        response = await Settings.llm.acomplete(json_prompt)
-        return ExtractionDone(output=response.text)
-
-    @step
-    async def validate(
-        self, ctx: Context, ev: ExtractionDone
-    ) -> StopEvent | ValidationErrorEvent:
-        """Validate extracted output against Pydantic schema."""
-        raw_output = ev.output
-        retries = await ctx.store.get("retries", default=0)
-
-        try:
-            parsed = self.output_parser.parse(raw_output)
-            if retries > 1:
-                logger.info(
-                    f"LLM parse succeeded on attempt {retries}/{self.max_retries} "
-                    f"for {self.output_cls.__name__}"
-                )
-            return StopEvent(result={"success": parsed})
-
-        except (ValidationError, ValueError) as e:
-            error_msg = self._format_error(e, raw_output)
-            await ctx.store.set("last_error", error_msg)
-
-            logger.error(
-                f"LLM parse error (attempt {retries}/{self.max_retries}): "
-                f"{type(e).__name__}: {e}\nRaw response: {raw_output[:500]}"
-            )
-
-            return ValidationErrorEvent(
-                error=error_msg,
-                wrong_output=raw_output,
-            )
-
-    def _format_error(self, error: Exception, raw_output: str) -> str:
-        """Format error for LLM feedback."""
-        if isinstance(error, ValidationError):
-            error_messages = []
-            for err in error.errors():
-                field = ".".join(str(loc) for loc in err["loc"])
-                error_messages.append(f"- {err['msg']} in field '{field}'")
-            return "Schema validation errors:\n" + "\n".join(error_messages)
-        else:
-            return f"Parse error: {str(error)}"
-
-
 class LLM:
    def __init__(self, settings, temperature: float = 0.4, max_tokens: int = 2048):
        self.settings_obj = settings
@@ -197,12 +29,11 @@ class LLM:
        self.temperature = temperature
        self.max_tokens = max_tokens

+        # Configure llamaindex Settings
        self._configure_llamaindex()

    def _configure_llamaindex(self):
        """Configure llamaindex Settings with OpenAILike LLM"""
-        session_id = llm_session_id.get() or f"fallback-{uuid4().hex}"
-
        Settings.llm = OpenAILike(
            model=self.model_name,
            api_base=self.url,
@@ -212,7 +43,6 @@ class LLM:
            is_function_calling_model=False,
            temperature=self.temperature,
            max_tokens=self.max_tokens,
-            additional_kwargs={"extra_body": {"litellm_session_id": session_id}},
        )

    async def get_response(
@@ -230,25 +60,24 @@ class LLM:
        output_cls: Type[T],
        tone_name: str | None = None,
    ) -> T:
-        """Get structured output from LLM with validation retry via Workflow."""
-        workflow = StructuredOutputWorkflow(
-            output_cls=output_cls,
-            max_retries=self.settings_obj.LLM_PARSE_MAX_RETRIES + 1,
-            timeout=120,
+        """Get structured output from LLM for non-function-calling models"""
+        summarizer = TreeSummarize(verbose=True)
+        response = await summarizer.aget_response(prompt, texts, tone_name=tone_name)
+
+        output_parser = PydanticOutputParser(output_cls)
+
+        program = LLMTextCompletionProgram.from_defaults(
+            output_parser=output_parser,
+            prompt_template_str=STRUCTURED_RESPONSE_PROMPT_TEMPLATE,
+            verbose=False,
        )

-        result = await workflow.run(
-            prompt=prompt,
-            texts=texts,
-            tone_name=tone_name,
+        format_instructions = output_parser.format(
+            "Please structure the above information in the following JSON format:"
        )

-        if "error" in result:
-            error_msg = result["error"] or "Max retries exceeded"
-            raise LLMParseError(
-                output_cls=output_cls,
-                error_msg=error_msg,
-                attempts=result.get("attempts", 0),
-            )
+        output = await program.acall(
+            analysis=str(response), format_instructions=format_instructions
+        )

-        return result["success"]
+        return output
--- a/server/reflector/pipelines/init.py
+++ b/server/reflector/pipelines/init.py
@@ -1 +0,0 @@
-"""Pipeline modules for audio processing."""
--- a/server/reflector/pipelines/main_file_pipeline.py
+++ b/server/reflector/pipelines/main_file_pipeline.py
@@ -23,18 +23,23 @@ from reflector.db.transcripts import (
    transcripts_controller,
 )
 from reflector.logger import logger
-from reflector.pipelines import topic_processing
 from reflector.pipelines.main_live_pipeline import (
    PipelineMainBase,
    broadcast_to_sockets,
    task_cleanup_consent,
    task_pipeline_post_to_zulip,
 )
-from reflector.pipelines.transcription_helpers import transcribe_file_with_processor
-from reflector.processors import AudioFileWriterProcessor
+from reflector.processors import (
+    AudioFileWriterProcessor,
+    TranscriptFinalSummaryProcessor,
+    TranscriptFinalTitleProcessor,
+    TranscriptTopicDetectorProcessor,
+)
 from reflector.processors.audio_waveform_processor import AudioWaveformProcessor
 from reflector.processors.file_diarization import FileDiarizationInput
 from reflector.processors.file_diarization_auto import FileDiarizationAutoProcessor
+from reflector.processors.file_transcript import FileTranscriptInput
+from reflector.processors.file_transcript_auto import FileTranscriptAutoProcessor
 from reflector.processors.transcript_diarization_assembler import (
    TranscriptDiarizationAssemblerInput,
    TranscriptDiarizationAssemblerProcessor,
@@ -51,6 +56,19 @@ from reflector.storage import get_transcripts_storage
 from reflector.worker.webhook import send_transcript_webhook


+class EmptyPipeline:
+    """Empty pipeline for processors that need a pipeline reference"""
+
+    def __init__(self, logger: structlog.BoundLogger):
+        self.logger = logger
+
+    def get_pref(self, k, d=None):
+        return d
+
+    async def emit(self, event):
+        pass
+
+
 class PipelineMainFile(PipelineMainBase):
    """
    Optimized file processing pipeline.
@@ -63,7 +81,7 @@ class PipelineMainFile(PipelineMainBase):
    def __init__(self, transcript_id: str):
        super().__init__(transcript_id=transcript_id)
        self.logger = logger.bind(transcript_id=self.transcript_id)
-        self.empty_pipeline = topic_processing.EmptyPipeline(logger=self.logger)
+        self.empty_pipeline = EmptyPipeline(logger=self.logger)

    def _handle_gather_exceptions(self, results: list, operation: str) -> None:
        """Handle exceptions from asyncio.gather with return_exceptions=True"""
@@ -113,7 +131,7 @@ class PipelineMainFile(PipelineMainBase):

        self.logger.info("File pipeline complete")

-        await self.set_status(transcript.id, "ended")
+        await transcripts_controller.set_status(transcript.id, "ended")

    async def extract_and_write_audio(
        self, file_path: Path, transcript: Transcript
@@ -244,7 +262,24 @@ class PipelineMainFile(PipelineMainBase):

    async def transcribe_file(self, audio_url: str, language: str) -> TranscriptType:
        """Transcribe complete file"""
-        return await transcribe_file_with_processor(audio_url, language)
+        processor = FileTranscriptAutoProcessor()
+        input_data = FileTranscriptInput(audio_url=audio_url, language=language)
+
+        # Store result for retrieval
+        result: TranscriptType | None = None
+
+        async def capture_result(transcript):
+            nonlocal result
+            result = transcript
+
+        processor.on(capture_result)
+        await processor.push(input_data)
+        await processor.flush()
+
+        if not result:
+            raise ValueError("No transcript captured")
+
+        return result

    async def diarize_file(self, audio_url: str) -> list[DiarizationSegment] | None:
        """Get diarization for file"""
@@ -287,31 +322,63 @@ class PipelineMainFile(PipelineMainBase):
    async def detect_topics(
        self, transcript: TranscriptType, target_language: str
    ) -> list[TitleSummary]:
-        return await topic_processing.detect_topics(
-            transcript,
-            target_language,
-            on_topic_callback=self.on_topic,
-            empty_pipeline=self.empty_pipeline,
-        )
+        """Detect topics from complete transcript"""
+        chunk_size = 300
+        topics: list[TitleSummary] = []
+
+        async def on_topic(topic: TitleSummary):
+            topics.append(topic)
+            return await self.on_topic(topic)
+
+        topic_detector = TranscriptTopicDetectorProcessor(callback=on_topic)
+        topic_detector.set_pipeline(self.empty_pipeline)
+
+        for i in range(0, len(transcript.words), chunk_size):
+            chunk_words = transcript.words[i : i + chunk_size]
+            if not chunk_words:
+                continue
+
+            chunk_transcript = TranscriptType(
+                words=chunk_words, translation=transcript.translation
+            )
+
+            await topic_detector.push(chunk_transcript)
+
+        await topic_detector.flush()
+        return topics

    async def generate_title(self, topics: list[TitleSummary]):
-        return await topic_processing.generate_title(
-            topics,
-            on_title_callback=self.on_title,
-            empty_pipeline=self.empty_pipeline,
-            logger=self.logger,
-        )
+        """Generate title from topics"""
+        if not topics:
+            self.logger.warning("No topics for title generation")
+            return
+
+        processor = TranscriptFinalTitleProcessor(callback=self.on_title)
+        processor.set_pipeline(self.empty_pipeline)
+
+        for topic in topics:
+            await processor.push(topic)
+
+        await processor.flush()

    async def generate_summaries(self, topics: list[TitleSummary]):
+        """Generate long and short summaries from topics"""
+        if not topics:
+            self.logger.warning("No topics for summary generation")
+            return
+
        transcript = await self.get_transcript()
-        return await topic_processing.generate_summaries(
-            topics,
-            transcript,
-            on_long_summary_callback=self.on_long_summary,
-            on_short_summary_callback=self.on_short_summary,
-            empty_pipeline=self.empty_pipeline,
-            logger=self.logger,
+        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
@@ -340,6 +407,7 @@ async def task_send_webhook_if_needed(*, transcript_id: str):
@asynctask
 async def task_pipeline_file_process(*, transcript_id: str):
    """Celery task for file pipeline processing"""
+
    transcript = await transcripts_controller.get_by_id(transcript_id)
    if not transcript:
        raise Exception(f"Transcript {transcript_id} not found")
@@ -358,12 +426,7 @@ async def task_pipeline_file_process(*, transcript_id: str):

        await pipeline.process(audio_file)

-    except Exception as e:
-        logger.error(
-            f"File pipeline failed for transcript {transcript_id}: {type(e).__name__}: {str(e)}",
-            exc_info=True,
-            transcript_id=transcript_id,
-        )
+    except Exception:
        await pipeline.set_status(transcript_id, "error")
        raise

--- a/server/reflector/pipelines/main_live_pipeline.py
+++ b/server/reflector/pipelines/main_live_pipeline.py
@@ -17,6 +17,7 @@ from contextlib import asynccontextmanager
 from typing import Generic

 import av
+import boto3
 from celery import chord, current_task, group, shared_task
 from pydantic import BaseModel
 from structlog import BoundLogger as Logger
@@ -84,20 +85,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


@@ -583,7 +570,6 @@ async def cleanup_consent(transcript: Transcript, logger: Logger):

    consent_denied = False
    recording = None
-    meeting = None
    try:
        if transcript.recording_id:
            recording = await recordings_controller.get_by_id(transcript.recording_id)
@@ -594,8 +580,8 @@ async def cleanup_consent(transcript: Transcript, logger: Logger):
                        meeting.id
                    )
    except Exception as e:
-        logger.error(f"Failed to fetch consent: {e}", exc_info=e)
-        raise
+        logger.error(f"Failed to get fetch consent: {e}", exc_info=e)
+        consent_denied = True

    if not consent_denied:
        logger.info("Consent approved, keeping all files")
@@ -603,24 +589,25 @@ async def cleanup_consent(transcript: Transcript, logger: Logger):

    logger.info("Consent denied, cleaning up all related audio files")

-    deletion_errors = []
-    if recording and recording.bucket_name:
-        keys_to_delete = []
-        if recording.track_keys:
-            keys_to_delete = recording.track_keys
-        elif recording.object_key:
-            keys_to_delete = [recording.object_key]
-
-        master_storage = get_transcripts_storage()
-        for key in keys_to_delete:
-            try:
-                await master_storage.delete_file(key, bucket=recording.bucket_name)
-                logger.info(f"Deleted recording file: {recording.bucket_name}/{key}")
-            except Exception as e:
-                error_msg = f"Failed to delete {key}: {e}"
-                logger.error(error_msg, exc_info=e)
-                deletion_errors.append(error_msg)
+    if recording and recording.bucket_name and recording.object_key:
+        s3_whereby = boto3.client(
+            "s3",
+            aws_access_key_id=settings.AWS_WHEREBY_ACCESS_KEY_ID,
+            aws_secret_access_key=settings.AWS_WHEREBY_ACCESS_KEY_SECRET,
+        )
+        try:
+            s3_whereby.delete_object(
+                Bucket=recording.bucket_name, Key=recording.object_key
+            )
+            logger.info(
+                f"Deleted original Whereby recording: {recording.bucket_name}/{recording.object_key}"
+            )
+        except Exception as e:
+            logger.error(f"Failed to delete Whereby recording: {e}", exc_info=e)

+    # non-transactional, files marked for deletion not actually deleted is possible
+    await transcripts_controller.update(transcript, {"audio_deleted": True})
+    # 2. Delete processed audio from transcript storage S3 bucket
    if transcript.audio_location == "storage":
        storage = get_transcripts_storage()
        try:
@@ -629,28 +616,18 @@ async def cleanup_consent(transcript: Transcript, logger: Logger):
                f"Deleted processed audio from storage: {transcript.storage_audio_path}"
            )
        except Exception as e:
-            error_msg = f"Failed to delete processed audio: {e}"
-            logger.error(error_msg, exc_info=e)
-            deletion_errors.append(error_msg)
+            logger.error(f"Failed to delete processed audio: {e}", exc_info=e)

+    # 3. Delete local audio files
    try:
        if hasattr(transcript, "audio_mp3_filename") and transcript.audio_mp3_filename:
            transcript.audio_mp3_filename.unlink(missing_ok=True)
        if hasattr(transcript, "audio_wav_filename") and transcript.audio_wav_filename:
            transcript.audio_wav_filename.unlink(missing_ok=True)
    except Exception as e:
-        error_msg = f"Failed to delete local audio files: {e}"
-        logger.error(error_msg, exc_info=e)
-        deletion_errors.append(error_msg)
+        logger.error(f"Failed to delete local audio files: {e}", exc_info=e)

-    if deletion_errors:
-        logger.warning(
-            f"Consent cleanup completed with {len(deletion_errors)} errors",
-            errors=deletion_errors,
-        )
-    else:
-        await transcripts_controller.update(transcript, {"audio_deleted": True})
-        logger.info("Consent cleanup done - all audio deleted")
+    logger.info("Consent cleanup done")


@get_transcript
--- a/server/reflector/pipelines/main_multitrack_pipeline.py
+++ b/server/reflector/pipelines/main_multitrack_pipeline.py
@@ -1,798 +0,0 @@
-import asyncio
-import math
-import tempfile
-from fractions import Fraction
-from pathlib import Path
-
-import av
-from av.audio.resampler import AudioResampler
-from celery import chain, shared_task
-
-from reflector.asynctask import asynctask
-from reflector.dailyco_api import MeetingParticipantsResponse
-from reflector.db.transcripts import (
-    Transcript,
-    TranscriptParticipant,
-    TranscriptStatus,
-    TranscriptWaveform,
-    transcripts_controller,
-)
-from reflector.logger import logger
-from reflector.pipelines import topic_processing
-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.pipelines.transcription_helpers import transcribe_file_with_processor
-from reflector.processors import AudioFileWriterProcessor
-from reflector.processors.audio_waveform_processor import AudioWaveformProcessor
-from reflector.processors.types import TitleSummary
-from reflector.processors.types import Transcript as TranscriptType
-from reflector.storage import Storage, get_transcripts_storage
-from reflector.utils.daily import (
-    filter_cam_audio_tracks,
-    parse_daily_recording_filename,
-)
-from reflector.utils.string import NonEmptyString
-from reflector.video_platforms.factory import create_platform_client
-
-# Audio encoding constants
-OPUS_STANDARD_SAMPLE_RATE = 48000
-OPUS_DEFAULT_BIT_RATE = 128000
-
-# Storage operation constants
-PRESIGNED_URL_EXPIRATION_SECONDS = 7200  # 2 hours
-
-
-class PipelineMainMultitrack(PipelineMainBase):
-    def __init__(self, transcript_id: str):
-        super().__init__(transcript_id=transcript_id)
-        self.logger = logger.bind(transcript_id=self.transcript_id)
-        self.empty_pipeline = topic_processing.EmptyPipeline(logger=self.logger)
-
-    async def pad_track_for_transcription(
-        self,
-        track_url: NonEmptyString,
-        track_idx: int,
-        storage: Storage,
-    ) -> NonEmptyString:
-        """
-        Pad a single track with silence based on stream metadata start_time.
-        Downloads from S3 presigned URL, processes via PyAV using tempfile, uploads to S3.
-        Returns presigned URL of padded track (or original URL if no padding needed).
-
-        Memory usage:
-        - Pattern: fixed_overhead(2-5MB) for PyAV codec/filters
-        - PyAV streams input efficiently (no full download, verified)
-        - Output written to tempfile (disk-based, not memory)
-        - Upload streams from file handle (boto3 chunks, typically 5-10MB)
-
-        Daily.co raw-tracks timing - Two approaches:
-
-            CURRENT APPROACH (PyAV metadata):
-            The WebM stream.start_time field encodes MEETING-RELATIVE timing:
-            - t=0: When Daily.co recording started (first participant joined)
-            - start_time=8.13s: This participant's track began 8.13s after recording started
-            - Purpose: Enables track alignment without external manifest files
-
-            This is NOT:
-            - Stream-internal offset (first packet timestamp relative to stream start)
-            - Absolute/wall-clock time
-            - Recording duration
-
-            ALTERNATIVE APPROACH (filename parsing):
-            Daily.co filenames contain Unix timestamps (milliseconds):
-            Format: {recording_start_ts}-{participant_id}-cam-audio-{track_start_ts}.webm
-            Example: 1760988935484-52f7f48b-fbab-431f-9a50-87b9abfc8255-cam-audio-1760988935922.webm
-
-            Can calculate offset: (track_start_ts - recording_start_ts) / 1000
-            - Track 0: (1760988935922 - 1760988935484) / 1000 = 0.438s
-            - Track 1: (1760988943823 - 1760988935484) / 1000 = 8.339s
-
-            TIME DIFFERENCE: PyAV metadata vs filename timestamps differ by ~209ms:
-            - Track 0: filename=438ms, metadata=229ms (diff: 209ms)
-            - Track 1: filename=8339ms, metadata=8130ms (diff: 209ms)
-
-            Consistent delta suggests network/encoding delay. PyAV metadata is ground truth
-            (represents when audio stream actually started vs when file upload initiated).
-
-            Example with 2 participants:
-                Track A: start_time=0.2s → Joined 200ms after recording began
-                Track B: start_time=8.1s → Joined 8.1 seconds later
-
-                After padding:
-                    Track A: [0.2s silence] + [speech...]
-                    Track B: [8.1s silence] + [speech...]
-
-                Whisper transcription timestamps are now synchronized:
-                    Track A word at 5.0s → happened at meeting t=5.0s
-                    Track B word at 10.0s → happened at meeting t=10.0s
-
-                Merging just sorts by timestamp - no offset calculation needed.
-
-        Padding coincidentally involves re-encoding. It's important when we work with Daily.co + Whisper.
-        This is because Daily.co returns recordings with skipped frames e.g. when microphone muted.
-        Daily.co doesn't understand those frames and ignores them, causing timestamp issues in transcription.
-        Re-encoding restores those frames. We do padding and re-encoding together just because it's convenient and more performant:
-        we need padded values for mix mp3 anyways
-        """
-
-        transcript = await self.get_transcript()
-
-        try:
-            # PyAV streams input from S3 URL efficiently (2-5MB fixed overhead for codec/filters)
-            with av.open(track_url) as in_container:
-                start_time_seconds = self._extract_stream_start_time_from_container(
-                    in_container, track_idx
-                )
-
-                if start_time_seconds <= 0:
-                    self.logger.info(
-                        f"Track {track_idx} requires no padding (start_time={start_time_seconds}s)",
-                        track_idx=track_idx,
-                    )
-                    return track_url
-
-                # Use tempfile instead of BytesIO for better memory efficiency
-                # Reduces peak memory usage during encoding/upload
-                with tempfile.NamedTemporaryFile(
-                    suffix=".webm", delete=False
-                ) as temp_file:
-                    temp_path = temp_file.name
-
-                try:
-                    self._apply_audio_padding_to_file(
-                        in_container, temp_path, start_time_seconds, track_idx
-                    )
-
-                    storage_path = (
-                        f"file_pipeline/{transcript.id}/tracks/padded_{track_idx}.webm"
-                    )
-
-                    # Upload using file handle for streaming
-                    with open(temp_path, "rb") as padded_file:
-                        await storage.put_file(storage_path, padded_file)
-                finally:
-                    # Clean up temp file
-                    Path(temp_path).unlink(missing_ok=True)
-
-                padded_url = await storage.get_file_url(
-                    storage_path,
-                    operation="get_object",
-                    expires_in=PRESIGNED_URL_EXPIRATION_SECONDS,
-                )
-
-                self.logger.info(
-                    f"Successfully padded track {track_idx}",
-                    track_idx=track_idx,
-                    start_time_seconds=start_time_seconds,
-                    padded_url=padded_url,
-                )
-
-                return padded_url
-
-        except Exception as e:
-            self.logger.error(
-                f"Failed to process track {track_idx}",
-                track_idx=track_idx,
-                url=track_url,
-                error=str(e),
-                exc_info=True,
-            )
-            raise Exception(
-                f"Track {track_idx} padding failed - transcript would have incorrect timestamps"
-            ) from e
-
-    def _extract_stream_start_time_from_container(
-        self, container, track_idx: int
-    ) -> float:
-        """
-        Extract meeting-relative start time from WebM stream metadata.
-        Uses PyAV to read stream.start_time from WebM container.
-        More accurate than filename timestamps by ~209ms due to network/encoding delays.
-        """
-        start_time_seconds = 0.0
-        try:
-            audio_streams = [s for s in container.streams if s.type == "audio"]
-            stream = audio_streams[0] if audio_streams else container.streams[0]
-
-            # 1) Try stream-level start_time (most reliable for Daily.co tracks)
-            if stream.start_time is not None and stream.time_base is not None:
-                start_time_seconds = float(stream.start_time * stream.time_base)
-
-            # 2) Fallback to container-level start_time (in av.time_base units)
-            if (start_time_seconds <= 0) and (container.start_time is not None):
-                start_time_seconds = float(container.start_time * av.time_base)
-
-            # 3) Fallback to first packet DTS in stream.time_base
-            if start_time_seconds <= 0:
-                for packet in container.demux(stream):
-                    if packet.dts is not None:
-                        start_time_seconds = float(packet.dts * stream.time_base)
-                        break
-        except Exception as e:
-            self.logger.warning(
-                "PyAV metadata read failed; assuming 0 start_time",
-                track_idx=track_idx,
-                error=str(e),
-            )
-            start_time_seconds = 0.0
-
-        self.logger.info(
-            f"Track {track_idx} stream metadata: start_time={start_time_seconds:.3f}s",
-            track_idx=track_idx,
-        )
-        return start_time_seconds
-
-    def _apply_audio_padding_to_file(
-        self,
-        in_container,
-        output_path: str,
-        start_time_seconds: float,
-        track_idx: int,
-    ) -> None:
-        """Apply silence padding to audio track using PyAV filter graph, writing to file"""
-        delay_ms = math.floor(start_time_seconds * 1000)
-
-        self.logger.info(
-            f"Padding track {track_idx} with {delay_ms}ms delay using PyAV",
-            track_idx=track_idx,
-            delay_ms=delay_ms,
-        )
-
-        try:
-            with av.open(output_path, "w", format="webm") as out_container:
-                in_stream = next(
-                    (s for s in in_container.streams if s.type == "audio"), None
-                )
-                if in_stream is None:
-                    raise Exception("No audio stream in input")
-
-                out_stream = out_container.add_stream(
-                    "libopus", rate=OPUS_STANDARD_SAMPLE_RATE
-                )
-                out_stream.bit_rate = OPUS_DEFAULT_BIT_RATE
-                graph = av.filter.Graph()
-
-                abuf_args = (
-                    f"time_base=1/{OPUS_STANDARD_SAMPLE_RATE}:"
-                    f"sample_rate={OPUS_STANDARD_SAMPLE_RATE}:"
-                    f"sample_fmt=s16:"
-                    f"channel_layout=stereo"
-                )
-                src = graph.add("abuffer", args=abuf_args, name="src")
-                aresample_f = graph.add("aresample", args="async=1", name="ares")
-                # adelay requires one delay value per channel separated by '|'
-                delays_arg = f"{delay_ms}|{delay_ms}"
-                adelay_f = graph.add(
-                    "adelay", args=f"delays={delays_arg}:all=1", name="delay"
-                )
-                sink = graph.add("abuffersink", name="sink")
-
-                src.link_to(aresample_f)
-                aresample_f.link_to(adelay_f)
-                adelay_f.link_to(sink)
-                graph.configure()
-
-                resampler = AudioResampler(
-                    format="s16", layout="stereo", rate=OPUS_STANDARD_SAMPLE_RATE
-                )
-                # Decode -> resample -> push through graph -> encode Opus
-                for frame in in_container.decode(in_stream):
-                    out_frames = resampler.resample(frame) or []
-                    for rframe in out_frames:
-                        rframe.sample_rate = OPUS_STANDARD_SAMPLE_RATE
-                        rframe.time_base = Fraction(1, OPUS_STANDARD_SAMPLE_RATE)
-                        src.push(rframe)
-
-                        while True:
-                            try:
-                                f_out = sink.pull()
-                            except Exception:
-                                break
-                            f_out.sample_rate = OPUS_STANDARD_SAMPLE_RATE
-                            f_out.time_base = Fraction(1, OPUS_STANDARD_SAMPLE_RATE)
-                            for packet in out_stream.encode(f_out):
-                                out_container.mux(packet)
-
-                src.push(None)
-                while True:
-                    try:
-                        f_out = sink.pull()
-                    except Exception:
-                        break
-                    f_out.sample_rate = OPUS_STANDARD_SAMPLE_RATE
-                    f_out.time_base = Fraction(1, OPUS_STANDARD_SAMPLE_RATE)
-                    for packet in out_stream.encode(f_out):
-                        out_container.mux(packet)
-
-                for packet in out_stream.encode(None):
-                    out_container.mux(packet)
-        except Exception as e:
-            self.logger.error(
-                "PyAV padding failed for track",
-                track_idx=track_idx,
-                delay_ms=delay_ms,
-                error=str(e),
-                exc_info=True,
-            )
-            raise
-
-    async def mixdown_tracks(
-        self,
-        track_urls: list[str],
-        writer: AudioFileWriterProcessor,
-        offsets_seconds: list[float] | None = None,
-    ) -> None:
-        """Multi-track mixdown using PyAV filter graph (amix), reading from S3 presigned URLs"""
-
-        target_sample_rate: int | None = None
-        for url in track_urls:
-            if not url:
-                continue
-            container = None
-            try:
-                container = av.open(url)
-                for frame in container.decode(audio=0):
-                    target_sample_rate = frame.sample_rate
-                    break
-            except Exception:
-                continue
-            finally:
-                if container is not None:
-                    container.close()
-            if target_sample_rate:
-                break
-
-        if not target_sample_rate:
-            self.logger.error("Mixdown failed - no decodable audio frames found")
-            raise Exception("Mixdown failed: No decodable audio frames in any track")
-        # 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_urls = [url for url in track_urls if url]
-        input_offsets_seconds = None
-        if offsets_seconds is not None:
-            input_offsets_seconds = [
-                offsets_seconds[i] for i, url in enumerate(track_urls) if url
-            ]
-        for idx, url in enumerate(valid_track_urls):
-            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.error("Mixdown failed - no valid inputs for graph")
-            raise Exception("Mixdown failed: No valid inputs for filter graph")
-
-        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()
-
-        containers = []
-        try:
-            # Open all containers with cleanup guaranteed
-            for i, url in enumerate(valid_track_urls):
-                try:
-                    c = av.open(
-                        url,
-                        options={
-                            # it's trying to stream from s3 by default
-                            "reconnect": "1",
-                            "reconnect_streamed": "1",
-                            "reconnect_delay_max": "5",
-                        },
-                    )
-                    containers.append(c)
-                except Exception as e:
-                    self.logger.warning(
-                        "Mixdown: failed to open container from URL",
-                        input=i,
-                        url=url,
-                        error=str(e),
-                    )
-
-            if not containers:
-                self.logger.error("Mixdown failed - no valid containers opened")
-                raise Exception("Mixdown failed: Could not open any track containers")
-
-            decoders = [c.decode(audio=0) for c in containers]
-            active = [True] * len(decoders)
-            resamplers = [
-                AudioResampler(format="s32", layout="stereo", rate=target_sample_rate)
-                for _ in decoders
-            ]
-
-            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
-                        # causes stream to move on / unclogs memory
-                        inputs[i].push(None)
-                        continue
-
-                    if frame.sample_rate != target_sample_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)
-
-                    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)
-
-            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:
-            # Cleanup all containers, even if processing failed
-            for c in containers:
-                if c is not None:
-                    try:
-                        c.close()
-                    except Exception:
-                        pass  # Best effort cleanup
-
-    @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 update_participants_from_daily(
-        self, transcript: Transcript, track_keys: list[str]
-    ) -> None:
-        """Update transcript participants with user_id and names from Daily.co API."""
-        if not transcript.recording_id:
-            return
-
-        try:
-            async with create_platform_client("daily") as daily_client:
-                id_to_name = {}
-                id_to_user_id = {}
-
-                try:
-                    rec_details = await daily_client.get_recording(
-                        transcript.recording_id
-                    )
-                    mtg_session_id = rec_details.mtgSessionId
-                    if mtg_session_id:
-                        try:
-                            payload: MeetingParticipantsResponse = (
-                                await daily_client.get_meeting_participants(
-                                    mtg_session_id
-                                )
-                            )
-                            for p in payload.data:
-                                pid = p.participant_id
-                                name = p.user_name
-                                user_id = p.user_id
-                                if name:
-                                    id_to_name[pid] = name
-                                if user_id:
-                                    id_to_user_id[pid] = user_id
-                        except Exception as e:
-                            self.logger.warning(
-                                "Failed to fetch Daily meeting participants",
-                                error=str(e),
-                                mtg_session_id=mtg_session_id,
-                                exc_info=True,
-                            )
-                    else:
-                        self.logger.warning(
-                            "No mtgSessionId found for recording; participant names may be generic",
-                            recording_id=transcript.recording_id,
-                        )
-                except Exception as e:
-                    self.logger.warning(
-                        "Failed to fetch Daily recording details",
-                        error=str(e),
-                        recording_id=transcript.recording_id,
-                        exc_info=True,
-                    )
-                    return
-
-                cam_audio_keys = filter_cam_audio_tracks(track_keys)
-
-                for idx, key in enumerate(cam_audio_keys):
-                    try:
-                        parsed = parse_daily_recording_filename(key)
-                        participant_id = parsed.participant_id
-                    except ValueError as e:
-                        self.logger.error(
-                            "Failed to parse Daily recording filename",
-                            error=str(e),
-                            key=key,
-                            exc_info=True,
-                        )
-                        continue
-
-                    default_name = f"Speaker {idx}"
-                    name = id_to_name.get(participant_id, default_name)
-                    user_id = id_to_user_id.get(participant_id)
-
-                    participant = TranscriptParticipant(
-                        id=participant_id, speaker=idx, name=name, user_id=user_id
-                    )
-                    await transcripts_controller.upsert_participant(
-                        transcript, participant
-                    )
-
-        except Exception as e:
-            self.logger.warning(
-                "Failed to map participant names", error=str(e), exc_info=True
-            )
-
-    async def process(self, bucket_name: str, track_keys: list[str]):
-        transcript = await self.get_transcript()
-        async with self.transaction():
-            await transcripts_controller.update(
-                transcript,
-                {
-                    "events": [],
-                    "topics": [],
-                    "participants": [],
-                },
-            )
-
-        await self.update_participants_from_daily(transcript, track_keys)
-
-        source_storage = get_transcripts_storage()
-        transcript_storage = source_storage
-
-        track_urls: list[str] = []
-        for key in track_keys:
-            url = await source_storage.get_file_url(
-                key,
-                operation="get_object",
-                expires_in=PRESIGNED_URL_EXPIRATION_SECONDS,
-                bucket=bucket_name,
-            )
-            track_urls.append(url)
-            self.logger.info(
-                f"Generated presigned URL for track from {bucket_name}",
-                key=key,
-            )
-
-        created_padded_files = set()
-        padded_track_urls: list[str] = []
-        for idx, url in enumerate(track_urls):
-            padded_url = await self.pad_track_for_transcription(
-                url, idx, transcript_storage
-            )
-            padded_track_urls.append(padded_url)
-            if padded_url != url:
-                storage_path = f"file_pipeline/{transcript.id}/tracks/padded_{idx}.webm"
-                created_padded_files.add(storage_path)
-            self.logger.info(f"Track {idx} processed, padded URL: {padded_url}")
-
-        transcript.data_path.mkdir(parents=True, exist_ok=True)
-
-        mp3_writer = AudioFileWriterProcessor(
-            path=str(transcript.audio_mp3_filename),
-            on_duration=self.on_duration,
-        )
-        await self.mixdown_tracks(padded_track_urls, mp3_writer, offsets_seconds=None)
-        await mp3_writer.flush()
-
-        if not transcript.audio_mp3_filename.exists():
-            raise Exception(
-                "Mixdown failed - no MP3 file generated. Cannot proceed without playable audio."
-            )
-
-        storage_path = f"{transcript.id}/audio.mp3"
-        # Use file handle streaming to avoid loading entire MP3 into memory
-        mp3_size = transcript.audio_mp3_filename.stat().st_size
-        with open(transcript.audio_mp3_filename, "rb") as mp3_file:
-            await transcript_storage.put_file(storage_path, mp3_file)
-        mp3_url = await transcript_storage.get_file_url(storage_path)
-
-        await transcripts_controller.update(transcript, {"audio_location": "storage"})
-
-        self.logger.info(
-            f"Uploaded mixed audio to storage",
-            storage_path=storage_path,
-            size=mp3_size,
-            url=mp3_url,
-        )
-
-        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")
-
-        speaker_transcripts: list[TranscriptType] = []
-        for idx, padded_url in enumerate(padded_track_urls):
-            if not padded_url:
-                continue
-
-            t = await self.transcribe_file(padded_url, transcript.source_language)
-
-            if not t.words:
-                self.logger.debug(f"no words in track {idx}")
-                # not skipping, it may be silence or indistinguishable mumbling
-
-            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,
-            )
-
-        valid_track_count = len([url for url in padded_track_urls if url])
-        if valid_track_count > 0 and len(speaker_transcripts) != valid_track_count:
-            raise Exception(
-                f"Only {len(speaker_transcripts)}/{valid_track_count} tracks transcribed successfully. "
-                f"All tracks must succeed to avoid incomplete transcripts."
-            )
-
-        if not speaker_transcripts:
-            raise Exception("No valid track transcriptions")
-
-        self.logger.info(f"Cleaning up {len(created_padded_files)} temporary S3 files")
-        cleanup_tasks = []
-        for storage_path in created_padded_files:
-            cleanup_tasks.append(transcript_storage.delete_file(storage_path))
-
-        if cleanup_tasks:
-            cleanup_results = await asyncio.gather(
-                *cleanup_tasks, return_exceptions=True
-            )
-            for storage_path, result in zip(created_padded_files, cleanup_results):
-                if isinstance(result, Exception):
-                    self.logger.warning(
-                        "Failed to cleanup temporary padded track",
-                        storage_path=storage_path,
-                        error=str(result),
-                    )
-
-        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 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:
-        return await transcribe_file_with_processor(audio_url, language)
-
-    async def detect_topics(
-        self, transcript: TranscriptType, target_language: str
-    ) -> list[TitleSummary]:
-        return await topic_processing.detect_topics(
-            transcript,
-            target_language,
-            on_topic_callback=self.on_topic,
-            empty_pipeline=self.empty_pipeline,
-        )
-
-    async def generate_title(self, topics: list[TitleSummary]):
-        return await topic_processing.generate_title(
-            topics,
-            on_title_callback=self.on_title,
-            empty_pipeline=self.empty_pipeline,
-            logger=self.logger,
-        )
-
-    async def generate_summaries(self, topics: list[TitleSummary]):
-        transcript = await self.get_transcript()
-        return await topic_processing.generate_summaries(
-            topics,
-            transcript,
-            on_long_summary_callback=self.on_long_summary,
-            on_short_summary_callback=self.on_short_summary,
-            empty_pipeline=self.empty_pipeline,
-            logger=self.logger,
-        )
-
-
-@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/topic_processing.py
+++ b/server/reflector/pipelines/topic_processing.py
@@ -1,109 +0,0 @@
-"""
-Topic processing utilities
-==========================
-
-Shared topic detection, title generation, and summarization logic
-used across file and multitrack pipelines.
-"""
-
-from typing import Callable
-
-import structlog
-
-from reflector.db.transcripts import Transcript
-from reflector.processors import (
-    TranscriptFinalSummaryProcessor,
-    TranscriptFinalTitleProcessor,
-    TranscriptTopicDetectorProcessor,
-)
-from reflector.processors.types import TitleSummary
-from reflector.processors.types import Transcript as TranscriptType
-
-
-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
-
-
-async def detect_topics(
-    transcript: TranscriptType,
-    target_language: str,
-    *,
-    on_topic_callback: Callable,
-    empty_pipeline: EmptyPipeline,
-) -> list[TitleSummary]:
-    chunk_size = 300
-    topics: list[TitleSummary] = []
-
-    async def on_topic(topic: TitleSummary):
-        topics.append(topic)
-        return await on_topic_callback(topic)
-
-    topic_detector = TranscriptTopicDetectorProcessor(callback=on_topic)
-    topic_detector.set_pipeline(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(
-    topics: list[TitleSummary],
-    *,
-    on_title_callback: Callable,
-    empty_pipeline: EmptyPipeline,
-    logger: structlog.BoundLogger,
-):
-    if not topics:
-        logger.warning("No topics for title generation")
-        return
-
-    processor = TranscriptFinalTitleProcessor(callback=on_title_callback)
-    processor.set_pipeline(empty_pipeline)
-
-    for topic in topics:
-        await processor.push(topic)
-
-    await processor.flush()
-
-
-async def generate_summaries(
-    topics: list[TitleSummary],
-    transcript: Transcript,
-    *,
-    on_long_summary_callback: Callable,
-    on_short_summary_callback: Callable,
-    empty_pipeline: EmptyPipeline,
-    logger: structlog.BoundLogger,
-):
-    if not topics:
-        logger.warning("No topics for summary generation")
-        return
-
-    processor = TranscriptFinalSummaryProcessor(
-        transcript=transcript,
-        callback=on_long_summary_callback,
-        on_short_summary=on_short_summary_callback,
-    )
-    processor.set_pipeline(empty_pipeline)
-
-    for topic in topics:
-        await processor.push(topic)
-
-    await processor.flush()
--- a/server/reflector/pipelines/transcription_helpers.py
+++ b/server/reflector/pipelines/transcription_helpers.py
@@ -1,34 +0,0 @@
-from reflector.processors.file_transcript import FileTranscriptInput
-from reflector.processors.file_transcript_auto import FileTranscriptAutoProcessor
-from reflector.processors.types import Transcript as TranscriptType
-
-
-async def transcribe_file_with_processor(
-    audio_url: str,
-    language: str,
-    processor_name: str | None = None,
-) -> TranscriptType:
-    processor = (
-        FileTranscriptAutoProcessor(name=processor_name)
-        if processor_name
-        else 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:
-        processor_label = processor_name or "default"
-        raise ValueError(
-            f"No transcript captured from {processor_label} processor for audio: {audio_url}"
-        )
-
-    return result
--- a/server/reflector/processors/file_transcript_modal.py
+++ b/server/reflector/processors/file_transcript_modal.py
@@ -56,16 +56,6 @@ class FileTranscriptModalProcessor(FileTranscriptProcessor):
                },
                follow_redirects=True,
            )
-
-            if response.status_code != 200:
-                error_body = response.text
-                self.logger.error(
-                    "Modal API error",
-                    audio_url=data.audio_url,
-                    status_code=response.status_code,
-                    error_body=error_body,
-                )
-
            response.raise_for_status()
            result = response.json()

--- a/server/reflector/processors/summary/summary_builder.py
+++ b/server/reflector/processors/summary/summary_builder.py
@@ -165,7 +165,6 @@ class SummaryBuilder:
        self.llm: LLM = llm
        self.model_name: str = llm.model_name
        self.logger = logger or structlog.get_logger()
-        self.participant_instructions: str | None = None
        if filename:
            self.read_transcript_from_file(filename)

@@ -192,61 +191,14 @@ class SummaryBuilder:
        self, prompt: str, output_cls: Type[T], tone_name: str | None = None
    ) -> T:
        """Generic function to get structured output from LLM for non-function-calling models."""
-        # Add participant instructions to the prompt if available
-        enhanced_prompt = self._enhance_prompt_with_participants(prompt)
        return await self.llm.get_structured_response(
-            enhanced_prompt, [self.transcript], output_cls, tone_name=tone_name
+            prompt, [self.transcript], output_cls, tone_name=tone_name
        )

-    async def _get_response(
-        self, prompt: str, texts: list[str], tone_name: str | None = None
-    ) -> str:
-        """Get text response with automatic participant instructions injection."""
-        enhanced_prompt = self._enhance_prompt_with_participants(prompt)
-        return await self.llm.get_response(enhanced_prompt, texts, tone_name=tone_name)
-
-    def _enhance_prompt_with_participants(self, prompt: str) -> str:
-        """Add participant instructions to any prompt if participants are known."""
-        if self.participant_instructions:
-            self.logger.debug("Adding participant instructions to prompt")
-            return f"{prompt}\n\n{self.participant_instructions}"
-        return prompt
-
    # ----------------------------------------------------------------------------
    # Participants
    # ----------------------------------------------------------------------------

-    def set_known_participants(self, participants: list[str]) -> None:
-        """
-        Set known participants directly without LLM identification.
-        This is used when participants are already identified and stored.
-        They are appended at the end of the transcript, providing more context for the assistant.
-        """
-        if not participants:
-            self.logger.warning("No participants provided")
-            return
-
-        self.logger.info(
-            "Using known participants",
-            participants=participants,
-        )
-
-        participants_md = self.format_list_md(participants)
-        self.transcript += f"\n\n# Participants\n\n{participants_md}"
-
-        # Set instructions that will be automatically added to all prompts
-        participants_list = ", ".join(participants)
-        self.participant_instructions = dedent(
-            f"""
-            # IMPORTANT: Participant Names
-            The following participants are identified in this conversation: {participants_list}
-
-            You MUST use these specific participant names when referring to people in your response.
-            Do NOT use generic terms like "a participant", "someone", "attendee", "Speaker 1", "Speaker 2", etc.
-            Always refer to people by their actual names (e.g., "John suggested..." not "A participant suggested...").
-            """
-        ).strip()
-
    async def identify_participants(self) -> None:
        """
        From a transcript, try to identify the participants using TreeSummarize with structured output.
@@ -280,19 +232,6 @@ class SummaryBuilder:
            if unique_participants:
                participants_md = self.format_list_md(unique_participants)
                self.transcript += f"\n\n# Participants\n\n{participants_md}"
-
-                # Set instructions that will be automatically added to all prompts
-                participants_list = ", ".join(unique_participants)
-                self.participant_instructions = dedent(
-                    f"""
-                    # IMPORTANT: Participant Names
-                    The following participants are identified in this conversation: {participants_list}
-
-                    You MUST use these specific participant names when referring to people in your response.
-                    Do NOT use generic terms like "a participant", "someone", "attendee", "Speaker 1", "Speaker 2", etc.
-                    Always refer to people by their actual names (e.g., "John suggested..." not "A participant suggested...").
-                    """
-                ).strip()
            else:
                self.logger.warning("No participants identified in the transcript")

@@ -379,13 +318,13 @@ class SummaryBuilder:
        for subject in self.subjects:
            detailed_prompt = DETAILED_SUBJECT_PROMPT_TEMPLATE.format(subject=subject)

-            detailed_response = await self._get_response(
+            detailed_response = await self.llm.get_response(
                detailed_prompt, [self.transcript], tone_name="Topic assistant"
            )

            paragraph_prompt = PARAGRAPH_SUMMARY_PROMPT

-            paragraph_response = await self._get_response(
+            paragraph_response = await self.llm.get_response(
                paragraph_prompt, [str(detailed_response)], tone_name="Topic summarizer"
            )

@@ -406,7 +345,7 @@ class SummaryBuilder:

        recap_prompt = RECAP_PROMPT

-        recap_response = await self._get_response(
+        recap_response = await self.llm.get_response(
            recap_prompt, [summaries_text], tone_name="Recap summarizer"
        )

--- a/server/reflector/processors/transcript_final_summary.py
+++ b/server/reflector/processors/transcript_final_summary.py
@@ -26,25 +26,7 @@ class TranscriptFinalSummaryProcessor(Processor):
    async def get_summary_builder(self, text) -> SummaryBuilder:
        builder = SummaryBuilder(self.llm, logger=self.logger)
        builder.set_transcript(text)
-
-        # Use known participants if available, otherwise identify them
-        if self.transcript and self.transcript.participants:
-            # Extract participant names from the stored participants
-            participant_names = [p.name for p in self.transcript.participants if p.name]
-            if participant_names:
-                self.logger.info(
-                    f"Using {len(participant_names)} known participants from transcript"
-                )
-                builder.set_known_participants(participant_names)
-            else:
-                self.logger.info(
-                    "Participants field exists but is empty, identifying participants"
-                )
-                await builder.identify_participants()
-        else:
-            self.logger.info("No participants stored, identifying participants")
-            await builder.identify_participants()
-
+        await builder.identify_participants()
        await builder.generate_summary()
        return builder

@@ -67,30 +49,18 @@ class TranscriptFinalSummaryProcessor(Processor):
        speakermap = {}
        if self.transcript:
            speakermap = {
-                p.speaker: p.name
-                for p in (self.transcript.participants or [])
-                if p.speaker is not None and p.name
+                participant["speaker"]: participant["name"]
+                for participant in self.transcript.participants
            }
-            self.logger.info(
-                f"Built speaker map with {len(speakermap)} participants",
-                speakermap=speakermap,
-            )

        # build the transcript as a single string
-        # Replace speaker IDs with actual participant names if available
+        # XXX: unsure if the participants name as replaced directly in speaker ?
        text_transcript = []
-        unique_speakers = set()
        for topic in self.chunks:
            for segment in topic.transcript.as_segments():
                name = speakermap.get(segment.speaker, f"Speaker {segment.speaker}")
-                unique_speakers.add((segment.speaker, name))
                text_transcript.append(f"{name}: {segment.text}")

-        self.logger.info(
-            f"Built transcript with {len(unique_speakers)} unique speakers",
-            speakers=list(unique_speakers),
-        )
-
        text_transcript = "\n".join(text_transcript)

        last_chunk = self.chunks[-1]
--- 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 AliasChoices, BaseModel, 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"""

-    title: str = Field(
-        description="A descriptive title for the topic being discussed",
-        validation_alias=AliasChoices("title", "Title"),
-    )
-    summary: str = Field(
-        description="A concise 1-2 sentence summary of the discussion",
-        validation_alias=AliasChoices("summary", "Summary"),
-    )
+    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")


 class TranscriptTopicDetectorProcessor(Processor):
--- a/server/reflector/processors/types.py
+++ b/server/reflector/processors/types.py
@@ -1,12 +1,14 @@
 import io
 import re
 import tempfile
-from collections import defaultdict
 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,17 +19,9 @@ class DiarizationSegment(TypedDict):


 PUNC_RE = re.compile(r"[.;:?!…]")
-SENTENCE_END_RE = re.compile(r"[.?!…]$")

-# Max segment length for words_to_segments() - breaks on any punctuation (. ; : ? ! …)
-# when segment exceeds this limit. Used for non-multitrack recordings.
-MAX_SEGMENT_CHARS = 120
-
-# Max segment length for words_to_segments_by_sentence() - only breaks on sentence-ending
-# punctuation (. ? ! …) when segment exceeds this limit. Higher threshold allows complete
-# sentences in multitrack recordings where speakers overlap.
-# similar number to server/reflector/processors/transcript_liner.py
-MAX_SENTENCE_SEGMENT_CHARS = 1000
+profanity_filter = ProfanityFilter()
+profanity_filter.set_censor("*")


 class AudioFile(BaseModel):
@@ -88,6 +82,7 @@ def words_to_segments(words: list[Word]) -> list[TranscriptSegment]:
    # but separate if the speaker changes, or if the punctuation is a . , ; : ? !
    segments = []
    current_segment = None
+    MAX_SEGMENT_LENGTH = 120

    for word in words:
        if current_segment is None:
@@ -117,7 +112,7 @@ def words_to_segments(words: list[Word]) -> list[TranscriptSegment]:
        current_segment.end = word.end

        have_punc = PUNC_RE.search(word.text)
-        if have_punc and (len(current_segment.text) > MAX_SEGMENT_CHARS):
+        if have_punc and (len(current_segment.text) > MAX_SEGMENT_LENGTH):
            segments.append(current_segment)
            current_segment = None

@@ -127,77 +122,23 @@ def words_to_segments(words: list[Word]) -> list[TranscriptSegment]:
    return segments


-def words_to_segments_by_sentence(words: list[Word]) -> list[TranscriptSegment]:
-    """Group words by speaker, then split into sentences.
-
-    For multitrack recordings where words from different speakers are interleaved
-    by timestamp, this function first groups all words by speaker, then creates
-    segments based on sentence boundaries within each speaker's words.
-
-    This produces cleaner output than words_to_segments() which breaks on every
-    speaker change, resulting in many tiny segments when speakers overlap.
-    """
-    if not words:
-        return []
-
-    # Group words by speaker, preserving order within each speaker
-    by_speaker: dict[int, list[Word]] = defaultdict(list)
-    for w in words:
-        by_speaker[w.speaker].append(w)
-
-    segments: list[TranscriptSegment] = []
-
-    for speaker, speaker_words in by_speaker.items():
-        current_text = ""
-        current_start: float | None = None
-        current_end: float = 0.0
-
-        for word in speaker_words:
-            if current_start is None:
-                current_start = word.start
-
-            current_text += word.text
-            current_end = word.end
-
-            # Check for sentence end or max length
-            is_sentence_end = SENTENCE_END_RE.search(word.text.strip())
-            is_too_long = len(current_text) >= MAX_SENTENCE_SEGMENT_CHARS
-
-            if is_sentence_end or is_too_long:
-                segments.append(
-                    TranscriptSegment(
-                        text=current_text,
-                        start=current_start,
-                        end=current_end,
-                        speaker=speaker,
-                    )
-                )
-                current_text = ""
-                current_start = None
-
-        # Flush remaining words for this speaker
-        if current_text and current_start is not None:
-            segments.append(
-                TranscriptSegment(
-                    text=current_text,
-                    start=current_start,
-                    end=current_end,
-                    speaker=speaker,
-                )
-            )
-
-    # Sort segments by start time
-    segments.sort(key=lambda s: s.start)
-    return segments
-
-
 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):
@@ -229,9 +170,13 @@ class Transcript(BaseModel):
            word.start += offset
            word.end += offset

-    def as_segments(self, is_multitrack: bool = False) -> list[TranscriptSegment]:
-        if is_multitrack:
-            return words_to_segments_by_sentence(self.words)
+    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/schemas/platform.py
+++ b/server/reflector/schemas/platform.py
@@ -1,5 +0,0 @@
-from typing import Literal
-
-Platform = Literal["whereby", "daily"]
-WHEREBY_PLATFORM: Platform = "whereby"
-DAILY_PLATFORM: Platform = "daily"
--- a/server/reflector/schemas/transcript_formats.py
+++ b/server/reflector/schemas/transcript_formats.py
@@ -1,17 +0,0 @@
-"""Schema definitions for transcript format types and segments."""
-
-from typing import Literal
-
-from pydantic import BaseModel
-
-TranscriptFormat = Literal["text", "text-timestamped", "webvtt-named", "json"]
-
-
-class TranscriptSegment(BaseModel):
-    """A single transcript segment with speaker and timing information."""
-
-    speaker: int
-    speaker_name: str
-    text: str
-    start: float
-    end: float
--- 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/services/transcript_process.py
+++ b/server/reflector/services/transcript_process.py
@@ -1,171 +0,0 @@
-"""
-Transcript processing service - shared logic for HTTP endpoints and Celery tasks.
-
-This module provides result-based error handling that works in both contexts:
- HTTP endpoint: converts errors to HTTPException
- Celery task: converts errors to Exception
-"""
-
-from dataclasses import dataclass
-from typing import Literal, Union, assert_never
-
-import celery
-from celery.result import AsyncResult
-
-from reflector.db.recordings import recordings_controller
-from reflector.db.transcripts import Transcript
-from reflector.pipelines.main_file_pipeline import task_pipeline_file_process
-from reflector.pipelines.main_multitrack_pipeline import (
-    task_pipeline_multitrack_process,
-)
-from reflector.utils.string import NonEmptyString
-
-
-@dataclass
-class ProcessError:
-    detail: NonEmptyString
-
-
-@dataclass
-class FileProcessingConfig:
-    transcript_id: NonEmptyString
-    mode: Literal["file"] = "file"
-
-
-@dataclass
-class MultitrackProcessingConfig:
-    transcript_id: NonEmptyString
-    bucket_name: NonEmptyString
-    track_keys: list[str]
-    mode: Literal["multitrack"] = "multitrack"
-
-
-ProcessingConfig = Union[FileProcessingConfig, MultitrackProcessingConfig]
-PrepareResult = Union[ProcessingConfig, ProcessError]
-
-
-@dataclass
-class ValidationOk:
-    # transcript currently doesnt always have recording_id
-    recording_id: NonEmptyString | None
-    transcript_id: NonEmptyString
-
-
-@dataclass
-class ValidationLocked:
-    detail: NonEmptyString
-
-
-@dataclass
-class ValidationNotReady:
-    detail: NonEmptyString
-
-
-@dataclass
-class ValidationAlreadyScheduled:
-    detail: NonEmptyString
-
-
-ValidationError = Union[
-    ValidationNotReady, ValidationLocked, ValidationAlreadyScheduled
-]
-ValidationResult = Union[ValidationOk, ValidationError]
-
-
-@dataclass
-class DispatchOk:
-    status: Literal["ok"] = "ok"
-
-
-@dataclass
-class DispatchAlreadyRunning:
-    status: Literal["already_running"] = "already_running"
-
-
-DispatchResult = Union[
-    DispatchOk, DispatchAlreadyRunning, ProcessError, ValidationError
-]
-
-
-async def validate_transcript_for_processing(
-    transcript: Transcript,
-) -> ValidationResult:
-    if transcript.locked:
-        return ValidationLocked(detail="Recording is locked")
-
-    if transcript.status == "idle":
-        return ValidationNotReady(detail="Recording is not ready for processing")
-
-    if task_is_scheduled_or_active(
-        "reflector.pipelines.main_file_pipeline.task_pipeline_file_process",
-        transcript_id=transcript.id,
-    ) or task_is_scheduled_or_active(
-        "reflector.pipelines.main_multitrack_pipeline.task_pipeline_multitrack_process",
-        transcript_id=transcript.id,
-    ):
-        return ValidationAlreadyScheduled(detail="already running")
-
-    return ValidationOk(
-        recording_id=transcript.recording_id, transcript_id=transcript.id
-    )
-
-
-async def prepare_transcript_processing(validation: ValidationOk) -> PrepareResult:
-    """
-    Determine processing mode from transcript/recording data.
-    """
-    bucket_name: str | None = None
-    track_keys: list[str] | None = None
-
-    if validation.recording_id:
-        recording = await recordings_controller.get_by_id(validation.recording_id)
-        if recording:
-            bucket_name = recording.bucket_name
-            track_keys = recording.track_keys
-
-            if track_keys is not None and len(track_keys) == 0:
-                return ProcessError(
-                    detail="No track keys found, must be either > 0 or None",
-                )
-            if track_keys is not None and not bucket_name:
-                return ProcessError(
-                    detail="Bucket name must be specified",
-                )
-
-    if track_keys:
-        return MultitrackProcessingConfig(
-            bucket_name=bucket_name,  # type: ignore (validated above)
-            track_keys=track_keys,
-            transcript_id=validation.transcript_id,
-        )
-
-    return FileProcessingConfig(
-        transcript_id=validation.transcript_id,
-    )
-
-
-def dispatch_transcript_processing(config: ProcessingConfig) -> AsyncResult:
-    if isinstance(config, MultitrackProcessingConfig):
-        return task_pipeline_multitrack_process.delay(
-            transcript_id=config.transcript_id,
-            bucket_name=config.bucket_name,
-            track_keys=config.track_keys,
-        )
-    elif isinstance(config, FileProcessingConfig):
-        return task_pipeline_file_process.delay(transcript_id=config.transcript_id)
-    else:
-        assert_never(config)
-
-
-def task_is_scheduled_or_active(task_name: str, **kwargs):
-    inspect = celery.current_app.control.inspect()
-
-    scheduled = inspect.scheduled() or {}
-    active = inspect.active() or {}
-    all = scheduled | active
-    for worker, tasks in all.items():
-        for task in tasks:
-            if task["name"] == task_name and task["kwargs"] == kwargs:
-                return True
-
-    return False
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Mathieu Virbel	e91979abbc	feat: use jitsi file system	2025-09-17 15:16:03 -06:00
Mathieu Virbel	95e8011975	Merge main into jisti-integration branch - Resolved conflicts in server/reflector/views/rooms.py to keep platform-agnostic approach - Resolved conflicts in www/app/[roomName]/page.tsx to keep VideoPlatformEmbed approach - Accepted main's version of generated API files (schemas.gen.ts, services.gen.ts, types.gen.ts) - Removed config-template.ts as per main branch changes	2025-09-15 12:53:49 -06:00
Mathieu Virbel	293f7d4f1f	feat: implement frontend video platform configuration and abstraction - Add NEXT_PUBLIC_VIDEO_PLATFORM environment variable support - Create video platform abstraction layer with factory pattern - Implement Whereby and Jitsi platform providers - Update room meeting page to use platform-agnostic component - Add platform display in room management (cards and table views) - Support single platform per deployment configuration - Maintain backward compatibility with existing Whereby integration 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-04 12:21:51 -06:00
Mathieu Virbel	41224a424c	docs: move platform-jitsi.md to docs/ directory	2025-09-02 18:28:50 -06:00
Mathieu Virbel	dd0089906f	fix: replace datetime.utcnow() with datetime.now(tz=timezone.utc) in Jitsi health check	2025-09-02 18:25:55 -06:00
Mathieu Virbel	fa559b1970	feat: update and expand video platform tests - Update existing tests for StrEnum instead of string literals - Add comprehensive WherebyClient tests with HTTP mocking - Add webhook event storage tests for participant and recording events - Add typing overload tests for create_platform_client factory - Update webhook test paths to new video_platforms router locations - Fix mock ordering and parameter issues in async tests - Test all platform client functionality including signature verification - Verify webhook event storage with proper timestamp handling 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-02 18:16:41 -06:00
Mathieu Virbel	c26ce65083	feat: update Jitsi documentation with webhook events storage system - Add comprehensive webhook event storage documentation - Document event structure and JSON storage in meetings table - Add practical webhook testing examples with proper signature generation - Include detailed troubleshooting for webhook signature verification issues - Add webhook event payload examples for all supported event types - Document event storage verification and database querying methods - Enhance existing webhook configuration with real-world examples 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-02 18:09:44 -06:00
Mathieu Virbel	52eff2acc0	feat: clean up legacy code and remove excessive documentation - Remove excessive inline comments from meeting creation flow - Remove verbose docstrings from simple property methods and basic functions - Clean up obvious comments like 'Generate JWT tokens', 'Build room URLs' - Remove unnecessary explanatory comments in platform clients - Keep only essential documentation for complex logic - Simplify race condition handling comments - Remove excessive method documentation for simple operations 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-02 18:08:12 -06:00
Mathieu Virbel	7875ec3432	feat: move platform routers to video_platforms folders - Move Jitsi router from views/jitsi.py to video_platforms/jitsi/router.py - Move Whereby router from views/whereby.py to video_platforms/whereby/router.py - Update __init__.py files to export routers from platform packages - Update app.py imports to use video_platforms instead of views - Remove old view files after successful migration - Maintain exact same API endpoint paths (/v1/jitsi, /v1/whereby) 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-02 18:05:04 -06:00
Mathieu Virbel	398be06fad	feat: add typing overloads and clean up platform client factory - Add typing overloads to get_platform_client for JitsiClient and WherebyClient return types - Add overloads to create_platform_client in factory for better IDE support - Remove PyJWT fallback imports from views/rooms.py - Remove platform defaults from CreateRoom and UpdateRoom models - Clean up legacy whereby fallback code in meeting creation - Use direct platform client access instead of conditional fallbacks 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-02 18:02:43 -06:00
Mathieu Virbel	da700069d9	Add webhook events storage to meetings model - Add events column as JSON type to meetings table with default empty array - Add events: List[Dict[str, Any]] field to Meeting model - Create migration 2890b5104577 for events column and apply successfully - Add MeetingController helper methods for event storage: - add_event() for generic event storage with timestamps - participant_joined(), participant_left() for participant tracking - recording_started(), recording_stopped() for recording events - get_events() for event retrieval - Update Jitsi webhook endpoints to store events: - Store participant join/leave events with data and timestamps - Store recording start/stop events from Prosody webhooks - Store recording completion events from Jibri finalize script - Events stored with type, timestamp, and data for webhook history tracking - Fix linting and formatting issues Addresses PR feedback point 12: save webhook events in meetings events field	2025-09-02 17:53:35 -06:00
Mathieu Virbel	51229a1790	Fix Jitsi client issues and create typed meeting data - Remove 'transcription': True from JWT features in _generate_jwt - Replace int(time.time()) with generate_uuid4() for room naming to avoid conflicts - Replace datetime.utcnow() with datetime.now(tz=timezone.utc) for proper timezone handling - Create JitsiMeetingData(MeetingData) class with typed extra_data properties - Update PLATFORM_NAME = VideoPlatform.JITSI to use enum - Update create_meeting to return JitsiMeetingData instance with proper typing - Fix get_room_sessions mock to use timezone-aware datetime - Export JitsiMeetingData from jitsi module Addresses PR feedback points 4, 5, 6, 10: remove transcription features, use UUID, proper datetime handling, and typed meeting data	2025-09-02 17:44:04 -06:00
Mathieu Virbel	2d2c23f7cc	Create video_platforms/whereby structure and WherebyClient - Create video_platforms/whereby/ directory with __init__.py, client.py, tasks.py - Implement WherebyClient inheriting from VideoPlatformClient interface - Move all functions from whereby.py into WherebyClient methods - Use VideoPlatform.WHEREBY enum for PLATFORM_NAME - Register WherebyClient in platform registry - Update factory.py to include S3 bucket config for whereby - Update worker process to use platform abstraction for get_room_sessions - Preserve exact API behavior for meeting activity detection - Maintain AWS S3 configuration handling in WherebyClient - Fix linting and formatting issues Addresses PR feedback point 7: implement video_platforms/whereby structure Note: whereby.py kept for legacy fallback until task 7 cleanup	2025-09-02 17:40:32 -06:00
Mathieu Virbel	0acb9cac79	Replace Literal with VideoPlatform StrEnum for platform field - Create VideoPlatform StrEnum with WHEREBY and JITSI values - Update rooms.py and meetings.py to use VideoPlatform enum - Update views/rooms.py and video_platforms/factory.py to use enum values - Generate new migration with proper server_default='whereby' - Apply migration successfully with backward compatibility - Fix linting and formatting issues Addresses PR feedback point 1: use StrEnum instead of Literal[]	2025-09-02 17:36:14 -06:00
Mathieu Virbel	d861d92cc2	docs: add comprehensive Jitsi Meet integration user guide - Complete end-user configuration guide for self-hosted Jitsi Meet - Covers installation, JWT authentication, and Prosody configuration - Webhook event handling with mod_event_sync setup - Jibri recording service configuration and finalize script - Room creation, JWT token management, and security best practices - Comprehensive troubleshooting with debug commands and solutions - Performance optimization and scaling considerations - Migration guidance from Whereby platform 🤖 Generated with Claude Code	2025-09-02 17:07:09 -06:00
Mathieu Virbel	24ff83a2ec	docs: add comprehensive Whereby integration user guide - Complete end-user configuration guide for Whereby video platform - Covers account setup, API key generation, and webhook configuration - AWS S3 storage setup with IAM permissions and security best practices - Room creation, recording options, and meeting feature configuration - Troubleshooting guide with common issues and debug commands - Security considerations and performance optimization tips - Migration guidance from other platforms 🤖 Generated with Claude Code	2025-09-02 17:05:40 -06:00
Mathieu Virbel	249234238c	feat: add comprehensive video platform test suite - Created complete test coverage for video platform abstraction - Tests for base classes, JitsiClient implementation, and platform registry - JWT generation tests with proper mocking and error scenarios - Webhook signature verification tests (valid/invalid/missing secret) - Platform factory tests for Jitsi and Whereby configuration - Registry tests for platform registration and client creation - Webhook endpoint tests with signature verification and error cases - Integration tests for rooms endpoint with platform abstraction - 24 comprehensive test cases covering all video platform functionality - All tests passing with proper mocking and isolation 🤖 Generated with Claude Code	2025-09-02 16:54:58 -06:00
Mathieu Virbel	42a603d5c3	feat: add PyJWT dependency and finalize Jitsi integration - Added PyJWT>=2.8.0 to pyproject.toml dependencies - Installed dependency via uv sync successfully - Verified JWT generation functionality works correctly - Confirmed platform factory creates JitsiClient instances - Validated database migrations applied (platform fields available) - Tested webhook endpoints are registered and functional - Verified FastAPI app starts without errors with full integration - All integration tests pass - Jitsi platform fully functional 🤖 Generated with Claude Code	2025-09-02 16:28:44 -06:00
Mathieu Virbel	6d2092f950	feat: create comprehensive Jitsi integration documentation - Added complete end-user configuration guide at server/platform-jitsi.md - Covers prerequisites, environment setup, and Jitsi Meet configuration - Includes JWT authentication, Jibri recording, and Prosody event-sync setup - Provides troubleshooting guide with common issues and solutions - Documents security best practices and performance optimization - Includes testing procedures and migration guidance from Whereby - Ready for production deployment with step-by-step instructions - Uses environment variable placeholders for security 🤖 Generated with Claude Code	2025-09-02 16:24:47 -06:00
Mathieu Virbel	f2bb6aaecb	feat: update rooms.py to use video platform abstraction - Added platform field to Room, CreateRoom, and UpdateRoom models - Updated rooms_create function to pass platform parameter - Rewrote rooms_create_meeting to use platform factory pattern - Added graceful fallback to legacy whereby implementation - Maintained API compatibility and error handling patterns - Prepared for multi-platform support (Whereby/Jitsi) 🤖 Generated with Claude Code	2025-09-02 16:21:58 -06:00
Mathieu Virbel	2b136ac7b0	feat: create Jitsi webhook endpoints for event handling - Added comprehensive Jitsi webhook endpoint in views/jitsi.py - Handles Prosody event-sync events (muc-occupant-joined/left) - Implements participant counting following whereby.py pattern - Added Jibri recording completion webhook endpoint - Includes signature verification with fallback when platform client unavailable - Registered router in app.py for /v1/jitsi endpoints - Added health check endpoint for webhook configuration 🤖 Generated with Claude Code	2025-09-02 16:19:54 -06:00
Mathieu Virbel	3f4fc26483	feat: register Jitsi platform in video platforms factory and registry - Added JitsiClient registration to platform registry - Enables dynamic platform selection through factory pattern - Factory configuration already supports Jitsi settings - Platform abstraction layer now supports beide Whereby and Jitsi 🤖 Generated with Claude Code	2025-09-02 16:17:32 -06:00
Mathieu Virbel	8e5ef5bca6	feat: implement JitsiClient with JWT authentication Complete implementation of JitsiClient following VideoPlatformClient interface with JWT-based room access control and webhook signature verification. - Add JWT token generation with proper payload structure - Implement unique room name generation with timestamp - Create separate user/host JWT tokens with moderator permissions - Build secure room URLs with embedded JWT parameters - Add HMAC-SHA256 webhook signature verification for Prosody events - Implement all abstract methods with Jitsi-specific behavior - Include comprehensive typing and error handling 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-02 16:15:49 -06:00
Mathieu Virbel	d49fdcb38d	feat: create video platforms architecture with Jitsi directory structure Create complete video platforms abstraction layer following daily.co branch pattern with Jitsi-specific directory structure. - Add video_platforms base module with abstract classes - Create VideoPlatformClient, MeetingData, VideoPlatformConfig interfaces - Add platform registry system for client management - Create factory pattern for platform client creation - Add Jitsi directory structure with __init__.py, tasks.py, client.py - Configure Jitsi platform in factory with JWT-based authentication 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-02 16:14:42 -06:00
Mathieu Virbel	d42380abf1	feat: add Jitsi configuration settings Add comprehensive Jitsi Meet configuration settings to settings.py following the same pattern as WHEREBY settings. - Add JITSI_DOMAIN with meet.jit.si default - Add JITSI_JWT_SECRET for JWT token signing - Add JITSI_WEBHOOK_SECRET for webhook validation - Add JITSI_APP_ID, JITSI_JWT_ISSUER, JITSI_JWT_AUDIENCE for JWT configuration - Follow consistent naming and typing patterns 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-02 16:11:00 -06:00
Mathieu Virbel	cf64e1a3d9	feat: add database migration for platform field Generate Alembic migration to add platform column to rooms and meetings tables enabling multi-platform video conferencing support. - Add platform column to meeting table with whereby default - Add platform column to room table with whereby default - Migration tested successfully with alembic upgrade head 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-02 16:10:11 -06:00
Mathieu Virbel	ea53ca7000	feat: add platform field to Room and Meeting models Add platform column to rooms and meetings database tables with Literal typing to support multiple video conferencing platforms (whereby, jitsi). - Add platform column to rooms/meetings SQLAlchemy tables with whereby default - Update Room/Meeting Pydantic models with platform field and Literal typing - Modify RoomController.add() to accept platform parameter - Update MeetingController.create() to copy platform from room 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>	2025-09-02 16:08:38 -06:00
				`@@ -1 +0,0 @@`
				`"""Pipeline modules for audio processing."""`