chore(main): release 0.32.2 (#842 )

fix: use Daily API recording.duration as master source for transcript duration (#844 )
Set duration early in get_participants from Daily API (seconds -> ms), ensuring post_zulip has the value before mixdown_tracks completes. Removes redundant duration update from mixdown_tracks. Co-authored-by: Igor Loskutov <igor.loskutoff@gmail.com>
2026-02-04 18:06:48 +00:00 · 2026-02-03 22:05:22 -05:00 · 2026-02-03 17:15:03 -05:00 · 2026-02-03 16:05:16 -05:00 · 2026-02-03 00:18:47 +01:00 · 2026-01-30 17:34:48 -05:00
78 changed files with 3420 additions and 953 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@
 .DS_Store
 server/.env
 server/.env.production
 .env
 Caddyfile
 server/exportdanswer
--- a/.gitleaksignore
+++ b/.gitleaksignore
@@ -3,3 +3,4 @@ docs/docs/installation/auth-setup.md:curl-auth-header:250
 docs/docs/installation/daily-setup.md:curl-auth-header:277
 gpu/self_hosted/DEV_SETUP.md:curl-auth-header:74
 gpu/self_hosted/DEV_SETUP.md:curl-auth-header:83
 server/reflector/worker/process.py:generic-api-key:465
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,64 @@
 # Changelog
 ## [0.32.2](https://github.com/Monadical-SAS/reflector/compare/v0.32.1...v0.32.2) (2026-02-03)
 ### Bug Fixes
 * increase TIMEOUT_MEDIUM from 2m to 5m for LLM tasks ([#843](https://github.com/Monadical-SAS/reflector/issues/843)) ([4acde4b](https://github.com/Monadical-SAS/reflector/commit/4acde4b7fdef88cc02ca12cf38c9020b05ed96ac))
 * make caddy optional ([#841](https://github.com/Monadical-SAS/reflector/issues/841)) ([a2ed7d6](https://github.com/Monadical-SAS/reflector/commit/a2ed7d60d557b551a5b64e4dfd909b63a791d9fc))
 * use Daily API recording.duration as master source for transcript duration ([#844](https://github.com/Monadical-SAS/reflector/issues/844)) ([8707c66](https://github.com/Monadical-SAS/reflector/commit/8707c6694a80c939b6214bbc13331741f192e082))
 ## [0.32.1](https://github.com/Monadical-SAS/reflector/compare/v0.32.0...v0.32.1) (2026-01-30)
 ### Bug Fixes
 * daily multitrack pipeline finalze dependency fix ([23eb137](https://github.com/Monadical-SAS/reflector/commit/23eb1371cb9348c4b81eb12ad506b582f8a4799e))
 * match httpx pad with hatchet audio timeout ([c05d1f0](https://github.com/Monadical-SAS/reflector/commit/c05d1f03cd8369fc06efd455527e50246887efd0))
 ## [0.32.0](https://github.com/Monadical-SAS/reflector/compare/v0.31.0...v0.32.0) (2026-01-30)
 ### Features
 * modal padding ([#837](https://github.com/Monadical-SAS/reflector/issues/837)) ([7fde64e](https://github.com/Monadical-SAS/reflector/commit/7fde64e2529a1d37b0f7507c62d983a7bd0b5b89))
 ## [0.31.0](https://github.com/Monadical-SAS/reflector/compare/v0.30.0...v0.31.0) (2026-01-23)
 ### Features
 * mixdown optional ([#834](https://github.com/Monadical-SAS/reflector/issues/834)) ([fc3ef6c](https://github.com/Monadical-SAS/reflector/commit/fc3ef6c8933231c731fad84e7477a476a6220a5e))
 ## [0.30.0](https://github.com/Monadical-SAS/reflector/compare/v0.29.0...v0.30.0) (2026-01-23)
 ### Features
 * brady bunch ([#816](https://github.com/Monadical-SAS/reflector/issues/816)) ([6c175a1](https://github.com/Monadical-SAS/reflector/commit/6c175a11d8a3745095bfad06a4ad3ccdfd278433))
 ## [0.29.0](https://github.com/Monadical-SAS/reflector/compare/v0.28.1...v0.29.0) (2026-01-21)
 ### Features
 * set hatchet as default for multitracks ([#822](https://github.com/Monadical-SAS/reflector/issues/822)) ([c723752](https://github.com/Monadical-SAS/reflector/commit/c723752b7e15aa48a41ad22856f147a5517d3f46))
 ## [0.28.1](https://github.com/Monadical-SAS/reflector/compare/v0.28.0...v0.28.1) (2026-01-21)
 ### Bug Fixes
 * ics non-sync bugfix ([#823](https://github.com/Monadical-SAS/reflector/issues/823)) ([23d2bc2](https://github.com/Monadical-SAS/reflector/commit/23d2bc283d4d02187b250d2055103e0374ee93d6))
 ## [0.28.0](https://github.com/Monadical-SAS/reflector/compare/v0.27.0...v0.28.0) (2026-01-20)
 ### Features
 * worker affinity ([#819](https://github.com/Monadical-SAS/reflector/issues/819)) ([3b6540e](https://github.com/Monadical-SAS/reflector/commit/3b6540eae5b597449f98661bdf15483b77be3268))
 ## [0.27.0](https://github.com/Monadical-SAS/reflector/compare/v0.26.0...v0.27.0) (2025-12-26)
--- a/Caddyfile.example
+++ b/Caddyfile.example
@@ -1,6 +1,8 @@
-# Reflector Caddyfile
+# Reflector Caddyfile (optional reverse proxy)
-# Replace example.com with your actual domains
+# Use this only when you run Caddy via: docker compose -f docker-compose.prod.yml --profile caddy up -d
-# CORS is handled by the backend - Caddy just proxies
+# If Coolify, Traefik, or nginx already use ports 80/443, do NOT start Caddy; point your proxy at web:3000 and server:1250.
 #
 # Replace example.com with your actual domains. CORS is handled by the backend - Caddy just proxies.
 #
 # For environment variable substitution, set:
 #   FRONTEND_DOMAIN=app.example.com
--- a/docker-compose.prod.yml
+++ b/docker-compose.prod.yml
@@ -1,9 +1,14 @@
 # Production Docker Compose configuration
 # Usage: docker compose -f docker-compose.prod.yml up -d
 #
 # Caddy (reverse proxy on ports 80/443) is OPTIONAL and behind the "caddy" profile:
 # - With Caddy (self-hosted, you manage SSL): docker compose -f docker-compose.prod.yml --profile caddy up -d
 # - Without Caddy (Coolify/Traefik/nginx already on 80/443): docker compose -f docker-compose.prod.yml up -d
 #   Then point your proxy at web:3000 (frontend) and server:1250 (API).
 #
 # Prerequisites:
 # 1. Copy .env.example to .env and configure for both server/ and www/
-# 2. Copy Caddyfile.example to Caddyfile and edit with your domains
+# 2. If using Caddy: copy Caddyfile.example to Caddyfile and edit your domains
 # 3. Deploy Modal GPU functions (see gpu/modal_deployments/deploy-all.sh)
 services:
@@ -84,6 +89,8 @@ services:
      retries: 3
  caddy:
    profiles:
      - caddy
    image: caddy:2-alpine
    restart: unless-stopped
    ports:
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -34,7 +34,7 @@ services:
    environment:
      ENTRYPOINT: beat
-  hatchet-worker:
+  hatchet-worker-cpu:
    build:
      context: server
    volumes:
@@ -43,7 +43,20 @@ services:
    env_file:
      - ./server/.env
    environment:
-      ENTRYPOINT: hatchet-worker
+      ENTRYPOINT: hatchet-worker-cpu
    depends_on:
      hatchet:
        condition: service_healthy
  hatchet-worker-llm:
    build:
      context: server
    volumes:
      - ./server/:/app/
      - /app/.venv
    env_file:
      - ./server/.env
    environment:
      ENTRYPOINT: hatchet-worker-llm
    depends_on:
      hatchet:
        condition: service_healthy
--- a/docs/docs/installation/docker-setup.md
+++ b/docs/docs/installation/docker-setup.md
@@ -11,15 +11,15 @@ This page documents the Docker Compose configuration for Reflector. For the comp
 The `docker-compose.prod.yml` includes these services:
-| Service | Image | Purpose |
+| Service    | Image                             | Purpose                                                                     |
-|---------|-------|---------|
+| ---------- | --------------------------------- | --------------------------------------------------------------------------- |
-| `web` | `monadicalsas/reflector-frontend` | Next.js frontend |
+| `web`      | `monadicalsas/reflector-frontend` | Next.js frontend                                                            |
-| `server` | `monadicalsas/reflector-backend` | FastAPI backend |
+| `server`   | `monadicalsas/reflector-backend`  | FastAPI backend                                                             |
-| `worker` | `monadicalsas/reflector-backend` | Celery worker for background tasks |
+| `worker`   | `monadicalsas/reflector-backend`  | Celery worker for background tasks                                          |
-| `beat` | `monadicalsas/reflector-backend` | Celery beat scheduler |
+| `beat`     | `monadicalsas/reflector-backend`  | Celery beat scheduler                                                       |
-| `redis` | `redis:7.2-alpine` | Message broker and cache |
+| `redis`    | `redis:7.2-alpine`                | Message broker and cache                                                    |
-| `postgres` | `postgres:17-alpine` | Primary database |
+| `postgres` | `postgres:17-alpine`              | Primary database                                                            |
-| `caddy` | `caddy:2-alpine` | Reverse proxy with auto-SSL |
+| `caddy`    | `caddy:2-alpine`                  | Reverse proxy with auto-SSL (optional; see [Caddy profile](#caddy-profile)) |
 ## Environment Files
@@ -30,6 +30,7 @@ Reflector uses two separate environment files:
 Used by: `server`, `worker`, `beat`
 Key variables:
 ```env
 # Database connection
 DATABASE_URL=postgresql+asyncpg://reflector:reflector@postgres:5432/reflector
@@ -54,6 +55,7 @@ TRANSCRIPT_MODAL_API_KEY=...
 Used by: `web`
 Key variables:
 ```env
 # Domain configuration
 SITE_URL=https://app.example.com
@@ -70,26 +72,42 @@ Note: `API_URL` is used client-side (browser), `SERVER_API_URL` is used server-s
 ## Volumes
-| Volume | Purpose |
+| Volume          | Purpose                       |
-|--------|---------|
+| --------------- | ----------------------------- |
-| `redis_data` | Redis persistence |
+| `redis_data`    | Redis persistence             |
-| `postgres_data` | PostgreSQL data |
+| `postgres_data` | PostgreSQL data               |
-| `server_data` | Uploaded files, local storage |
+| `server_data`   | Uploaded files, local storage |
-| `caddy_data` | SSL certificates |
+| `caddy_data`    | SSL certificates              |
-| `caddy_config` | Caddy configuration |
+| `caddy_config`  | Caddy configuration           |
 ## Network
 All services share the default network. The network is marked `attachable: true` to allow external containers (like Authentik) to join.
 ## Caddy profile
 Caddy (ports 80 and 443) is **optional** and behind the `caddy` profile so it does not conflict with an existing reverse proxy (e.g. Coolify, Traefik, nginx).
 - **With Caddy** (you want Reflector to handle SSL):
  `docker compose -f docker-compose.prod.yml --profile caddy up -d`
 - **Without Caddy** (Coolify or another proxy already on 80/443):
  `docker compose -f docker-compose.prod.yml up -d`
  Then configure your proxy to send traffic to `web:3000` (frontend) and `server:1250` (API).
 ## Common Commands
 ### Start all services
 ```bash
 # Without Caddy (e.g. when using Coolify)
 docker compose -f docker-compose.prod.yml up -d
 # With Caddy as reverse proxy
 docker compose -f docker-compose.prod.yml --profile caddy up -d
 ```
 ### View logs
 ```bash
 # All services
 docker compose -f docker-compose.prod.yml logs -f
@@ -99,6 +117,7 @@ docker compose -f docker-compose.prod.yml logs server --tail 50
 ```
 ### Restart a service
 ```bash
 # Quick restart (doesn't reload .env changes)
 docker compose -f docker-compose.prod.yml restart server
@@ -108,27 +127,32 @@ docker compose -f docker-compose.prod.yml up -d server
 ```
 ### Run database migrations
 ```bash
 docker compose -f docker-compose.prod.yml exec server uv run alembic upgrade head
 ```
 ### Access database
 ```bash
 docker compose -f docker-compose.prod.yml exec postgres psql -U reflector
 ```
 ### Pull latest images
 ```bash
 docker compose -f docker-compose.prod.yml pull
 docker compose -f docker-compose.prod.yml up -d
 ```
 ### Stop all services
 ```bash
 docker compose -f docker-compose.prod.yml down
 ```
 ### Full reset (WARNING: deletes data)
 ```bash
 docker compose -f docker-compose.prod.yml down -v
 ```
@@ -187,6 +211,7 @@ The Caddyfile supports environment variable substitution:
 Set `FRONTEND_DOMAIN` and `API_DOMAIN` environment variables, or edit the file directly.
 ### Reload Caddy after changes
 ```bash
 docker compose -f docker-compose.prod.yml exec caddy caddy reload --config /etc/caddy/Caddyfile
 ```
--- a/docs/docs/installation/overview.md
+++ b/docs/docs/installation/overview.md
@@ -26,7 +26,7 @@ flowchart LR
 Before starting, you need:
- **Production server** -  4+ cores, 8GB+ RAM, public IP
+- **Production server** - 4+ cores, 8GB+ RAM, public IP
 - **Two domain names** - e.g., `app.example.com` (frontend) and `api.example.com` (backend)
 - **GPU processing** - Choose one:
  - Modal.com account, OR
@@ -60,16 +60,17 @@ Type: A    Name: api    Value: <your-server-ip>
 Reflector requires GPU processing for transcription and speaker diarization. Choose one option:
-| | **Modal.com (Cloud)** | **Self-Hosted GPU** |
+|              | **Modal.com (Cloud)**             | **Self-Hosted GPU**          |
-|---|---|---|
+| ------------ | --------------------------------- | ---------------------------- |
 | **Best for** | No GPU hardware, zero maintenance | Own GPU server, full control |
-| **Pricing** | Pay-per-use | Fixed infrastructure cost |
+| **Pricing**  | Pay-per-use                       | Fixed infrastructure cost    |
 ### Option A: Modal.com (Serverless Cloud GPU)
 #### Accept HuggingFace Licenses
 Visit both pages and click "Accept":
 - https://huggingface.co/pyannote/speaker-diarization-3.1
 - https://huggingface.co/pyannote/segmentation-3.0
@@ -179,6 +180,7 @@ Save these credentials - you'll need them in the next step.
 ## Configure Environment
 Reflector has two env files:
 - `server/.env` - Backend configuration
 - `www/.env` - Frontend configuration
@@ -190,6 +192,7 @@ nano server/.env
 ```
 **Required settings:**
 ```env
 # Database (defaults work with docker-compose.prod.yml)
 DATABASE_URL=postgresql+asyncpg://reflector:reflector@postgres:5432/reflector
@@ -249,6 +252,7 @@ nano www/.env
 ```
 **Required settings:**
 ```env
 # Your domains
 SITE_URL=https://app.example.com
@@ -266,7 +270,11 @@ FEATURE_REQUIRE_LOGIN=false
 ---
-## Configure Caddy
+## Reverse proxy (Caddy or existing)
 **If Coolify, Traefik, or nginx already use ports 80/443** (e.g. Coolify on your host): skip Caddy. Start the stack without the Caddy profile (see [Start Services](#start-services) below), then point your proxy at `web:3000` (frontend) and `server:1250` (API).
 **If you want Reflector to provide the reverse proxy and SSL:**
 ```bash
 cp Caddyfile.example Caddyfile
@@ -289,10 +297,18 @@ Replace `example.com` with your domains. The `{$VAR:default}` syntax uses Caddy'
 ## Start Services
 **Without Caddy** (e.g. Coolify already on 80/443):
 ```bash
 docker compose -f docker-compose.prod.yml up -d
 ```
 **With Caddy** (Reflector handles SSL):
 ```bash
 docker compose -f docker-compose.prod.yml --profile caddy up -d
 ```
 Wait for containers to start (first run may take 1-2 minutes to pull images and initialize).
 ---
@@ -300,18 +316,21 @@ Wait for containers to start (first run may take 1-2 minutes to pull images and
 ## Verify Deployment
 ### Check services
 ```bash
 docker compose -f docker-compose.prod.yml ps
 # All should show "Up"
 ```
 ### Test API
 ```bash
 curl https://api.example.com/health
 # Should return: {"status":"healthy"}
 ```
 ### Test Frontend
 - Visit https://app.example.com
 - You should see the Reflector interface
 - Try uploading an audio file to test transcription
@@ -327,6 +346,7 @@ By default, Reflector is open (no login required). **Authentication is required
 See [Authentication Setup](./auth-setup) for full Authentik OAuth configuration.
 Quick summary:
 1. Deploy Authentik on your server
 2. Create OAuth provider in Authentik
 3. Extract public key for JWT verification
@@ -358,6 +378,7 @@ DAILYCO_STORAGE_AWS_ROLE_ARN=<arn:aws:iam::ACCOUNT:role/DailyCo>
 ```
 Reload env and restart:
 ```bash
 docker compose -f docker-compose.prod.yml up -d server worker
 ```
@@ -367,35 +388,43 @@ docker compose -f docker-compose.prod.yml up -d server worker
 ## Troubleshooting
 ### Check logs for errors
 ```bash
 docker compose -f docker-compose.prod.yml logs server --tail 20
 docker compose -f docker-compose.prod.yml logs worker --tail 20
 ```
 ### Services won't start
 ```bash
 docker compose -f docker-compose.prod.yml logs
 ```
 ### CORS errors in browser
 - Verify `CORS_ORIGIN` in `server/.env` matches your frontend domain exactly (including `https://`)
 - Reload env: `docker compose -f docker-compose.prod.yml up -d server`
-### SSL certificate errors
+### SSL certificate errors (when using Caddy)
 - Caddy auto-provisions Let's Encrypt certificates
- Ensure ports 80 and 443 are open
+- Ensure ports 80 and 443 are open and not used by another proxy
 - Check: `docker compose -f docker-compose.prod.yml logs caddy`
 - If port 80 is already in use (e.g. by Coolify), run without Caddy: `docker compose -f docker-compose.prod.yml up -d` and use your existing proxy
 ### Transcription not working
 - Check Modal dashboard: https://modal.com/apps
 - Verify URLs in `server/.env` match deployed functions
 - Check worker logs: `docker compose -f docker-compose.prod.yml logs worker`
 ### "Login required" but auth not configured
 - Set `FEATURE_REQUIRE_LOGIN=false` in `www/.env`
 - Rebuild frontend: `docker compose -f docker-compose.prod.yml up -d --force-recreate web`
 ### Database migrations or connectivity issues
 Migrations run automatically on server startup. To check database connectivity or debug migration failures:
 ```bash
@@ -408,4 +437,3 @@ docker compose -f docker-compose.prod.yml exec server uv run python -c "from ref
 # Manually run migrations (if needed)
 docker compose -f docker-compose.prod.yml exec server uv run alembic upgrade head
 ```
--- a/gpu/modal_deployments/deploy-all.sh
+++ b/gpu/modal_deployments/deploy-all.sh
@@ -131,6 +131,15 @@ if [ -z "$DIARIZER_URL" ]; then
 fi
 echo "  -> $DIARIZER_URL"
 echo ""
 echo "Deploying padding (CPU audio processing via Modal SDK)..."
 modal deploy reflector_padding.py
 if [ $? -ne 0 ]; then
    echo "Error: Failed to deploy padding. Check Modal dashboard for details."
    exit 1
 fi
 echo "  -> reflector-padding.pad_track (Modal SDK function)"
 # --- Output Configuration ---
 echo ""
 echo "=========================================="
@@ -147,4 +156,6 @@ echo ""
 echo "DIARIZATION_BACKEND=modal"
 echo "DIARIZATION_URL=$DIARIZER_URL"
 echo "DIARIZATION_MODAL_API_KEY=$API_KEY"
 echo ""
 echo "# Padding uses Modal SDK (requires MODAL_TOKEN_ID/SECRET in worker containers)"
 echo "# --- End Modal Configuration ---"
--- a/gpu/modal_deployments/reflector_padding.py
+++ b/gpu/modal_deployments/reflector_padding.py
@@ -0,0 +1,277 @@
 """
 Reflector GPU backend - audio padding
 ======================================
 CPU-intensive audio padding service for adding silence to audio tracks.
 Uses PyAV filter graph (adelay) for precise track synchronization.
 IMPORTANT: This padding logic is duplicated from server/reflector/utils/audio_padding.py
 for Modal deployment isolation (Modal can't import from server/reflector/). If you modify
 the PyAV filter graph or padding algorithm, you MUST update both:
  - gpu/modal_deployments/reflector_padding.py (this file)
  - server/reflector/utils/audio_padding.py
 Constants duplicated from server/reflector/utils/audio_constants.py for same reason.
 """
 import os
 import tempfile
 from fractions import Fraction
 import math
 import asyncio
 import modal
 S3_TIMEOUT = 60 # happens 2 times
 PADDING_TIMEOUT = 600 + (S3_TIMEOUT * 2)
 SCALEDOWN_WINDOW = 60  # The maximum duration (in seconds) that individual containers can remain idle when scaling down.
 DISCONNECT_CHECK_INTERVAL = 2  # Check for client disconnect
 app = modal.App("reflector-padding")
 # CPU-based image
 image = (
    modal.Image.debian_slim(python_version="3.12")
    .apt_install("ffmpeg")  # Required by PyAV
    .pip_install(
        "av==13.1.0",  # PyAV for audio processing
        "requests==2.32.3",  # HTTP for presigned URL downloads/uploads
        "fastapi==0.115.12",  # API framework
    )
 )
 # ref B0F71CE8-FC59-4AA5-8414-DAFB836DB711
 OPUS_STANDARD_SAMPLE_RATE = 48000
 # ref B0F71CE8-FC59-4AA5-8414-DAFB836DB711
 OPUS_DEFAULT_BIT_RATE = 128000
@app.function(
    cpu=2.0,
    timeout=PADDING_TIMEOUT,
    scaledown_window=SCALEDOWN_WINDOW,
    image=image,
 )
@modal.asgi_app()
 def web():
    from fastapi import FastAPI, Request, HTTPException
    from pydantic import BaseModel
    class PaddingRequest(BaseModel):
        track_url: str
        output_url: str
        start_time_seconds: float
        track_index: int
    class PaddingResponse(BaseModel):
        size: int
        cancelled: bool = False
    web_app = FastAPI()
    @web_app.post("/pad")
    async def pad_track_endpoint(request: Request, req: PaddingRequest) -> PaddingResponse:
        """Modal web endpoint for padding audio tracks with disconnect detection.
        """
        import logging
        logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
        logger = logging.getLogger(__name__)
        if not req.track_url:
            raise HTTPException(status_code=400, detail="track_url cannot be empty")
        if not req.output_url:
            raise HTTPException(status_code=400, detail="output_url cannot be empty")
        if req.start_time_seconds <= 0:
            raise HTTPException(status_code=400, detail=f"start_time_seconds must be positive, got {req.start_time_seconds}")
        if req.start_time_seconds > 18000:
            raise HTTPException(status_code=400, detail=f"start_time_seconds exceeds maximum 18000s (5 hours)")
        logger.info(f"Padding request: track {req.track_index}, delay={req.start_time_seconds}s")
        # Thread-safe cancellation flag shared between async disconnect checker and blocking thread
        import threading
        cancelled = threading.Event()
        async def check_disconnect():
            """Background task to check for client disconnect every 2 seconds."""
            while not cancelled.is_set():
                await asyncio.sleep(DISCONNECT_CHECK_INTERVAL)
                if await request.is_disconnected():
                    logger.warning("Client disconnected, setting cancellation flag")
                    cancelled.set()
                    break
        # Start disconnect checker in background
        disconnect_task = asyncio.create_task(check_disconnect())
        try:
            result = await asyncio.get_event_loop().run_in_executor(
                None, _pad_track_blocking, req, cancelled, logger
            )
            return PaddingResponse(**result)
        finally:
            cancelled.set()
            disconnect_task.cancel()
            try:
                await disconnect_task
            except asyncio.CancelledError:
                pass
    def _pad_track_blocking(req, cancelled, logger) -> dict:
        """Blocking CPU-bound padding work with periodic cancellation checks.
        Args:
            cancelled: threading.Event for thread-safe cancellation signaling
        """
        import av
        import requests
        from av.audio.resampler import AudioResampler
        import time
        temp_dir = tempfile.mkdtemp()
        input_path = None
        output_path = None
        last_check = time.time()
        try:
            logger.info("Downloading track for padding")
            response = requests.get(req.track_url, stream=True, timeout=S3_TIMEOUT)
            response.raise_for_status()
            input_path = os.path.join(temp_dir, "track.webm")
            total_bytes = 0
            chunk_count = 0
            with open(input_path, "wb") as f:
                for chunk in response.iter_content(chunk_size=8192):
                    if chunk:
                        f.write(chunk)
                        total_bytes += len(chunk)
                        chunk_count += 1
                        # Check for cancellation every arbitrary amount of chunks
                        if chunk_count % 12 == 0:
                            now = time.time()
                            if now - last_check >= DISCONNECT_CHECK_INTERVAL:
                                if cancelled.is_set():
                                    logger.info("Cancelled during download, exiting early")
                                    return {"size": 0, "cancelled": True}
                                last_check = now
            logger.info(f"Track downloaded: {total_bytes} bytes")
            if cancelled.is_set():
                logger.info("Cancelled after download, exiting early")
                return {"size": 0, "cancelled": True}
            # Apply padding using PyAV
            output_path = os.path.join(temp_dir, "padded.webm")
            delay_ms = math.floor(req.start_time_seconds * 1000)
            logger.info(f"Padding track {req.track_index} with {delay_ms}ms delay using PyAV")
            in_container = av.open(input_path)
            in_stream = next((s for s in in_container.streams if s.type == "audio"), None)
            if in_stream is None:
                raise ValueError("No audio stream in input")
            with av.open(output_path, "w", format="webm") as out_container:
                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")
                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
                )
                for frame in in_container.decode(in_stream):
                    # Check for cancellation periodically
                    now = time.time()
                    if now - last_check >= DISCONNECT_CHECK_INTERVAL:
                        if cancelled.is_set():
                            logger.info("Cancelled during processing, exiting early")
                            in_container.close()
                            return {"size": 0, "cancelled": True}
                        last_check = now
                    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)
                # Flush filter graph
                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)
                # Flush encoder
                for packet in out_stream.encode(None):
                    out_container.mux(packet)
            in_container.close()
            file_size = os.path.getsize(output_path)
            logger.info(f"Padding complete: {file_size} bytes")
            logger.info("Uploading padded track to S3")
            with open(output_path, "rb") as f:
                upload_response = requests.put(req.output_url, data=f, timeout=S3_TIMEOUT)
            upload_response.raise_for_status()
            logger.info(f"Upload complete: {file_size} bytes")
            return {"size": file_size}
        finally:
            if input_path and os.path.exists(input_path):
                try:
                    os.unlink(input_path)
                except Exception as e:
                    logger.warning(f"Failed to cleanup input file: {e}")
            if output_path and os.path.exists(output_path):
                try:
                    os.unlink(output_path)
                except Exception as e:
                    logger.warning(f"Failed to cleanup output file: {e}")
            try:
                os.rmdir(temp_dir)
            except Exception as e:
                logger.warning(f"Failed to cleanup temp directory: {e}")
    return web_app
--- a/server/docs/DAILY_REFLECTOR_DATA_MODEL.md
+++ b/server/docs/DAILY_REFLECTOR_DATA_MODEL.md
@@ -0,0 +1,496 @@
 # Daily.co and Reflector Data Model
 This document explains the data model relationships between Daily.co's API concepts and Reflector's database schema, clarifying common sources of confusion.
 ---
 ## Table of Contents
 1. [Core Entities Overview](#core-entities-overview)
 2. [Daily.co vs Reflector Terminology](#dailyco-vs-reflector-terminology)
 3. [Entity Relationships](#entity-relationships)
 4. [Recording Multiplicity](#recording-multiplicity)
 5. [Session Identifiers Explained](#session-identifiers-explained)
 6. [Time-Based Matching](#time-based-matching)
 7. [Multitrack Recording Details](#multitrack-recording-details)
 8. [Verified Example](#verified-example)
 ---
 ## Core Entities Overview
 ### Reflector's Four Primary Entities
 ```
 ┌─────────────────────────────────────────────────────────────────┐
 │ Room (Reflector)                                                │
 │ - Persistent meeting template                                   │
 │ - User-created configuration                                    │
 │ - Example: "team-standup"                                       │
 └────────────────────┬────────────────────────────────────────────┘
                     │ 1:N
                     ▼
 ┌─────────────────────────────────────────────────────────────────┐
 │ Meeting (Reflector)                                             │
 │ - Single session instance                                       │
 │ - Creates NEW Daily.co room with timestamp                      │
 │ - Example: "team-standup-20260115120000"                        │
 └────────────────────┬────────────────────────────────────────────┘
                     │ 1:N
                     ▼
 ┌─────────────────────────────────────────────────────────────────┐
 │ Recording (Reflector + Daily.co)                                │
 │ - One segment of audio/video                                    │
 │ - New recording created on stop/restart                         │
 │ - track_keys: JSON array of S3 file paths                       │
 └────────────────────┬────────────────────────────────────────────┘
                     │ 1:1
                     ▼
 ┌─────────────────────────────────────────────────────────────────┐
 │ Transcript (Reflector)                                          │
 │ - Processed audio with transcription                            │
 │ - Diarization, summaries, topics                                │
 │ - One transcript per recording                                  │
 └─────────────────────────────────────────────────────────────────┘
 ```
 ---
 ## Daily.co vs Reflector Terminology
 ### Room
 | Aspect | Daily.co | Reflector |
 |--------|----------|-----------|
 | **Definition** | Virtual meeting space on Daily.co platform | User-created meeting template/configuration |
 | **Lifetime** | Configurable expiration | Persistent until user deletes |
 | **Creation** | API call for each meeting | Pre-created by user once |
 | **Reuse** | Can host multiple sessions | Generates new Daily.co room per meeting |
 | **Name Format** | `room-name` (reusable) | `room-name` (base identifier) |
 | **Timestamping** | Not required | Meeting adds timestamp: `{name}-YYYYMMDDHHMMSS` |
 **Example:**
 ```
 Reflector Room: "daily-private-igor" (persistent config)
    ↓ starts meeting
 Daily.co Room: "daily-private-igor-20260110042117"
 ```
 ### Meeting
 | Aspect | Daily.co | Reflector |
 |--------|----------|-----------|
 | **Definition** | Session that starts when first participant joins | Explicit database record of a session |
 | **Identifier** | `mtgSessionId` (generated by Daily.co) | `meeting.id` (UUID, generated by Reflector) |
 | **Creation** | Implicit (first participant join) | Explicit API call before participants join |
 | **Purpose** | Tracks active session state | Links recordings, transcripts, participants |
 | **Scope** | Per room instance | Per Reflector room + timestamp |
 **Critical Limitation:** Daily.co's recordings API often does NOT return `mtgSessionId`, requiring time-based matching (see [Time-Based Matching](#time-based-matching)).
 ### Recording
 | Aspect | Daily.co | Reflector |
 |--------|----------|-----------|
 | **Definition** | Audio/video files on S3 | Metadata + processing status |
 | **Types** | `cloud` (composed video), `raw-tracks` (multitrack) | Stores references + `track_keys` array |
 | **Multiplicity** | One recording object per start/stop cycle | One DB row per Daily.co recording object |
 | **Identifier** | Daily.co `recording_id` | Same `recording_id` (stored in DB) |
 | **Multitrack** | Array of `.webm` files (one per participant) | `track_keys` JSON array with S3 paths |
 | **Linkage** | Via `room_name` + `start_ts` | FK `meeting_id` (set via time-based match) |
 **Critical Behavior:** Recording **stops/restarts** create **separate recording objects** with unique IDs.
 ---
 ## Entity Relationships
 ### Database Schema Relationships
 ```sql
 -- Simplified schema showing key relationships
 TABLE room (
    id VARCHAR PRIMARY KEY,
    name VARCHAR UNIQUE,
    platform VARCHAR  -- 'whereby' | 'daily'
 )
 TABLE meeting (
    id VARCHAR PRIMARY KEY,
    room_id VARCHAR REFERENCES room(id) ON DELETE CASCADE,  -- nullable
    room_name VARCHAR,  -- Daily.co room name (timestamped)
    start_date TIMESTAMP,
    platform VARCHAR
 )
 TABLE recording (
    id VARCHAR PRIMARY KEY,  -- Daily.co recording_id
    meeting_id VARCHAR,      -- FK to meeting (set via time-based match)
    bucket_name VARCHAR,
    object_key VARCHAR,      -- S3 prefix
    track_keys JSON,         -- Array of S3 keys for multitrack
    recorded_at TIMESTAMP
 )
 TABLE transcript (
    id VARCHAR PRIMARY KEY,
    recording_id VARCHAR,    -- nullable FK
    meeting_id VARCHAR,      -- nullable FK
    room_id VARCHAR,         -- nullable FK
    participants JSON,       -- [{id, speaker, name, user_id}, ...]
    title VARCHAR,
    long_summary VARCHAR,
    webvtt TEXT
 )
 ```
 **Relationship Cardinalities:**
 ```
 1 Room → N Meetings
 1 Meeting → N Recordings (common: 1-21 recordings per meeting)
 1 Recording → 1 Transcript
 1 Meeting → N Transcripts (via recordings)
 ```
 ---
 ## Recording Multiplicity
 ### Why Multiple Recordings Per Meeting?
 Daily.co creates a **new recording object** (new ID, new files) whenever recording stops and restarts. This happens due to:
 1. **Manual stop/start** - User clicks stop, then start recording again
 2. **Network reconnection** - Participant drops, reconnects → triggers restart
 3. **Participant rejoin** - Last participant leaves, new one joins → new session
 ---
 ## Session Identifiers Explained
 ### The Hidden Entity: Daily.co Meeting Session
 Daily.co has an **implicit ephemeral entity** that sits between Room and Recording:
 ```
 Daily.co Room: "daily-private-igor-20260110042117"
    │
    ├─ Daily.co Meeting Session #1 (mtgSessionId: c04334de...)
    │   └─ Recording #3 (f4a50f94) - 4s, 1 track
    │
    └─ Daily.co Meeting Session #2 (mtgSessionId: 4cdae3c0...)
        ├─ Recording #2 (b0fa94da) - 80s, 2 tracks  ← recording stopped
        └─ Recording #1 (05edf519) - 62s, 1 track   ← then restarted
 ```
 **Daily.co Meeting Session:**
 - **Lifecycle:** Starts when first participant joins, ends when last participant leaves
 - **Identifier:** `mtgSessionId` (generated by Daily.co)
 - **Persistence:** Ephemeral - new ID if everyone leaves and someone rejoins
 - **Relationship:** 1 Session → N Recordings (if recording stops/restarts during session)
 **Key Insight:** Multiple recordings can share the same `mtgSessionId` if recording was stopped and restarted while participants remained connected.
 ### mtgSessionId (Meeting Session Identifier)
 `mtgSessionId` identifies a **Daily.co meeting session** (not individual participants, not a room).
 ### session_id (Per-Participant)
 **Different concept:** Per-participant connection identifier from webhooks.
 **Reflector Tracking:** `daily_participant_session` table
 ```sql
 TABLE daily_participant_session (
    id VARCHAR PRIMARY KEY,        -- {meeting_id}:{user_id}:{joined_at_ms}
    meeting_id VARCHAR,
    session_id VARCHAR,            -- From webhook (per-participant)
    user_id VARCHAR,
    user_name VARCHAR,
    joined_at TIMESTAMP,
    left_at TIMESTAMP
 )
 ```
 ---
 ## Time-Based Matching
 ### Problem Statement
 Daily.co's recordings API does not reliably return `mtgSessionId`, making it impossible to directly link recordings to meetings via Daily.co's identifiers.
 **Example API response:**
 ```json
 {
  "id": "recording-uuid",
  "room_name": "daily-private-igor-20260110042117",
  "start_ts": 1768018896,
  "mtgSessionId": null  ← Missing!
 }
 ```
 ### Solution: Time-Based Matching
 **Implementation:** `reflector/db/meetings.py:get_by_room_name_and_time()`
 ---
 ## Multitrack Recording Details
 ### track_keys JSON Array
 **Schema:** `recording.track_keys` (JSON, nullable)
 ```sql
 -- Example recording with 2 audio tracks
 {
  "id": "b0fa94da-73b5-4f95-9239-5216a682a505",
  "track_keys": [
    "igormonadical/daily-private-igor-20260110042117/1768018896877-890c0eae-e186-4534-a7bd-7c794b7d6d7f-cam-audio-1768018914565",
    "igormonadical/daily-private-igor-20260110042117/1768018896877-9660e8e9-4297-4f17-951d-0b2bf2401803-cam-audio-1768018899286"
  ]
 }
 ```
 **Semantics:**
 - `track_keys = null` → Not multitrack (cloud recording)
 - `track_keys = []` → Multitrack recording with no audio captured (silence/muted)
 - `track_keys = [...]` → Multitrack with N audio tracks
 **Property:** `recording.is_multitrack` (Python)
 ```python
@property
 def is_multitrack(self) -> bool:
    return self.track_keys is not None and len(self.track_keys) > 0
 ```
 ### Track Filename Format
 Daily.co multitrack filenames encode timing and participant information:
 **Format:** `{recording_start_ts}-{participant_id}-cam-audio-{track_start_ts}`
 **Example:** `1768018896877-890c0eae-e186-4534-a7bd-7c794b7d6d7f-cam-audio-1768018914565`
 **Parsed Components:**
 ```python
 # reflector/utils/daily.py:25-60
 class DailyRecordingFilename(NamedTuple):
    recording_start_ts: int  # 1768018896877 (milliseconds)
    participant_id: str      # 890c0eae-e186-4534-a7bd-7c794b7d6d7f
    track_start_ts: int      # 1768018914565 (milliseconds)
 ```
 **Note:** Browser downloads from S3 add `.webm` extension due to MIME headers, but S3 object keys have no extension.
 ### Video Track Filtering
 Daily.co API returns both audio and video tracks, but Reflector only processes audio.
 **Filtering Logic:** `reflector/worker/process.py:660`
 ```python
 track_keys = [t.s3Key for t in recording.tracks if t.type == "audio"]
 ```
 **Example API Response:**
 ```json
 {
  "tracks": [
    {"type": "audio", "s3Key": "...cam-audio-1768018914565"},
    {"type": "audio", "s3Key": "...cam-audio-1768018899286"},
    {"type": "video", "s3Key": "...cam-video-1768018897095"}  ← Filtered out
  ]
 }
 ```
 **Result:** Only 2 audio tracks stored in `recording.track_keys`, video track discarded.
 **Rationale:** Reflector is audio transcription system; video not needed for processing.
 ### Track-to-Participant Mapping
 **Flow:**
 1. Daily.co webhook/polling provides `track_keys` array
 2. Each track filename contains `participant_id`
 3. Reflector queries Daily.co API: `GET /meetings/{mtgSessionId}/participants`
 4. Maps `participant_id` → `user_name`
 5. Stores in `transcript.participants` JSON:
 ```json
 [
  {
    "id": "890c0eae-e186-4534-a7bd-7c794b7d6d7f",
    "speaker": 0,
    "name": "test2",
    "user_id": "907f2cc1-eaab-435f-8ee2-09185f416b22"
  },
  {
    "id": "9660e8e9-4297-4f17-951d-0b2bf2401803",
    "speaker": 1,
    "name": "test",
    "user_id": "907f2cc1-eaab-435f-8ee2-09185f416b22"
  }
 ]
 ```
 **Diarization:** Multitrack recordings don't need speaker diarization AI — speaker identity comes from separate audio tracks.
 ---
 ## Example
 ### Meeting: daily-private-igor-20260110042117
 **Context:** User conducted test recording with start/stop cycles, producing 3 recordings.
 #### Database State
 ```sql
 -- Meeting
 id: 034804b8-cee2-4fb4-94d7-122f6f068a61
 room_name: daily-private-igor-20260110042117
 start_date: 2026-01-10 04:21:17+00
 ```
 #### Daily.co API Response
 ```json
 [
  {
    "id": "f4a50f94-053c-4f9d-bda6-78ad051fbc36",
    "room_name": "daily-private-igor-20260110042117",
    "start_ts": 1768018885,
    "duration": 4,
    "status": "finished",
    "mtgSessionId": "c04334de-42a0-4c2a-96be-a49b068dca85",
    "tracks": [
      {"type": "audio", "s3Key": "...62e8f3ae...cam-audio-1768018885417"}
    ]
  },
  {
    "id": "b0fa94da-73b5-4f95-9239-5216a682a505",
    "room_name": "daily-private-igor-20260110042117",
    "start_ts": 1768018896,
    "duration": 80,
    "status": "finished",
    "mtgSessionId": "4cdae3c0-86cb-4578-8a6d-3a228bb48345",
    "tracks": [
      {"type": "audio", "s3Key": "...890c0eae...cam-audio-1768018914565"},
      {"type": "audio", "s3Key": "...9660e8e9...cam-audio-1768018899286"},
      {"type": "video", "s3Key": "...9660e8e9...cam-video-1768018897095"}
    ]
  },
  {
    "id": "05edf519-9048-4b49-9a75-73e9826fd950",
    "room_name": "daily-private-igor-20260110042117",
    "start_ts": 1768018914,
    "duration": 62,
    "status": "finished",
    "mtgSessionId": "4cdae3c0-86cb-4578-8a6d-3a228bb48345",
    "tracks": [
      {"type": "audio", "s3Key": "...890c0eae...cam-audio-1768018914948"}
    ]
  }
 ]
 ```
 **Key Observations:**
 - 3 recording objects returned by Daily.co
 - 2 different `mtgSessionId` values (2 different meeting instances)
 - Recording #2 has 3 tracks (2 audio + 1 video)
 - Timestamps: 1768018885 → 1768018896 (+11s) → 1768018914 (+18s)
 #### Reflector Database
 **Recordings:**
 ```
 ┌──────────────────────────────────────┬──────────────┬────────────┬──────────────────────────────────────┐
 │ id                                   │ track_count  │ duration   │ mtgSessionId                         │
 ├──────────────────────────────────────┼──────────────┼────────────┼──────────────────────────────────────┤
 │ f4a50f94-053c-4f9d-bda6-78ad051fbc36 │ 1            │ 4s         │ c04334de-42a0-4c2a-96be-a49b068dca85 │
 │ b0fa94da-73b5-4f95-9239-5216a682a505 │ 2 (video=0)  │ 80s        │ 4cdae3c0-86cb-4578-8a6d-3a228bb48345 │
 │ 05edf519-9048-4b49-9a75-73e9826fd950 │ 1            │ 62s        │ 4cdae3c0-86cb-4578-8a6d-3a228bb48345 │
 └──────────────────────────────────────┴──────────────┴────────────┴──────────────────────────────────────┘
 ```
 **Note:** Recording #2 has 2 audio tracks (video filtered out), not 3.
 **Transcripts:**
 ```
 ┌──────────────────────────────────────┬──────────────────────────────────────┬──────────────┬──────────────────────────────────────────────┐
 │ id                                   │ recording_id                         │ participants │ title                                        │
 ├──────────────────────────────────────┼──────────────────────────────────────┼──────────────┼──────────────────────────────────────────────┤
 │ 17149b1f-546c-4837-80a0-f8140bd16592 │ f4a50f94-053c-4f9d-bda6-78ad051fbc36 │ 1 (test)     │ (empty - no speech)                          │
 │ 49801332-3222-4c11-bdb2-375479fc87f2 │ b0fa94da-73b5-4f95-9239-5216a682a505 │ 2 (test,     │ "Examination and Validation Procedures       │
 │                                      │                                      │   test2)     │  Review"                                     │
 │ e5271e12-20fb-42d2-b5a8-21438abadef9 │ 05edf519-9048-4b49-9a75-73e9826fd950 │ 1 (test2)    │ "Technical Sound Check Procedure Review"     │
 └──────────────────────────────────────┴──────────────────────────────────────┴──────────────┴──────────────────────────────────────────────┘
 ```
 **Transcript Content:**
 *Transcript #1* (17149b1f): Empty WebVTT (no audio captured)
 *Transcript #2* (49801332):
 ```webvtt
 WEBVTT
 00:00:03.109 --> 00:00:05.589
 <v Speaker1>Test, test, test. Test, test, test, test, test.
 00:00:19.829 --> 00:00:22.710
 <v Speaker0>Test test test test test test test test test test test.
 ```
 **AI-Generated Summary:**
 > "The meeting focused on the critical importance of rigorous testing for ensuring reliability and quality, with test and test2 emphasizing the need for a structured testing framework and meticulous documentation..."
 *Transcript #3* (e5271e12):
 ```webvtt
 WEBVTT
 00:00:02.029 --> 00:00:04.910
 <v Speaker0>Test, test, test, test, test, test, test, test, test, test, test.
 ```
 #### Validation: track_keys → participants
 **Recording #2 (b0fa94da) tracks:**
 ```json
 [
  ".../890c0eae-e186-4534-a7bd-7c794b7d6d7f-cam-audio-...",
  ".../9660e8e9-4297-4f17-951d-0b2bf2401803-cam-audio-..."
 ]
 ```
 **Transcript #2 (49801332) participants:**
 ```json
 [
  {"id": "890c0eae-e186-4534-a7bd-7c794b7d6d7f", "speaker": 0, "name": "test2"},
  {"id": "9660e8e9-4297-4f17-951d-0b2bf2401803", "speaker": 1, "name": "test"}
 ]
 ```
 ### Data Flow
 ```
 Daily.co API: 3 recordings
    ↓
 Polling: _poll_raw_tracks_recordings()
    ↓
 Worker: process_multitrack_recording.delay() × 3
    ↓
 DB: 3 recording rows created
    ↓
 Pipeline: Audio processing + transcription × 3
    ↓
 DB: 3 transcript rows created (1:1 with recordings)
    ↓
 UI: User sees 3 separate transcripts
 ```
 **Result:** ✅ 1:1 Recording → Transcript relationship maintained.
 ---
 **Document Version:** 1.0
 **Last Verified:** 2026-01-15
 **Data Source:** Production database + Daily.co API inspection
--- a/server/migrations/versions/1b1e6a6fc465_add_cloud_recording_support.py
+++ b/server/migrations/versions/1b1e6a6fc465_add_cloud_recording_support.py
@@ -0,0 +1,40 @@
 """add cloud recording support
 Revision ID: 1b1e6a6fc465
 Revises: bd3a729bb379
 Create Date: 2026-01-09 17:17:33.535620
 """
 from typing import Sequence, Union
 import sqlalchemy as sa
 from alembic import op
 # revision identifiers, used by Alembic.
 revision: str = "1b1e6a6fc465"
 down_revision: Union[str, None] = "bd3a729bb379"
 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("daily_composed_video_s3_key", sa.String(), nullable=True)
        )
        batch_op.add_column(
            sa.Column("daily_composed_video_duration", sa.Integer(), nullable=True)
        )
    # ### end Alembic commands ###
 def downgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
    with op.batch_alter_table("meeting", schema=None) as batch_op:
        batch_op.drop_column("daily_composed_video_duration")
        batch_op.drop_column("daily_composed_video_s3_key")
    # ### end Alembic commands ###
--- a/server/migrations/versions/80beb1ea3269_replace_use_hatchet_with_use_celery.py
+++ b/server/migrations/versions/80beb1ea3269_replace_use_hatchet_with_use_celery.py
@@ -0,0 +1,44 @@
 """replace_use_hatchet_with_use_celery
 Revision ID: 80beb1ea3269
 Revises: bd3a729bb379
 Create Date: 2026-01-20 16:26:25.555869
 """
 from typing import Sequence, Union
 import sqlalchemy as sa
 from alembic import op
 # revision identifiers, used by Alembic.
 revision: str = "80beb1ea3269"
 down_revision: Union[str, None] = "bd3a729bb379"
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 def upgrade() -> None:
    with op.batch_alter_table("room", schema=None) as batch_op:
        batch_op.add_column(
            sa.Column(
                "use_celery",
                sa.Boolean(),
                server_default=sa.text("false"),
                nullable=False,
            )
        )
        batch_op.drop_column("use_hatchet")
 def downgrade() -> None:
    with op.batch_alter_table("room", schema=None) as batch_op:
        batch_op.add_column(
            sa.Column(
                "use_hatchet",
                sa.Boolean(),
                server_default=sa.text("false"),
                nullable=False,
            )
        )
        batch_op.drop_column("use_celery")
--- a/server/migrations/versions/e69f08ead8ea_merge_cloud_recording_and_celery_heads.py
+++ b/server/migrations/versions/e69f08ead8ea_merge_cloud_recording_and_celery_heads.py
@@ -0,0 +1,23 @@
 """merge cloud recording and celery heads
 Revision ID: e69f08ead8ea
 Revises: 1b1e6a6fc465, 80beb1ea3269
 Create Date: 2026-01-21 21:39:10.326841
 """
 from typing import Sequence, Union
 # revision identifiers, used by Alembic.
 revision: str = "e69f08ead8ea"
 down_revision: Union[str, None] = ("1b1e6a6fc465", "80beb1ea3269")
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 def upgrade() -> None:
    pass
 def downgrade() -> None:
    pass
--- a/server/pyproject.toml
+++ b/server/pyproject.toml
@@ -8,7 +8,7 @@ readme = "README.md"
 dependencies = [
    "aiohttp>=3.9.0",
    "aiohttp-cors>=0.7.0",
-    "av>=10.0.0",
+    "av>=15.0.0",
    "requests>=2.31.0",
    "aiortc>=1.5.0",
    "sortedcontainers>=2.4.0",
--- a/server/reflector/dailyco_api/init.py
+++ b/server/reflector/dailyco_api/init.py
@@ -3,7 +3,7 @@ Daily.co API Module
 """
 # Client
-from .client import DailyApiClient, DailyApiError
+from .client import DailyApiClient, DailyApiError, RecordingType
 # Request models
 from .requests import (
@@ -64,6 +64,7 @@ __all__ = [
    # Client
    "DailyApiClient",
    "DailyApiError",
    "RecordingType",
    # Requests
    "CreateRoomRequest",
    "RoomProperties",
--- a/server/reflector/dailyco_api/client.py
+++ b/server/reflector/dailyco_api/client.py
@@ -7,7 +7,8 @@ Reference: https://docs.daily.co/reference/rest-api
 """
 from http import HTTPStatus
-from typing import Any
+from typing import Any, Literal
 from uuid import UUID
 import httpx
 import structlog
@@ -32,6 +33,8 @@ from .responses import (
 logger = structlog.get_logger(__name__)
 RecordingType = Literal["cloud", "raw-tracks"]
 class DailyApiError(Exception):
    """Daily.co API error with full request/response context."""
@@ -395,6 +398,38 @@ class DailyApiClient:
        return [RecordingResponse(**r) for r in data["data"]]
    async def start_recording(
        self,
        room_name: NonEmptyString,
        recording_type: RecordingType,
        instance_id: UUID,
    ) -> dict[str, Any]:
        """Start recording via REST API.
        Reference: https://docs.daily.co/reference/rest-api/rooms/recordings/start
        Args:
            room_name: Daily.co room name
            recording_type: Recording type
            instance_id: UUID for this recording session
        Returns:
            Recording start confirmation from Daily.co API
        Raises:
            DailyApiError: If API request fails
        """
        client = await self._get_client()
        response = await client.post(
            f"{self.base_url}/rooms/{room_name}/recordings/start",
            headers=self.headers,
            json={
                "type": recording_type,
                "instanceId": str(instance_id),
            },
        )
        return await self._handle_response(response, "start_recording")
    # ============================================================================
    # MEETING TOKENS
    # ============================================================================
--- a/server/reflector/dailyco_api/instance_id.py
+++ b/server/reflector/dailyco_api/instance_id.py
@@ -0,0 +1,37 @@
 """
 Daily.co recording instanceId generation utilities.
 Deterministic instance ID generation for cloud and raw-tracks recordings.
 MUST match frontend logic
 """
 from uuid import UUID, uuid5
 from reflector.utils.string import NonEmptyString
 # Namespace UUID for UUIDv5 generation of raw-tracks instanceIds
 # DO NOT CHANGE: Breaks instanceId determinism across deployments and frontend/backend matching
 RAW_TRACKS_NAMESPACE = UUID("a1b2c3d4-e5f6-7890-abcd-ef1234567890")
 def generate_cloud_instance_id(meeting_id: NonEmptyString) -> UUID:
    """
    Generate instanceId for cloud recording.
    Cloud recordings use meeting ID directly as instanceId.
    This ensures each meeting has one unique cloud recording.
    """
    return UUID(meeting_id)
 def generate_raw_tracks_instance_id(meeting_id: NonEmptyString) -> UUID:
    """
    Generate instanceId for raw-tracks recording.
    Raw-tracks recordings use UUIDv5(meeting_id, namespace) to ensure
    different instanceId from cloud while remaining deterministic.
    Daily.co requires cloud and raw-tracks to have different instanceIds
    for concurrent recording.
    """
    return uuid5(RAW_TRACKS_NAMESPACE, meeting_id)
--- a/server/reflector/dailyco_api/requests.py
+++ b/server/reflector/dailyco_api/requests.py
@@ -88,13 +88,6 @@ class MeetingTokenProperties(BaseModel):
    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"
    )
    start_cloud_recording_opts: dict | None = Field(
        default=None,
        description="Options for startRecording when start_cloud_recording is true (e.g., maxDuration)",
    )
    enable_recording_ui: bool = Field(
        default=True, description="Show recording controls in UI"
    )
--- a/server/reflector/dailyco_api/responses.py
+++ b/server/reflector/dailyco_api/responses.py
@@ -116,6 +116,7 @@ class RecordingS3Info(BaseModel):
    bucket_name: NonEmptyString
    bucket_region: NonEmptyString
    key: NonEmptyString | None = None
    endpoint: NonEmptyString | None = None
@@ -132,6 +133,9 @@ class RecordingResponse(BaseModel):
    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)")
    type: Literal["cloud", "raw-tracks"] | None = Field(
        None, description="Recording type (may be missing from API)"
    )
    status: RecordingStatus = Field(
        description="Recording status ('in-progress' or 'finished')"
    )
@@ -145,6 +149,9 @@ class RecordingResponse(BaseModel):
        None, description="Token for sharing recording"
    )
    s3: RecordingS3Info | None = Field(None, description="S3 bucket information")
    s3key: NonEmptyString | None = Field(
        None, description="S3 key for cloud recordings (top-level field)"
    )
    tracks: list[DailyTrack] = Field(
        default_factory=list,
        description="Track list for raw-tracks recordings (always array, never null)",
--- a/server/reflector/db/meetings.py
+++ b/server/reflector/db/meetings.py
@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timedelta
 from typing import Any, Literal
 import sqlalchemy as sa
@@ -9,7 +9,7 @@ from reflector.db import get_database, metadata
 from reflector.db.rooms import Room
 from reflector.schemas.platform import WHEREBY_PLATFORM, Platform
 from reflector.utils import generate_uuid4
-from reflector.utils.string import assert_equal
+from reflector.utils.string import NonEmptyString, assert_equal
 meetings = sa.Table(
    "meeting",
@@ -63,6 +63,9 @@ meetings = sa.Table(
        nullable=False,
        server_default=assert_equal(WHEREBY_PLATFORM, "whereby"),
    ),
    # Daily.co composed video (Brady Bunch grid layout) - Daily.co only, not Whereby
    sa.Column("daily_composed_video_s3_key", sa.String, nullable=True),
    sa.Column("daily_composed_video_duration", sa.Integer, nullable=True),
    sa.Index("idx_meeting_room_id", "room_id"),
    sa.Index("idx_meeting_calendar_event", "calendar_event_id"),
 )
@@ -110,6 +113,9 @@ class Meeting(BaseModel):
    calendar_event_id: str | None = None
    calendar_metadata: dict[str, Any] | None = None
    platform: Platform = WHEREBY_PLATFORM
    # Daily.co composed video (Brady Bunch grid) - Daily.co only
    daily_composed_video_s3_key: str | None = None
    daily_composed_video_duration: int | None = None
 class MeetingController:
@@ -171,6 +177,90 @@ class MeetingController:
            return None
        return Meeting(**result)
    async def get_by_room_name_all(self, room_name: str) -> list[Meeting]:
        """Get all meetings for a room name (not just most recent)."""
        query = meetings.select().where(meetings.c.room_name == room_name)
        results = await get_database().fetch_all(query)
        return [Meeting(**r) for r in results]
    async def get_by_room_name_and_time(
        self,
        room_name: NonEmptyString,
        recording_start: datetime,
        time_window_hours: int = 168,
    ) -> Meeting | None:
        """
        Get meeting by room name closest to recording timestamp.
        HACK ALERT: Daily.co doesn't return instanceId in recordings API response,
        and mtgSessionId is separate from our instanceId. Time-based matching is
        the least-bad workaround.
        This handles edge case of duplicate room_name values in DB (race conditions,
        double-clicks, etc.) by matching based on temporal proximity.
        Algorithm:
        1. Find meetings within time_window_hours of recording_start
        2. Return meeting with start_date closest to recording_start
        3. If tie, return first by meeting.id (deterministic)
        Args:
            room_name: Daily.co room name from recording
            recording_start: Timezone-aware datetime from recording.start_ts
            time_window_hours: Search window (default 168 = 1 week)
        Returns:
            Meeting closest to recording timestamp, or None if no matches
        Failure modes:
        - Multiple meetings in same room within ~5 minutes: picks closest
        - All meetings outside time window: returns None
        - Clock skew between Daily.co and DB: 1-week window tolerates this
        Why 1 week window:
        - Handles webhook failures (recording discovered days later)
        - Tolerates clock skew
        - Rejects unrelated meetings from weeks ago
        """
        # Validate timezone-aware datetime
        if recording_start.tzinfo is None:
            raise ValueError(
                f"recording_start must be timezone-aware, got naive datetime: {recording_start}"
            )
        window_start = recording_start - timedelta(hours=time_window_hours)
        window_end = recording_start + timedelta(hours=time_window_hours)
        query = (
            meetings.select()
            .where(
                sa.and_(
                    meetings.c.room_name == room_name,
                    meetings.c.start_date >= window_start,
                    meetings.c.start_date <= window_end,
                )
            )
            .order_by(meetings.c.start_date)
        )
        results = await get_database().fetch_all(query)
        if not results:
            return None
        candidates = [Meeting(**r) for r in results]
        # Find meeting with start_date closest to recording_start
        closest = min(
            candidates,
            key=lambda m: (
                abs((m.start_date - recording_start).total_seconds()),
                m.id,  # Tie-breaker: deterministic by UUID
            ),
        )
        return closest
    async def get_active(self, room: Room, current_time: datetime) -> Meeting | None:
        """
        Get latest active meeting for a room.
@@ -260,6 +350,44 @@ class MeetingController:
        query = meetings.update().where(meetings.c.id == meeting_id).values(**kwargs)
        await get_database().execute(query)
    async def set_cloud_recording_if_missing(
        self,
        meeting_id: NonEmptyString,
        s3_key: NonEmptyString,
        duration: int,
    ) -> bool:
        """
        Set cloud recording only if not already set.
        Returns True if updated, False if already set.
        Prevents webhook/polling race condition via atomic WHERE clause.
        """
        # Check current value before update to detect actual change
        meeting_before = await self.get_by_id(meeting_id)
        if not meeting_before:
            return False
        was_null = meeting_before.daily_composed_video_s3_key is None
        query = (
            meetings.update()
            .where(
                sa.and_(
                    meetings.c.id == meeting_id,
                    meetings.c.daily_composed_video_s3_key.is_(None),
                )
            )
            .values(
                daily_composed_video_s3_key=s3_key,
                daily_composed_video_duration=duration,
            )
        )
        await get_database().execute(query)
        # Return True only if value was NULL before (actual update occurred)
        # If was_null=False, the WHERE clause prevented the update
        return was_null
    async def increment_num_clients(self, meeting_id: str) -> None:
        """Atomically increment participant count."""
        query = (
--- a/server/reflector/db/recordings.py
+++ b/server/reflector/db/recordings.py
@@ -7,6 +7,7 @@ from sqlalchemy import or_
 from reflector.db import get_database, metadata
 from reflector.utils import generate_uuid4
 from reflector.utils.string import NonEmptyString
 recordings = sa.Table(
    "recording",
@@ -71,6 +72,19 @@ class RecordingController:
        query = recordings.delete().where(recordings.c.id == id)
        await get_database().execute(query)
    async def set_meeting_id(
        self,
        recording_id: NonEmptyString,
        meeting_id: NonEmptyString,
    ) -> None:
        """Link recording to meeting."""
        query = (
            recordings.update()
            .where(recordings.c.id == recording_id)
            .values(meeting_id=meeting_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:
--- a/server/reflector/db/rooms.py
+++ b/server/reflector/db/rooms.py
@@ -58,7 +58,7 @@ rooms = sqlalchemy.Table(
        nullable=False,
    ),
    sqlalchemy.Column(
-        "use_hatchet",
+        "use_celery",
        sqlalchemy.Boolean,
        nullable=False,
        server_default=false(),
@@ -97,7 +97,7 @@ class Room(BaseModel):
    ics_last_sync: datetime | None = None
    ics_last_etag: str | None = None
    platform: Platform = Field(default_factory=lambda: settings.DEFAULT_VIDEO_PLATFORM)
-    use_hatchet: bool = False
+    use_celery: bool = False
    skip_consent: bool = False
--- a/server/reflector/hatchet/constants.py
+++ b/server/reflector/hatchet/constants.py
@@ -35,7 +35,9 @@ LLM_RATE_LIMIT_PER_SECOND = 10
 # Task execution timeouts (seconds)
 TIMEOUT_SHORT = 60  # Quick operations: API calls, DB updates
-TIMEOUT_MEDIUM = 120  # Single LLM calls, waveform generation
+TIMEOUT_MEDIUM = (
    300  # Single LLM calls, waveform generation (5m for slow LLM responses)
 )
 TIMEOUT_LONG = 180  # Action items (larger context LLM)
-TIMEOUT_AUDIO = 300  # Audio processing: padding, mixdown
+TIMEOUT_AUDIO = 720  # Audio processing: padding, mixdown
 TIMEOUT_HEAVY = 600  # Transcription, fan-out LLM tasks
--- a/server/reflector/hatchet/run_workers.py
+++ b/server/reflector/hatchet/run_workers.py
@@ -1,77 +0,0 @@
 """
 Run Hatchet workers for the multitrack pipeline.
 Runs as a separate process, just like Celery workers.
 Usage:
    uv run -m reflector.hatchet.run_workers
    # Or via docker:
    docker compose exec server uv run -m reflector.hatchet.run_workers
 """
 import signal
 import sys
 from hatchet_sdk.rate_limit import RateLimitDuration
 from reflector.hatchet.constants import LLM_RATE_LIMIT_KEY, LLM_RATE_LIMIT_PER_SECOND
 from reflector.logger import logger
 from reflector.settings import settings
 def main() -> None:
    """Start Hatchet worker polling."""
    if not settings.HATCHET_ENABLED:
        logger.error("HATCHET_ENABLED is False, not starting workers")
        sys.exit(1)
    if not settings.HATCHET_CLIENT_TOKEN:
        logger.error("HATCHET_CLIENT_TOKEN is not set")
        sys.exit(1)
    logger.info(
        "Starting Hatchet workers",
        debug=settings.HATCHET_DEBUG,
    )
    # Import here (not top-level) - workflow modules call HatchetClientManager.get_client()
    # at module level because Hatchet SDK decorators (@workflow.task) bind at import time.
    # Can't use lazy init: decorators need the client object when function is defined.
    from reflector.hatchet.client import HatchetClientManager  # noqa: PLC0415
    from reflector.hatchet.workflows import (  # noqa: PLC0415
        daily_multitrack_pipeline,
        subject_workflow,
        topic_chunk_workflow,
        track_workflow,
    )
    hatchet = HatchetClientManager.get_client()
    hatchet.rate_limits.put(
        LLM_RATE_LIMIT_KEY, LLM_RATE_LIMIT_PER_SECOND, RateLimitDuration.SECOND
    )
    worker = hatchet.worker(
        "reflector-pipeline-worker",
        workflows=[
            daily_multitrack_pipeline,
            subject_workflow,
            topic_chunk_workflow,
            track_workflow,
        ],
    )
    def shutdown_handler(signum: int, frame) -> None:
        logger.info("Received shutdown signal, stopping workers...")
        # Worker cleanup happens automatically on exit
        sys.exit(0)
    signal.signal(signal.SIGINT, shutdown_handler)
    signal.signal(signal.SIGTERM, shutdown_handler)
    logger.info("Starting Hatchet worker polling...")
    worker.start()
 if __name__ == "__main__":
    main()
--- a/server/reflector/hatchet/run_workers_cpu.py
+++ b/server/reflector/hatchet/run_workers_cpu.py
@@ -0,0 +1,43 @@
 """
 CPU-heavy worker pool for audio processing tasks.
 Handles ONLY: mixdown_tracks
 Configuration:
 - slots=1: Only mixdown (already serialized globally with max_runs=1)
 - Worker affinity: pool=cpu-heavy
 """
 from reflector.hatchet.client import HatchetClientManager
 from reflector.hatchet.workflows.daily_multitrack_pipeline import (
    daily_multitrack_pipeline,
 )
 from reflector.logger import logger
 def main():
    hatchet = HatchetClientManager.get_client()
    logger.info(
        "Starting Hatchet CPU worker pool (mixdown only)",
        worker_name="cpu-worker-pool",
        slots=1,
        labels={"pool": "cpu-heavy"},
    )
    cpu_worker = hatchet.worker(
        "cpu-worker-pool",
        slots=1,  # Only 1 mixdown at a time (already serialized globally)
        labels={
            "pool": "cpu-heavy",
        },
        workflows=[daily_multitrack_pipeline],
    )
    try:
        cpu_worker.start()
    except KeyboardInterrupt:
        logger.info("Received shutdown signal, stopping CPU workers...")
 if __name__ == "__main__":
    main()
--- a/server/reflector/hatchet/run_workers_llm.py
+++ b/server/reflector/hatchet/run_workers_llm.py
@@ -0,0 +1,51 @@
 """
 LLM/I/O worker pool for all non-CPU tasks.
 Handles: all tasks except mixdown_tracks (transcription, LLM inference, orchestration)
 """
 from reflector.hatchet.client import HatchetClientManager
 from reflector.hatchet.workflows.daily_multitrack_pipeline import (
    daily_multitrack_pipeline,
 )
 from reflector.hatchet.workflows.subject_processing import subject_workflow
 from reflector.hatchet.workflows.topic_chunk_processing import topic_chunk_workflow
 from reflector.hatchet.workflows.track_processing import track_workflow
 from reflector.logger import logger
 SLOTS = 10
 WORKER_NAME = "llm-worker-pool"
 POOL = "llm-io"
 def main():
    hatchet = HatchetClientManager.get_client()
    logger.info(
        "Starting Hatchet LLM worker pool (all tasks except mixdown)",
        worker_name=WORKER_NAME,
        slots=SLOTS,
        labels={"pool": POOL},
    )
    llm_worker = hatchet.worker(
        WORKER_NAME,
        slots=SLOTS,  # not all slots are probably used
        labels={
            "pool": POOL,
        },
        workflows=[
            daily_multitrack_pipeline,
            topic_chunk_workflow,
            subject_workflow,
            track_workflow,
        ],
    )
    try:
        llm_worker.start()
    except KeyboardInterrupt:
        logger.info("Received shutdown signal, stopping LLM workers...")
 if __name__ == "__main__":
    main()
--- a/server/reflector/hatchet/workflows/daily_multitrack_pipeline.py
+++ b/server/reflector/hatchet/workflows/daily_multitrack_pipeline.py
@@ -23,7 +23,12 @@ from pathlib import Path
 from typing import Any, Callable, Coroutine, Protocol, TypeVar
 import httpx
-from hatchet_sdk import Context
+from hatchet_sdk import (
    ConcurrencyExpression,
    ConcurrencyLimitStrategy,
    Context,
 )
 from hatchet_sdk.labels import DesiredWorkerLabel
 from pydantic import BaseModel
 from reflector.dailyco_api.client import DailyApiClient
@@ -317,6 +322,7 @@ async def get_participants(input: PipelineInput, ctx: Context) -> ParticipantsRe
    mtg_session_id = recording.mtg_session_id
    async with fresh_db_connection():
        from reflector.db.transcripts import (  # noqa: PLC0415
            TranscriptDuration,
            TranscriptParticipant,
            transcripts_controller,
        )
@@ -325,15 +331,26 @@ async def get_participants(input: PipelineInput, ctx: Context) -> ParticipantsRe
        if not transcript:
            raise ValueError(f"Transcript {input.transcript_id} not found")
        # Note: title NOT cleared - preserves existing titles
        # Duration from Daily API (seconds -> milliseconds) - master source
        duration_ms = recording.duration * 1000 if recording.duration else 0
        await transcripts_controller.update(
            transcript,
            {
                "events": [],
                "topics": [],
                "participants": [],
                "duration": duration_ms,
            },
        )
        await append_event_and_broadcast(
            input.transcript_id,
            transcript,
            "DURATION",
            TranscriptDuration(duration=duration_ms),
            logger=logger,
        )
        mtg_session_id = assert_non_none_and_non_empty(
            mtg_session_id, "mtg_session_id is required"
        )
@@ -467,6 +484,20 @@ async def process_tracks(input: PipelineInput, ctx: Context) -> ProcessTracksRes
    parents=[process_tracks],
    execution_timeout=timedelta(seconds=TIMEOUT_AUDIO),
    retries=3,
    desired_worker_labels={
        "pool": DesiredWorkerLabel(
            value="cpu-heavy",
            required=True,
            weight=100,
        ),
    },
    concurrency=[
        ConcurrencyExpression(
            expression="'mixdown-global'",
            max_runs=1,  # serialize mixdown to prevent resource contention
            limit_strategy=ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,  # Queue
        )
    ],
 )
@with_error_handling(TaskName.MIXDOWN_TRACKS)
 async def mixdown_tracks(input: PipelineInput, ctx: Context) -> MixdownResult:
@@ -1076,7 +1107,7 @@ async def identify_action_items(
@daily_multitrack_pipeline.task(
-    parents=[generate_waveform, generate_title, generate_recap, identify_action_items],
+    parents=[process_tracks, generate_title, generate_recap, identify_action_items],
    execution_timeout=timedelta(seconds=TIMEOUT_SHORT),
    retries=3,
 )
@@ -1089,12 +1120,8 @@ async def finalize(input: PipelineInput, ctx: Context) -> FinalizeResult:
    """
    ctx.log("finalize: saving transcript and setting status to 'ended'")
    mixdown_result = ctx.task_output(mixdown_tracks)
    track_result = ctx.task_output(process_tracks)
    duration = mixdown_result.duration
    all_words = track_result.all_words
    # Cleanup temporary padded S3 files (deferred until finalize for semantic parity with Celery)
    created_padded_files = track_result.created_padded_files
    if created_padded_files:
@@ -1114,7 +1141,6 @@ async def finalize(input: PipelineInput, ctx: Context) -> FinalizeResult:
    async with fresh_db_connection():
        from reflector.db.transcripts import (  # noqa: PLC0415
            TranscriptDuration,
            TranscriptText,
            transcripts_controller,
        )
@@ -1123,34 +1149,26 @@ async def finalize(input: PipelineInput, ctx: Context) -> FinalizeResult:
        if transcript is None:
            raise ValueError(f"Transcript {input.transcript_id} not found in database")
        merged_transcript = TranscriptType(words=all_words, translation=None)
        await append_event_and_broadcast(
            input.transcript_id,
            transcript,
            "TRANSCRIPT",
            TranscriptText(
-                text=merged_transcript.text,
+                text="",
-                translation=merged_transcript.translation,
+                translation=None,
            ),
            logger=logger,
        )
-        # Save duration and clear workflow_run_id (workflow completed successfully)
+        # Clear workflow_run_id (workflow completed successfully)
-        # Note: title/long_summary/short_summary already saved by their callbacks
+        # Note: title/long_summary/short_summary/duration already saved by their callbacks
        await transcripts_controller.update(
            transcript,
            {
                "duration": duration,
                "workflow_run_id": None,  # Clear on success - no need to resume
            },
        )
        duration_data = TranscriptDuration(duration=duration)
        await append_event_and_broadcast(
            input.transcript_id, transcript, "DURATION", duration_data, logger=logger
        )
        await set_status_and_broadcast(input.transcript_id, "ended", logger=logger)
        ctx.log(
@@ -1328,14 +1346,34 @@ async def send_webhook(input: PipelineInput, ctx: Context) -> WebhookResult:
            f"participants={len(payload.transcript.participants)})"
        )
-        response = await send_webhook_request(
+        try:
-            url=room.webhook_url,
+            response = await send_webhook_request(
-            payload=payload,
+                url=room.webhook_url,
-            event_type="transcript.completed",
+                payload=payload,
-            webhook_secret=room.webhook_secret,
+                event_type="transcript.completed",
-            timeout=30.0,
+                webhook_secret=room.webhook_secret,
-        )
+                timeout=30.0,
            )
-        ctx.log(f"send_webhook complete: status_code={response.status_code}")
+            ctx.log(f"send_webhook complete: status_code={response.status_code}")
            return WebhookResult(webhook_sent=True, response_code=response.status_code)
-        return WebhookResult(webhook_sent=True, response_code=response.status_code)
+        except httpx.HTTPStatusError as e:
            ctx.log(
                f"send_webhook failed (HTTP {e.response.status_code}), continuing anyway"
            )
            return WebhookResult(
                webhook_sent=False, response_code=e.response.status_code
            )
        except httpx.ConnectError as e:
            ctx.log(f"send_webhook failed (connection error), continuing anyway: {e}")
            return WebhookResult(webhook_sent=False)
        except httpx.TimeoutException as e:
            ctx.log(f"send_webhook failed (timeout), continuing anyway: {e}")
            return WebhookResult(webhook_sent=False)
        except Exception as e:
            ctx.log(f"send_webhook unexpected error, continuing anyway: {e}")
            return WebhookResult(webhook_sent=False)
--- a/server/reflector/hatchet/workflows/padding_workflow.py
+++ b/server/reflector/hatchet/workflows/padding_workflow.py
@@ -0,0 +1,165 @@
 """
 Hatchet child workflow: PaddingWorkflow
 Handles individual audio track padding via Modal.com backend.
 """
 from datetime import timedelta
 import av
 from hatchet_sdk import Context
 from pydantic import BaseModel
 from reflector.hatchet.client import HatchetClientManager
 from reflector.hatchet.constants import TIMEOUT_AUDIO
 from reflector.hatchet.workflows.models import PadTrackResult
 from reflector.logger import logger
 from reflector.utils.audio_constants import PRESIGNED_URL_EXPIRATION_SECONDS
 from reflector.utils.audio_padding import extract_stream_start_time_from_container
 class PaddingInput(BaseModel):
    """Input for individual track padding."""
    track_index: int
    s3_key: str
    bucket_name: str
    transcript_id: str
 hatchet = HatchetClientManager.get_client()
 padding_workflow = hatchet.workflow(
    name="PaddingWorkflow", input_validator=PaddingInput
 )
@padding_workflow.task(execution_timeout=timedelta(seconds=TIMEOUT_AUDIO), retries=3)
 async def pad_track(input: PaddingInput, ctx: Context) -> PadTrackResult:
    """Pad audio track with silence based on WebM container start_time."""
    ctx.log(f"pad_track: track {input.track_index}, s3_key={input.s3_key}")
    logger.info(
        "[Hatchet] pad_track",
        track_index=input.track_index,
        s3_key=input.s3_key,
        transcript_id=input.transcript_id,
    )
    try:
        # Create fresh storage instance to avoid aioboto3 fork issues
        from reflector.settings import settings  # noqa: PLC0415
        from reflector.storage.storage_aws import AwsStorage  # noqa: PLC0415
        storage = AwsStorage(
            aws_bucket_name=settings.TRANSCRIPT_STORAGE_AWS_BUCKET_NAME,
            aws_region=settings.TRANSCRIPT_STORAGE_AWS_REGION,
            aws_access_key_id=settings.TRANSCRIPT_STORAGE_AWS_ACCESS_KEY_ID,
            aws_secret_access_key=settings.TRANSCRIPT_STORAGE_AWS_SECRET_ACCESS_KEY,
        )
        source_url = await storage.get_file_url(
            input.s3_key,
            operation="get_object",
            expires_in=PRESIGNED_URL_EXPIRATION_SECONDS,
            bucket=input.bucket_name,
        )
        # Extract start_time to determine if padding needed
        with av.open(source_url) as in_container:
            if in_container.duration:
                try:
                    duration = timedelta(seconds=in_container.duration // 1_000_000)
                    ctx.log(
                        f"pad_track: track {input.track_index}, duration={duration}"
                    )
                except (ValueError, TypeError, OverflowError) as e:
                    ctx.log(
                        f"pad_track: track {input.track_index}, duration error: {str(e)}"
                    )
            start_time_seconds = extract_stream_start_time_from_container(
                in_container, input.track_index, logger=logger
            )
        if start_time_seconds <= 0:
            logger.info(
                f"Track {input.track_index} requires no padding",
                track_index=input.track_index,
            )
            return PadTrackResult(
                padded_key=input.s3_key,
                bucket_name=input.bucket_name,
                size=0,
                track_index=input.track_index,
            )
        storage_path = f"file_pipeline_hatchet/{input.transcript_id}/tracks/padded_{input.track_index}.webm"
        # Presign PUT URL for output (Modal will upload directly)
        output_url = await storage.get_file_url(
            storage_path,
            operation="put_object",
            expires_in=PRESIGNED_URL_EXPIRATION_SECONDS,
        )
        import httpx  # noqa: PLC0415
        from reflector.processors.audio_padding_modal import (  # noqa: PLC0415
            AudioPaddingModalProcessor,
        )
        try:
            processor = AudioPaddingModalProcessor()
            result = await processor.pad_track(
                track_url=source_url,
                output_url=output_url,
                start_time_seconds=start_time_seconds,
                track_index=input.track_index,
            )
            file_size = result.size
            ctx.log(f"pad_track: Modal returned size={file_size}")
        except httpx.HTTPStatusError as e:
            error_detail = e.response.text if hasattr(e.response, "text") else str(e)
            logger.error(
                "[Hatchet] Modal padding HTTP error",
                transcript_id=input.transcript_id,
                track_index=input.track_index,
                status_code=e.response.status_code if hasattr(e, "response") else None,
                error=error_detail,
                exc_info=True,
            )
            raise Exception(
                f"Modal padding failed: HTTP {e.response.status_code}"
            ) from e
        except httpx.TimeoutException as e:
            logger.error(
                "[Hatchet] Modal padding timeout",
                transcript_id=input.transcript_id,
                track_index=input.track_index,
                error=str(e),
                exc_info=True,
            )
            raise Exception("Modal padding timeout") from e
        logger.info(
            "[Hatchet] pad_track complete",
            track_index=input.track_index,
            padded_key=storage_path,
        )
        return PadTrackResult(
            padded_key=storage_path,
            bucket_name=None,  # None = use default transcript storage bucket
            size=file_size,
            track_index=input.track_index,
        )
    except Exception as e:
        logger.error(
            "[Hatchet] pad_track failed",
            transcript_id=input.transcript_id,
            track_index=input.track_index,
            error=str(e),
            exc_info=True,
        )
        raise
--- a/server/reflector/hatchet/workflows/topic_chunk_processing.py
+++ b/server/reflector/hatchet/workflows/topic_chunk_processing.py
@@ -7,7 +7,11 @@ Spawned dynamically by detect_topics via aio_run_many() for parallel processing.
 from datetime import timedelta
-from hatchet_sdk import ConcurrencyExpression, ConcurrencyLimitStrategy, Context
+from hatchet_sdk import (
    ConcurrencyExpression,
    ConcurrencyLimitStrategy,
    Context,
 )
 from hatchet_sdk.rate_limit import RateLimit
 from pydantic import BaseModel
@@ -34,11 +38,13 @@ hatchet = HatchetClientManager.get_client()
 topic_chunk_workflow = hatchet.workflow(
    name="TopicChunkProcessing",
    input_validator=TopicChunkInput,
-    concurrency=ConcurrencyExpression(
+    concurrency=[
-        expression="'global'",  # constant string = global limit across all runs
+        ConcurrencyExpression(
-        max_runs=20,
+            expression="'global'",  # constant string = global limit across all runs
-        limit_strategy=ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+            max_runs=20,
-    ),
+            limit_strategy=ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
        )
    ],
 )
--- a/server/reflector/hatchet/workflows/track_processing.py
+++ b/server/reflector/hatchet/workflows/track_processing.py
@@ -14,9 +14,7 @@ Hatchet workers run in forked processes; fresh imports per task ensure
 storage/DB connections are not shared across forks.
 """
 import tempfile
 from datetime import timedelta
 from pathlib import Path
 import av
 from hatchet_sdk import Context
@@ -27,10 +25,7 @@ from reflector.hatchet.constants import TIMEOUT_AUDIO, TIMEOUT_HEAVY
 from reflector.hatchet.workflows.models import PadTrackResult, TranscribeTrackResult
 from reflector.logger import logger
 from reflector.utils.audio_constants import PRESIGNED_URL_EXPIRATION_SECONDS
-from reflector.utils.audio_padding import (
+from reflector.utils.audio_padding import extract_stream_start_time_from_container
    apply_audio_padding_to_file,
    extract_stream_start_time_from_container,
 )
 class TrackInput(BaseModel):
@@ -83,63 +78,44 @@ async def pad_track(input: TrackInput, ctx: Context) -> PadTrackResult:
        )
        with av.open(source_url) as in_container:
            if in_container.duration:
                try:
                    duration = timedelta(seconds=in_container.duration // 1_000_000)
                    ctx.log(
                        f"pad_track: track {input.track_index}, duration={duration}"
                    )
                except Exception:
                    ctx.log(f"pad_track: track {input.track_index}, duration=ERROR")
            start_time_seconds = extract_stream_start_time_from_container(
                in_container, input.track_index, logger=logger
            )
-            # If no padding needed, return original S3 key
+        # If no padding needed, return original S3 key
-            if start_time_seconds <= 0:
+        if start_time_seconds <= 0:
-                logger.info(
+            logger.info(
-                    f"Track {input.track_index} requires no padding",
+                f"Track {input.track_index} requires no padding",
-                    track_index=input.track_index,
+                track_index=input.track_index,
-                )
+            )
-                return PadTrackResult(
+            return PadTrackResult(
-                    padded_key=input.s3_key,
+                padded_key=input.s3_key,
-                    bucket_name=input.bucket_name,
+                bucket_name=input.bucket_name,
-                    size=0,
+                size=0,
-                    track_index=input.track_index,
+                track_index=input.track_index,
-                )
+            )
-            with tempfile.NamedTemporaryFile(suffix=".webm", delete=False) as temp_file:
+        storage_path = f"file_pipeline_hatchet/{input.transcript_id}/tracks/padded_{input.track_index}.webm"
                temp_path = temp_file.name
-            try:
+        # Presign PUT URL for output (Modal uploads directly)
-                apply_audio_padding_to_file(
+        output_url = await storage.get_file_url(
-                    in_container,
+            storage_path,
-                    temp_path,
+            operation="put_object",
-                    start_time_seconds,
+            expires_in=PRESIGNED_URL_EXPIRATION_SECONDS,
-                    input.track_index,
+        )
                    logger=logger,
                )
-                file_size = Path(temp_path).stat().st_size
+        from reflector.processors.audio_padding_modal import (  # noqa: PLC0415
-                storage_path = f"file_pipeline_hatchet/{input.transcript_id}/tracks/padded_{input.track_index}.webm"
+            AudioPaddingModalProcessor,
        )
-                logger.info(
+        processor = AudioPaddingModalProcessor()
-                    f"About to upload padded track",
+        result = await processor.pad_track(
-                    key=storage_path,
+            track_url=source_url,
-                    size=file_size,
+            output_url=output_url,
-                )
+            start_time_seconds=start_time_seconds,
-
+            track_index=input.track_index,
-                with open(temp_path, "rb") as padded_file:
+        )
-                    await storage.put_file(storage_path, padded_file)
+        file_size = result.size
                logger.info(
                    f"Uploaded padded track to S3",
                    key=storage_path,
                    size=file_size,
                )
            finally:
                Path(temp_path).unlink(missing_ok=True)
        ctx.log(f"pad_track complete: track {input.track_index} -> {storage_path}")
        logger.info(
--- a/server/reflector/processors/audio_padding_modal.py
+++ b/server/reflector/processors/audio_padding_modal.py
@@ -0,0 +1,113 @@
 """
 Modal.com backend for audio padding.
 """
 import asyncio
 import os
 import httpx
 from pydantic import BaseModel
 from reflector.hatchet.constants import TIMEOUT_AUDIO
 from reflector.logger import logger
 class PaddingResponse(BaseModel):
    size: int
    cancelled: bool = False
 class AudioPaddingModalProcessor:
    """Audio padding processor using Modal.com CPU backend via HTTP."""
    def __init__(
        self, padding_url: str | None = None, modal_api_key: str | None = None
    ):
        self.padding_url = padding_url or os.getenv("PADDING_URL")
        if not self.padding_url:
            raise ValueError(
                "PADDING_URL required to use AudioPaddingModalProcessor. "
                "Set PADDING_URL environment variable or pass padding_url parameter."
            )
        self.modal_api_key = modal_api_key or os.getenv("MODAL_API_KEY")
    async def pad_track(
        self,
        track_url: str,
        output_url: str,
        start_time_seconds: float,
        track_index: int,
    ) -> PaddingResponse:
        """Pad audio track with silence via Modal backend.
        Args:
            track_url: Presigned GET URL for source audio track
            output_url: Presigned PUT URL for output WebM
            start_time_seconds: Amount of silence to prepend
            track_index: Track index for logging
        """
        if not track_url:
            raise ValueError("track_url cannot be empty")
        if start_time_seconds <= 0:
            raise ValueError(
                f"start_time_seconds must be positive, got {start_time_seconds}"
            )
        log = logger.bind(track_index=track_index, padding_seconds=start_time_seconds)
        log.info("Sending Modal padding HTTP request")
        url = f"{self.padding_url}/pad"
        headers = {}
        if self.modal_api_key:
            headers["Authorization"] = f"Bearer {self.modal_api_key}"
        try:
            async with httpx.AsyncClient(timeout=TIMEOUT_AUDIO) as client:
                response = await client.post(
                    url,
                    headers=headers,
                    json={
                        "track_url": track_url,
                        "output_url": output_url,
                        "start_time_seconds": start_time_seconds,
                        "track_index": track_index,
                    },
                    follow_redirects=True,
                )
                if response.status_code != 200:
                    error_body = response.text
                    log.error(
                        "Modal padding API error",
                        status_code=response.status_code,
                        error_body=error_body,
                    )
                response.raise_for_status()
                result = response.json()
            # Check if work was cancelled
            if result.get("cancelled"):
                log.warning("Modal padding was cancelled by disconnect detection")
                raise asyncio.CancelledError(
                    "Padding cancelled due to client disconnect"
                )
            log.info("Modal padding complete", size=result["size"])
            return PaddingResponse(**result)
        except asyncio.CancelledError:
            log.warning(
                "Modal padding cancelled (Hatchet timeout, disconnect detected on Modal side)"
            )
            raise
        except httpx.TimeoutException as e:
            log.error("Modal padding timeout", error=str(e), exc_info=True)
            raise Exception(f"Modal padding timeout: {e}") from e
        except httpx.HTTPStatusError as e:
            log.error("Modal padding HTTP error", error=str(e), exc_info=True)
            raise Exception(f"Modal padding HTTP error: {e}") from e
        except Exception as e:
            log.error("Modal padding unexpected error", error=str(e), exc_info=True)
            raise
--- a/server/reflector/services/ics_sync.py
+++ b/server/reflector/services/ics_sync.py
@@ -319,21 +319,6 @@ class ICSSyncService:
            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}"
@@ -371,6 +356,44 @@ class ICSSyncService:
        time_since_sync = datetime.now(timezone.utc) - room.ics_last_sync
        return time_since_sync.total_seconds() >= room.ics_fetch_interval
    def _event_data_changed(self, existing: CalendarEvent, new_data: EventData) -> bool:
        """Check if event data has changed by comparing relevant fields.
        IMPORTANT: When adding fields to CalendarEvent/EventData, update this method
        and the _COMPARED_FIELDS set below for runtime validation.
        """
        # Fields that come from ICS and should trigger updates when changed
        _COMPARED_FIELDS = {
            "title",
            "description",
            "start_time",
            "end_time",
            "location",
            "attendees",
            "ics_raw_data",
        }
        # Runtime exhaustiveness check: ensure we're comparing all EventData fields
        event_data_fields = set(EventData.__annotations__.keys()) - {"ics_uid"}
        if event_data_fields != _COMPARED_FIELDS:
            missing = event_data_fields - _COMPARED_FIELDS
            extra = _COMPARED_FIELDS - event_data_fields
            raise RuntimeError(
                f"_event_data_changed() field mismatch: "
                f"missing={missing}, extra={extra}. "
                f"Update the comparison logic when adding/removing fields."
            )
        return (
            existing.title != new_data["title"]
            or existing.description != new_data["description"]
            or existing.start_time != new_data["start_time"]
            or existing.end_time != new_data["end_time"]
            or existing.location != new_data["location"]
            or existing.attendees != new_data["attendees"]
            or existing.ics_raw_data != new_data["ics_raw_data"]
        )
    async def _sync_events_to_database(
        self, room_id: str, events: list[EventData]
    ) -> SyncStats:
@@ -386,11 +409,14 @@ class ICSSyncService:
            )
            if existing:
-                updated += 1
+                # Only count as updated if data actually changed
                if self._event_data_changed(existing, event_data):
                    updated += 1
                    await calendar_events_controller.upsert(calendar_event)
            else:
                created += 1
                await calendar_events_controller.upsert(calendar_event)
            await calendar_events_controller.upsert(calendar_event)
            current_ics_uids.append(event_data["ics_uid"])
        # Soft delete events that are no longer in calendar
--- a/server/reflector/services/transcript_process.py
+++ b/server/reflector/services/transcript_process.py
@@ -11,7 +11,7 @@ from typing import Literal, Union, assert_never
 import celery
 from celery.result import AsyncResult
-from hatchet_sdk.clients.rest.exceptions import ApiException
+from hatchet_sdk.clients.rest.exceptions import ApiException, NotFoundException
 from hatchet_sdk.clients.rest.models import V1TaskStatus
 from reflector.db.recordings import recordings_controller
@@ -23,7 +23,6 @@ from reflector.pipelines.main_file_pipeline import task_pipeline_file_process
 from reflector.pipelines.main_multitrack_pipeline import (
    task_pipeline_multitrack_process,
 )
 from reflector.settings import settings
 from reflector.utils.string import NonEmptyString
@@ -102,8 +101,8 @@ async def validate_transcript_for_processing(
    if transcript.locked:
        return ValidationLocked(detail="Recording is locked")
-    # hatchet is idempotent anyways + if it wasn't dispatched successfully
+    # Check if recording is ready for processing
-    if transcript.status == "idle" and not settings.HATCHET_ENABLED:
+    if transcript.status == "idle" and not transcript.workflow_run_id:
        return ValidationNotReady(detail="Recording is not ready for processing")
    # Check Celery tasks
@@ -116,7 +115,8 @@ async def validate_transcript_for_processing(
    ):
        return ValidationAlreadyScheduled(detail="already running")
-    if settings.HATCHET_ENABLED and transcript.workflow_run_id:
+    # Check Hatchet workflow status if workflow_run_id exists
    if transcript.workflow_run_id:
        try:
            status = await HatchetClientManager.get_workflow_run_status(
                transcript.workflow_run_id
@@ -181,19 +181,16 @@ async def dispatch_transcript_processing(
    Returns AsyncResult for Celery tasks, None for Hatchet workflows.
    """
    if isinstance(config, MultitrackProcessingConfig):
-        # Check if room has use_hatchet=True (overrides env vars)
+        use_celery = False
        room_forces_hatchet = False
        if config.room_id:
            room = await rooms_controller.get_by_id(config.room_id)
-            room_forces_hatchet = room.use_hatchet if room else False
+            use_celery = room.use_celery if room else False
-        # Start durable workflow if enabled (Hatchet)
+        use_hatchet = not use_celery
        # and if room has use_hatchet=True
        use_hatchet = settings.HATCHET_ENABLED and room_forces_hatchet
-        if room_forces_hatchet:
+        if use_celery:
            logger.info(
-                "Room forces Hatchet workflow",
+                "Room uses legacy Celery processing",
                room_id=config.room_id,
                transcript_id=config.transcript_id,
            )
@@ -215,24 +212,39 @@ async def dispatch_transcript_processing(
                    )
                    return None
                else:
-                    # Workflow exists but can't replay (CANCELLED, COMPLETED, etc.)
+                    # Workflow can't replay (CANCELLED, COMPLETED, or 404 deleted)
                    # Log and proceed to start new workflow
-                    status = await HatchetClientManager.get_workflow_run_status(
+                    try:
-                        transcript.workflow_run_id
+                        status = await HatchetClientManager.get_workflow_run_status(
-                    )
+                            transcript.workflow_run_id
-                    logger.info(
+                        )
-                        "Old workflow not replayable, starting new",
+                        logger.info(
-                        old_workflow_id=transcript.workflow_run_id,
+                            "Old workflow not replayable, starting new",
-                        old_status=status.value,
+                            old_workflow_id=transcript.workflow_run_id,
-                    )
+                            old_status=status.value,
                        )
                    except NotFoundException:
                        # Workflow deleted from Hatchet but ID still in DB
                        logger.info(
                            "Old workflow not found in Hatchet, starting new",
                            old_workflow_id=transcript.workflow_run_id,
                        )
            # Force: cancel old workflow if exists
            if force and transcript and transcript.workflow_run_id:
-                await HatchetClientManager.cancel_workflow(transcript.workflow_run_id)
+                try:
-                logger.info(
+                    await HatchetClientManager.cancel_workflow(
-                    "Cancelled old workflow (--force)",
+                        transcript.workflow_run_id
-                    workflow_id=transcript.workflow_run_id,
+                    )
-                )
+                    logger.info(
                        "Cancelled old workflow (--force)",
                        workflow_id=transcript.workflow_run_id,
                    )
                except NotFoundException:
                    logger.info(
                        "Old workflow already deleted (--force)",
                        workflow_id=transcript.workflow_run_id,
                    )
                await transcripts_controller.update(
                    transcript, {"workflow_run_id": None}
                )
--- a/server/reflector/settings.py
+++ b/server/reflector/settings.py
@@ -98,6 +98,10 @@ class Settings(BaseSettings):
    # Diarization: local pyannote.audio
    DIARIZATION_PYANNOTE_AUTH_TOKEN: str | None = None
    # Audio Padding (Modal.com backend)
    PADDING_URL: str | None = None
    PADDING_MODAL_API_KEY: str | None = None
    # Sentry
    SENTRY_DSN: str | None = None
@@ -158,19 +162,10 @@ class Settings(BaseSettings):
    ZULIP_API_KEY: str | None = None
    ZULIP_BOT_EMAIL: str | None = None
-    # Durable workflow orchestration
+    # Hatchet workflow orchestration (always enabled for multitrack processing)
    # Provider: "hatchet" (or "none" to disable)
    DURABLE_WORKFLOW_PROVIDER: str = "none"
    # Hatchet workflow orchestration
    HATCHET_CLIENT_TOKEN: str | None = None
    HATCHET_CLIENT_TLS_STRATEGY: str = "none"  # none, tls, mtls
    HATCHET_DEBUG: bool = False
    @property
    def HATCHET_ENABLED(self) -> bool:
        """True if Hatchet is the active provider."""
        return self.DURABLE_WORKFLOW_PROVIDER == "hatchet"
 settings = Settings()
--- a/server/reflector/utils/audio_constants.py
+++ b/server/reflector/utils/audio_constants.py
@@ -5,7 +5,9 @@ Used by both Hatchet workflows and Celery pipelines for consistent audio encodin
 """
 # Opus codec settings
 # ref B0F71CE8-FC59-4AA5-8414-DAFB836DB711
 OPUS_STANDARD_SAMPLE_RATE = 48000
 # ref B0F71CE8-FC59-4AA5-8414-DAFB836DB711
 OPUS_DEFAULT_BIT_RATE = 128000  # 128kbps for good speech quality
 # S3 presigned URL expiration
--- a/server/reflector/video_platforms/daily.py
+++ b/server/reflector/video_platforms/daily.py
@@ -1,4 +1,5 @@
 from datetime import datetime
 from uuid import UUID
 from reflector.dailyco_api import (
    CreateMeetingTokenRequest,
@@ -12,9 +13,11 @@ from reflector.dailyco_api import (
    RoomProperties,
    verify_webhook_signature,
 )
 from reflector.dailyco_api import RecordingType as DailyRecordingType
 from reflector.db.daily_participant_sessions import (
    daily_participant_sessions_controller,
 )
 from reflector.db.meetings import meetings_controller
 from reflector.db.rooms import Room
 from reflector.logger import logger
 from reflector.storage import get_dailyco_storage
@@ -58,10 +61,9 @@ class DailyClient(VideoPlatformClient):
        enable_recording = None
        if room.recording_type == self.RECORDING_LOCAL:
            enable_recording = "local"
-        elif (
+        elif room.recording_type == self.RECORDING_CLOUD:
-            room.recording_type == self.RECORDING_CLOUD
+            # Don't set enable_recording - recordings started via REST API (not auto-start)
-        ):  # daily "cloud" is not our "cloud"
+            enable_recording = None
            enable_recording = "raw-tracks"
        properties = RoomProperties(
            enable_recording=enable_recording,
@@ -106,8 +108,6 @@ class DailyClient(VideoPlatformClient):
        Daily.co doesn't provide historical session API, so we query our database
        where participant.joined/left webhooks are stored.
        """
        from reflector.db.meetings import meetings_controller  # noqa: PLC0415
        meeting = await meetings_controller.get_by_room_name(room_name)
        if not meeting:
            return []
@@ -179,21 +179,14 @@ class DailyClient(VideoPlatformClient):
    async def create_meeting_token(
        self,
        room_name: DailyRoomName,
        start_cloud_recording: bool,
        enable_recording_ui: bool,
        user_id: NonEmptyString | None = None,
        is_owner: bool = False,
        max_recording_duration_seconds: int | None = None,
    ) -> NonEmptyString:
        start_cloud_recording_opts = None
        if start_cloud_recording and max_recording_duration_seconds:
            start_cloud_recording_opts = {"maxDuration": max_recording_duration_seconds}
        properties = MeetingTokenProperties(
            room_name=room_name,
            user_id=user_id,
            start_cloud_recording=start_cloud_recording,
            start_cloud_recording_opts=start_cloud_recording_opts,
            enable_recording_ui=enable_recording_ui,
            is_owner=is_owner,
        )
@@ -201,6 +194,23 @@ class DailyClient(VideoPlatformClient):
        result = await self._api_client.create_meeting_token(request)
        return result.token
    async def start_recording(
        self,
        room_name: DailyRoomName,
        recording_type: DailyRecordingType,
        instance_id: UUID,
    ) -> dict:
        """Start recording via Daily.co REST API.
        Args:
            instance_id: UUID for this recording session - one UUID per "room" in Daily (which is "meeting" in Reflector)
        """
        return await self._api_client.start_recording(
            room_name=room_name,
            recording_type=recording_type,
            instance_id=instance_id,
        )
    async def close(self):
        """Clean up API client resources."""
        await self._api_client.close()
--- a/server/reflector/views/daily.py
+++ b/server/reflector/views/daily.py
@@ -19,6 +19,7 @@ from reflector.video_platforms.factory import create_platform_client
 from reflector.worker.process import (
    poll_daily_room_presence_task,
    process_multitrack_recording,
    store_cloud_recording,
 )
 router = APIRouter()
@@ -174,46 +175,64 @@ async def _handle_recording_started(event: RecordingStartedEvent):
 async def _handle_recording_ready(event: RecordingReadyEvent):
    room_name = event.payload.room_name
    recording_id = event.payload.recording_id
-    tracks = event.payload.tracks
+    recording_type = event.payload.type
    if not tracks:
        logger.warning(
            "recording.ready-to-download: missing tracks",
            room_name=room_name,
            recording_id=recording_id,
            payload=event.payload,
        )
        return
    logger.info(
        "Recording ready for download",
        room_name=room_name,
        recording_id=recording_id,
-        num_tracks=len(tracks),
+        recording_type=recording_type,
        platform="daily",
    )
    bucket_name = settings.DAILYCO_STORAGE_AWS_BUCKET_NAME
    if not bucket_name:
-        logger.error(
+        logger.error("DAILYCO_STORAGE_AWS_BUCKET_NAME not configured")
            "DAILYCO_STORAGE_AWS_BUCKET_NAME not configured; cannot process Daily recording"
        )
        return
-    track_keys = [t.s3Key for t in tracks if t.type == "audio"]
+    if recording_type == "cloud":
        await store_cloud_recording(
            recording_id=recording_id,
            room_name=room_name,
            s3_key=event.payload.s3_key,
            duration=event.payload.duration,
            start_ts=event.payload.start_ts,
            source="webhook",
        )
-    logger.info(
+    elif recording_type == "raw-tracks":
-        "Recording webhook queuing processing",
+        tracks = event.payload.tracks
-        recording_id=recording_id,
+        if not tracks:
-        room_name=room_name,
+            logger.warning(
-    )
+                "raw-tracks recording: missing tracks array",
                room_name=room_name,
                recording_id=recording_id,
            )
            return
-    process_multitrack_recording.delay(
+        track_keys = [t.s3Key for t in tracks if t.type == "audio"]
-        bucket_name=bucket_name,
+
-        daily_room_name=room_name,
+        logger.info(
-        recording_id=recording_id,
+            "Raw-tracks recording queuing processing",
-        track_keys=track_keys,
+            recording_id=recording_id,
-    )
+            room_name=room_name,
            num_tracks=len(track_keys),
        )
        process_multitrack_recording.delay(
            bucket_name=bucket_name,
            daily_room_name=room_name,
            recording_id=recording_id,
            track_keys=track_keys,
            recording_start_ts=event.payload.start_ts,
        )
    else:
        logger.warning(
            "Unknown recording type",
            recording_type=recording_type,
            recording_id=recording_id,
        )
 async def _handle_recording_error(event: RecordingErrorEvent):
--- a/server/reflector/views/meetings.py
+++ b/server/reflector/views/meetings.py
@@ -1,16 +1,23 @@
 import json
 from datetime import datetime, timezone
-from typing import Annotated, Optional
+from typing import Annotated, Any, Optional
 from uuid import UUID
 from fastapi import APIRouter, Depends, HTTPException, Request
 from pydantic import BaseModel
 import reflector.auth as auth
 from reflector.dailyco_api import RecordingType
 from reflector.dailyco_api.client import DailyApiError
 from reflector.db.meetings import (
    MeetingConsent,
    meeting_consent_controller,
    meetings_controller,
 )
 from reflector.db.rooms import rooms_controller
 from reflector.logger import logger
 from reflector.utils.string import NonEmptyString
 from reflector.video_platforms.factory import create_platform_client
 router = APIRouter()
@@ -73,3 +80,72 @@ async def meeting_deactivate(
    await meetings_controller.update_meeting(meeting_id, is_active=False)
    return {"status": "success", "meeting_id": meeting_id}
 class StartRecordingRequest(BaseModel):
    type: RecordingType
    instanceId: UUID
@router.post("/meetings/{meeting_id}/recordings/start")
 async def start_recording(
    meeting_id: NonEmptyString, body: StartRecordingRequest
 ) -> dict[str, Any]:
    """Start cloud or raw-tracks recording via Daily.co REST API.
    Both cloud and raw-tracks are started via REST API to bypass enable_recording limitation of allowing only 1 recording at a time.
    Uses different instanceIds for cloud vs raw-tracks (same won't work)
    Note: No authentication required - anonymous users supported. TODO this is a DOS vector
    """
    meeting = await meetings_controller.get_by_id(meeting_id)
    if not meeting:
        raise HTTPException(status_code=404, detail="Meeting not found")
    log = logger.bind(
        meeting_id=meeting_id,
        room_name=meeting.room_name,
        recording_type=body.type,
        instance_id=body.instanceId,
    )
    try:
        client = create_platform_client("daily")
        result = await client.start_recording(
            room_name=meeting.room_name,
            recording_type=body.type,
            instance_id=body.instanceId,
        )
        log.info(f"Started {body.type} recording via REST API")
        return {"status": "ok", "result": result}
    except DailyApiError as e:
        # Parse Daily.co error response to detect "has an active stream"
        try:
            error_body = json.loads(e.response_body)
            error_info = error_body.get("info", "")
            # "has an active stream" means recording already started by another participant
            # This is SUCCESS from business logic perspective - return 200
            if "has an active stream" in error_info:
                log.info(
                    f"{body.type} recording already active (started by another participant)"
                )
                return {"status": "already_active", "instanceId": str(body.instanceId)}
        except (json.JSONDecodeError, KeyError):
            pass  # Fall through to error handling
        # All other Daily.co API errors
        log.error(f"Failed to start {body.type} recording", error=str(e))
        raise HTTPException(
            status_code=500, detail=f"Failed to start recording: {str(e)}"
        )
    except Exception as e:
        # Non-Daily.co errors
        log.error(f"Failed to start {body.type} recording", error=str(e))
        raise HTTPException(
            status_code=500, detail=f"Failed to start recording: {str(e)}"
        )
--- a/server/reflector/views/rooms.py
+++ b/server/reflector/views/rooms.py
@@ -73,6 +73,8 @@ class Meeting(BaseModel):
    calendar_event_id: str | None = None
    calendar_metadata: dict[str, Any] | None = None
    platform: Platform
    daily_composed_video_s3_key: str | None = None
    daily_composed_video_duration: int | None = None
 class CreateRoom(BaseModel):
@@ -586,7 +588,6 @@ async def rooms_join_meeting(
        )
        token = await client.create_meeting_token(
            meeting.room_name,
            start_cloud_recording=meeting.recording_type == "cloud",
            enable_recording_ui=enable_recording_ui,
            user_id=user_id,
            is_owner=user_id == room.user_id,
--- a/server/reflector/worker/app.py
+++ b/server/reflector/worker/app.py
@@ -6,6 +6,11 @@ from celery.schedules import crontab
 from reflector.settings import settings
 logger = structlog.get_logger(__name__)
 # Polling intervals (seconds)
 # Webhook-aware: 180s when webhook configured (backup mode), 15s when no webhook (primary discovery)
 POLL_DAILY_RECORDINGS_INTERVAL_SEC = 180.0 if settings.DAILY_WEBHOOK_SECRET else 15.0
 if celery.current_app.main != "default":
    logger.info(f"Celery already configured ({celery.current_app})")
    app = celery.current_app
@@ -44,7 +49,7 @@ else:
        },
        "poll_daily_recordings": {
            "task": "reflector.worker.process.poll_daily_recordings",
-            "schedule": 180.0,  # Every 3 minutes (configurable lookback window)
+            "schedule": POLL_DAILY_RECORDINGS_INTERVAL_SEC,
        },
        "trigger_daily_reconciliation": {
            "task": "reflector.worker.process.trigger_daily_reconciliation",
--- a/server/reflector/worker/process.py
+++ b/server/reflector/worker/process.py
@@ -2,7 +2,7 @@ import json
 import os
 import re
 from datetime import datetime, timezone
-from typing import List
+from typing import List, Literal
 from urllib.parse import unquote
 import av
@@ -42,6 +42,7 @@ from reflector.utils.daily import (
    filter_cam_audio_tracks,
    recording_lock_key,
 )
 from reflector.utils.string import NonEmptyString
 from reflector.video_platforms.factory import create_platform_client
 from reflector.video_platforms.whereby_utils import (
    parse_whereby_recording_filename,
@@ -175,13 +176,18 @@ async def process_multitrack_recording(
    daily_room_name: DailyRoomName,
    recording_id: str,
    track_keys: list[str],
    recording_start_ts: int,
 ):
    """
    Process raw-tracks (multitrack) recording from Daily.co.
    """
    logger.info(
        "Processing multitrack recording",
        bucket=bucket_name,
        room_name=daily_room_name,
        recording_id=recording_id,
        provided_keys=len(track_keys),
        recording_start_ts=recording_start_ts,
    )
    if not track_keys:
@@ -212,7 +218,7 @@ async def process_multitrack_recording(
        )
        await _process_multitrack_recording_inner(
-            bucket_name, daily_room_name, recording_id, track_keys
+            bucket_name, daily_room_name, recording_id, track_keys, recording_start_ts
        )
@@ -221,8 +227,18 @@ async def _process_multitrack_recording_inner(
    daily_room_name: DailyRoomName,
    recording_id: str,
    track_keys: list[str],
    recording_start_ts: int,
 ):
-    """Inner function containing the actual processing logic."""
+    """
    Process multitrack recording (first time or reprocessing).
    For first processing (webhook/polling):
    - Uses recording_start_ts for time-based meeting matching (no instanceId available)
    For reprocessing:
    - Uses recording.meeting_id directly (already linked during first processing)
    - recording_start_ts is ignored
    """
    tz = timezone.utc
    recorded_at = datetime.now(tz)
@@ -240,7 +256,53 @@ async def _process_multitrack_recording_inner(
            exc_info=True,
        )
-    meeting = await meetings_controller.get_by_room_name(daily_room_name)
+    # Check if recording already exists (reprocessing path)
    recording = await recordings_controller.get_by_id(recording_id)
    if recording and recording.meeting_id:
        # Reprocessing: recording exists with meeting already linked
        meeting = await meetings_controller.get_by_id(recording.meeting_id)
        if not meeting:
            logger.error(
                "Reprocessing: meeting not found for recording - skipping",
                meeting_id=recording.meeting_id,
                recording_id=recording_id,
            )
            return
        logger.info(
            "Reprocessing: using existing recording.meeting_id",
            recording_id=recording_id,
            meeting_id=meeting.id,
            room_name=daily_room_name,
        )
    else:
        # First processing: recording doesn't exist, need time-based matching
        # (Daily.co doesn't return instanceId in API, must match by timestamp)
        recording_start = datetime.fromtimestamp(recording_start_ts, tz=timezone.utc)
        meeting = await meetings_controller.get_by_room_name_and_time(
            room_name=daily_room_name,
            recording_start=recording_start,
            time_window_hours=168,  # 1 week
        )
        if not meeting:
            logger.error(
                "Raw-tracks: no meeting found within 1-week window (time-based match) - skipping",
                recording_id=recording_id,
                room_name=daily_room_name,
                recording_start_ts=recording_start_ts,
                recording_start=recording_start.isoformat(),
            )
            return  # Skip processing, will retry on next poll
        logger.info(
            "First processing: found meeting via time-based matching",
            meeting_id=meeting.id,
            room_name=daily_room_name,
            recording_id=recording_id,
            time_delta_seconds=abs(
                (meeting.start_date - recording_start).total_seconds()
            ),
        )
    room_name_base = extract_base_room_name(daily_room_name)
@@ -248,18 +310,8 @@ async def _process_multitrack_recording_inner(
    if not room:
        raise Exception(f"Room not found: {room_name_base}")
    if not meeting:
        raise Exception(f"Meeting not found: {room_name_base}")
    logger.info(
        "Found existing Meeting for recording",
        meeting_id=meeting.id,
        room_name=daily_room_name,
        recording_id=recording_id,
    )
    recording = await recordings_controller.get_by_id(recording_id)
    if not recording:
        # Create recording (only happens during first processing)
        object_key_dir = os.path.dirname(track_keys[0]) if track_keys else ""
        recording = await recordings_controller.create(
            Recording(
@@ -271,7 +323,19 @@ async def _process_multitrack_recording_inner(
                track_keys=track_keys,
            )
        )
-    # else: Recording already exists; metadata set at creation time
+    elif not recording.meeting_id:
        # Recording exists but meeting_id is null (failed first processing)
        # Update with meeting from time-based matching
        await recordings_controller.set_meeting_id(
            recording_id=recording.id,
            meeting_id=meeting.id,
        )
        recording.meeting_id = meeting.id
        logger.info(
            "Updated existing recording with meeting_id",
            recording_id=recording.id,
            meeting_id=meeting.id,
        )
    transcript = await transcripts_controller.get_by_recording_id(recording.id)
    if not transcript:
@@ -287,11 +351,12 @@ async def _process_multitrack_recording_inner(
            room_id=room.id,
        )
-    use_hatchet = settings.HATCHET_ENABLED and room and room.use_hatchet
+    use_celery = room and room.use_celery
    use_hatchet = not use_celery
-    if room and room.use_hatchet and not settings.HATCHET_ENABLED:
+    if use_celery:
        logger.info(
-            "Room forces Hatchet workflow",
+            "Room uses legacy Celery processing",
            room_id=room.id,
            transcript_id=transcript.id,
        )
@@ -337,9 +402,11 @@ async def poll_daily_recordings():
    """Poll Daily.co API for recordings and process missing ones.
    Fetches latest recordings from Daily.co API (default limit 100), compares with DB,
-    and queues processing for recordings not already in DB.
+    and stores/queues missing recordings:
    - Cloud recordings: Store S3 key in meeting table
    - Raw-tracks recordings: Queue multitrack processing
-    For each missing recording, uses audio tracks from API response.
+    Acts as fallback when webhooks active, primary discovery when webhooks unavailable.
    Worker-level locking provides idempotency (see process_multitrack_recording).
    """
@@ -380,51 +447,222 @@ async def poll_daily_recordings():
        )
        return
-    recording_ids = [rec.id for rec in finished_recordings]
+    # Separate cloud and raw-tracks recordings
    cloud_recordings = []
    raw_tracks_recordings = []
    for rec in finished_recordings:
        if rec.type:
            # Daily.co API returns null type - make sure this assumption stays
            # If this logs, Daily.co API changed - we can remove inference logic.
            recording_type = rec.type
            logger.warning(
                "Recording has explicit type field from Daily.co API (unexpected, API may have changed)",
                recording_id=rec.id,
                room_name=rec.room_name,
                recording_type=recording_type,
                has_s3key=bool(rec.s3key),
                tracks_count=len(rec.tracks),
            )
        else:
            # DAILY.CO API LIMITATION:
            # GET /recordings response does NOT include type field.
            # Daily.co docs mention type field exists, but API never returns it.
            # Verified: 84 recordings from Nov 2025 - Jan 2026 ALL have type=None.
            #
            # This is not a recent API change - Daily.co has never returned type.
            # Must infer from structural properties.
            #
            # Inference heuristic (reliable for finished recordings):
            # - Has tracks array → raw-tracks
            # - Has s3key but no tracks → cloud
            # - Neither → failed/incomplete recording
            if len(rec.tracks) > 0:
                recording_type = "raw-tracks"
            elif rec.s3key and len(rec.tracks) == 0:
                recording_type = "cloud"
            else:
                logger.warning(
                    "Recording has no type, no s3key, and no tracks - likely failed recording",
                    recording_id=rec.id,
                    room_name=rec.room_name,
                    status=rec.status,
                    duration=rec.duration,
                    mtg_session_id=rec.mtgSessionId,
                )
                continue
        if recording_type == "cloud":
            cloud_recordings.append(rec)
        else:
            raw_tracks_recordings.append(rec)
    logger.debug(
        "Poll results",
        total=len(finished_recordings),
        cloud=len(cloud_recordings),
        raw_tracks=len(raw_tracks_recordings),
    )
    # Process cloud recordings
    await _poll_cloud_recordings(cloud_recordings)
    # Process raw-tracks recordings
    await _poll_raw_tracks_recordings(raw_tracks_recordings, bucket_name)
 async def store_cloud_recording(
    recording_id: NonEmptyString,
    room_name: NonEmptyString,
    s3_key: NonEmptyString,
    duration: int,
    start_ts: int,
    source: Literal["webhook", "polling"],
 ) -> bool:
    """
    Store cloud recording reference in meeting table.
    Common function for both webhook and polling code paths.
    Uses time-based matching to handle duplicate room_name values.
    Args:
        recording_id: Daily.co recording ID
        room_name: Daily.co room name
        s3_key: S3 key where recording is stored
        duration: Recording duration in seconds
        start_ts: Unix timestamp when recording started
        source: "webhook" or "polling" (for logging)
    Returns:
        True if stored, False if skipped/failed
    """
    recording_start = datetime.fromtimestamp(start_ts, tz=timezone.utc)
    meeting = await meetings_controller.get_by_room_name_and_time(
        room_name=room_name,
        recording_start=recording_start,
        time_window_hours=168,  # 1 week
    )
    if not meeting:
        logger.warning(
            f"Cloud recording ({source}): no meeting found within 1-week window",
            recording_id=recording_id,
            room_name=room_name,
            recording_start_ts=start_ts,
            recording_start=recording_start.isoformat(),
        )
        return False
    success = await meetings_controller.set_cloud_recording_if_missing(
        meeting_id=meeting.id,
        s3_key=s3_key,
        duration=duration,
    )
    if not success:
        logger.debug(
            f"Cloud recording ({source}): already set (race lost)",
            recording_id=recording_id,
            room_name=room_name,
            meeting_id=meeting.id,
        )
        return False
    logger.info(
        f"Cloud recording stored via {source} (time-based match)",
        meeting_id=meeting.id,
        recording_id=recording_id,
        s3_key=s3_key,
        duration=duration,
        time_delta_seconds=abs((meeting.start_date - recording_start).total_seconds()),
    )
    return True
 async def _poll_cloud_recordings(cloud_recordings: List[FinishedRecordingResponse]):
    """
    Store cloud recordings missing from meeting table via polling.
    Uses time-based matching via store_cloud_recording().
    """
    if not cloud_recordings:
        return
    stored_count = 0
    for recording in cloud_recordings:
        # Extract S3 key from recording (cloud recordings use s3key field)
        s3_key = recording.s3key or (recording.s3.key if recording.s3 else None)
        if not s3_key:
            logger.warning(
                "Cloud recording: missing S3 key",
                recording_id=recording.id,
                room_name=recording.room_name,
            )
            continue
        stored = await store_cloud_recording(
            recording_id=recording.id,
            room_name=recording.room_name,
            s3_key=s3_key,
            duration=recording.duration,
            start_ts=recording.start_ts,
            source="polling",
        )
        if stored:
            stored_count += 1
    logger.info(
        "Cloud recording polling complete",
        total=len(cloud_recordings),
        stored=stored_count,
    )
 async def _poll_raw_tracks_recordings(
    raw_tracks_recordings: List[FinishedRecordingResponse],
    bucket_name: str,
 ):
    """Queue raw-tracks recordings missing from DB (existing logic)."""
    if not raw_tracks_recordings:
        return
    recording_ids = [rec.id for rec in raw_tracks_recordings]
    existing_recordings = await recordings_controller.get_by_ids(recording_ids)
    existing_ids = {rec.id for rec in existing_recordings}
    missing_recordings = [
-        rec for rec in finished_recordings if rec.id not in existing_ids
+        rec for rec in raw_tracks_recordings if rec.id not in existing_ids
    ]
    if not missing_recordings:
        logger.debug(
-            "All recordings already in DB",
+            "All raw-tracks recordings already in DB",
-            api_count=len(finished_recordings),
+            api_count=len(raw_tracks_recordings),
            existing_count=len(existing_recordings),
        )
        return
    logger.info(
-        "Found recordings missing from DB",
+        "Found raw-tracks recordings missing from DB",
        missing_count=len(missing_recordings),
-        total_api_count=len(finished_recordings),
+        total_api_count=len(raw_tracks_recordings),
        existing_count=len(existing_recordings),
    )
    for recording in missing_recordings:
        if not recording.tracks:
-            if recording.status == "finished":
+            logger.warning(
-                logger.warning(
+                "Finished raw-tracks recording has no tracks (no audio captured)",
-                    "Finished recording has no tracks (no audio captured)",
+                recording_id=recording.id,
-                    recording_id=recording.id,
+                room_name=recording.room_name,
-                    room_name=recording.room_name,
+            )
                )
            else:
                logger.debug(
                    "No tracks in recording yet",
                    recording_id=recording.id,
                    room_name=recording.room_name,
                    status=recording.status,
                )
            continue
        track_keys = [t.s3Key for t in recording.tracks if t.type == "audio"]
        if not track_keys:
            logger.warning(
-                "No audio tracks found in recording (only video tracks)",
+                "No audio tracks found in raw-tracks recording",
                recording_id=recording.id,
                room_name=recording.room_name,
                total_tracks=len(recording.tracks),
@@ -432,7 +670,7 @@ async def poll_daily_recordings():
            continue
        logger.info(
-            "Queueing missing recording for processing",
+            "Queueing missing raw-tracks recording for processing",
            recording_id=recording.id,
            room_name=recording.room_name,
            track_count=len(track_keys),
@@ -443,6 +681,7 @@ async def poll_daily_recordings():
            daily_room_name=recording.room_name,
            recording_id=recording.id,
            track_keys=track_keys,
            recording_start_ts=recording.start_ts,
        )
@@ -810,7 +1049,6 @@ async def reprocess_failed_daily_recordings():
                )
                continue
            # Fetch room to check use_hatchet flag
            room = None
            if meeting.room_id:
                room = await rooms_controller.get_by_id(meeting.room_id)
@@ -834,10 +1072,10 @@ async def reprocess_failed_daily_recordings():
                )
                continue
-            use_hatchet = settings.HATCHET_ENABLED and room and room.use_hatchet
+            use_celery = room and room.use_celery
            use_hatchet = not use_celery
            if use_hatchet:
                # Hatchet requires a transcript for workflow_run_id tracking
                if not transcript:
                    logger.warning(
                        "No transcript for Hatchet reprocessing, skipping",
@@ -883,11 +1121,16 @@ async def reprocess_failed_daily_recordings():
                    transcript_status=transcript.status if transcript else None,
                )
                # For reprocessing, pass actual recording time (though it's ignored - see _process_multitrack_recording_inner)
                # Reprocessing uses recording.meeting_id directly instead of time-based matching
                recording_start_ts = int(recording.recorded_at.timestamp())
                process_multitrack_recording.delay(
                    bucket_name=bucket_name,
                    daily_room_name=meeting.room_name,
                    recording_id=recording.id,
                    track_keys=recording.track_keys,
                    recording_start_ts=recording_start_ts,
                )
            reprocessed_count += 1
--- a/server/runserver.sh
+++ b/server/runserver.sh
@@ -7,8 +7,10 @@ elif [ "${ENTRYPOINT}" = "worker" ]; then
    uv run celery -A reflector.worker.app worker --loglevel=info
 elif [ "${ENTRYPOINT}" = "beat" ]; then
    uv run celery -A reflector.worker.app beat --loglevel=info
-elif [ "${ENTRYPOINT}" = "hatchet-worker" ]; then
+elif [ "${ENTRYPOINT}" = "hatchet-worker-cpu" ]; then
-    uv run python -m reflector.hatchet.run_workers
+    uv run python -m reflector.hatchet.run_workers_cpu
 elif [ "${ENTRYPOINT}" = "hatchet-worker-llm" ]; then
    uv run python -m reflector.hatchet.run_workers_llm
 else
    echo "Unknown command"
 fi
--- a/server/tests/test_dailyco_instance_id.py
+++ b/server/tests/test_dailyco_instance_id.py
@@ -0,0 +1,147 @@
 """
 Tests for Daily.co instanceId generation.
 Verifies deterministic behavior and frontend/backend consistency.
 """
 import pytest
 from reflector.dailyco_api.instance_id import (
    RAW_TRACKS_NAMESPACE,
    generate_cloud_instance_id,
    generate_raw_tracks_instance_id,
 )
 class TestInstanceIdDeterminism:
    """Test deterministic generation of instanceIds."""
    def test_cloud_instance_id_is_meeting_id(self):
        """Cloud instanceId is meeting ID directly (implicitly tests determinism)."""
        meeting_id = "550e8400-e29b-41d4-a716-446655440000"
        result1 = generate_cloud_instance_id(meeting_id)
        result2 = generate_cloud_instance_id(meeting_id)
        assert str(result1) == meeting_id
        assert result1 == result2
    def test_raw_tracks_instance_id_deterministic(self):
        """Raw-tracks instanceId generation is deterministic."""
        meeting_id = "550e8400-e29b-41d4-a716-446655440000"
        result1 = generate_raw_tracks_instance_id(meeting_id)
        result2 = generate_raw_tracks_instance_id(meeting_id)
        assert result1 == result2
    def test_raw_tracks_different_from_cloud(self):
        """Raw-tracks instanceId differs from cloud instanceId."""
        meeting_id = "550e8400-e29b-41d4-a716-446655440000"
        cloud_id = generate_cloud_instance_id(meeting_id)
        raw_tracks_id = generate_raw_tracks_instance_id(meeting_id)
        assert cloud_id != raw_tracks_id
    def test_different_meetings_different_instance_ids(self):
        """Different meetings generate different instanceIds."""
        meeting_id1 = "550e8400-e29b-41d4-a716-446655440000"
        meeting_id2 = "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
        cloud1 = generate_cloud_instance_id(meeting_id1)
        cloud2 = generate_cloud_instance_id(meeting_id2)
        assert cloud1 != cloud2
        raw1 = generate_raw_tracks_instance_id(meeting_id1)
        raw2 = generate_raw_tracks_instance_id(meeting_id2)
        assert raw1 != raw2
 class TestFrontendBackendConsistency:
    """Test that backend matches frontend logic."""
    def test_namespace_matches_frontend(self):
        """Namespace UUID matches frontend RAW_TRACKS_NAMESPACE constant."""
        # From www/app/[roomName]/components/DailyRoom.tsx
        frontend_namespace = "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
        assert str(RAW_TRACKS_NAMESPACE) == frontend_namespace
    def test_raw_tracks_generation_matches_frontend_logic(self):
        """Backend UUIDv5 generation matches frontend uuidv5() call."""
        # Example meeting ID
        meeting_id = "550e8400-e29b-41d4-a716-446655440000"
        # Backend result
        backend_result = generate_raw_tracks_instance_id(meeting_id)
        # Expected result from frontend: uuidv5(meeting.id, RAW_TRACKS_NAMESPACE)
        # Python uuid5 uses (namespace, name) argument order
        # JavaScript uuid.v5(name, namespace) - same args, different order
        # Frontend: uuidv5(meeting.id, "a1b2c3d4-e5f6-7890-abcd-ef1234567890")
        # Backend: uuid5(UUID("a1b2c3d4-e5f6-7890-abcd-ef1234567890"), meeting.id)
        # Verify it's a valid UUID (will raise if not)
        assert len(str(backend_result)) == 36
        assert backend_result.version == 5
 class TestEdgeCases:
    """Test edge cases and error conditions."""
    def test_invalid_uuid_format_raises(self):
        """Invalid UUID format raises ValueError."""
        with pytest.raises(ValueError):
            generate_cloud_instance_id("not-a-uuid")
    def test_lowercase_uuid_normalized_for_cloud(self):
        """Cloud instanceId: lowercase/uppercase UUIDs produce same result."""
        meeting_id_lower = "550e8400-e29b-41d4-a716-446655440000"
        meeting_id_upper = "550E8400-E29B-41D4-A716-446655440000"
        cloud_lower = generate_cloud_instance_id(meeting_id_lower)
        cloud_upper = generate_cloud_instance_id(meeting_id_upper)
        assert cloud_lower == cloud_upper
    def test_uuid5_is_case_sensitive_warning(self):
        """
        Documents uuid5 case sensitivity - different case UUIDs produce different hashes.
        Not a problem: meeting.id always lowercase from DB and API.
        Frontend generates raw-tracks instanceId from lowercase meeting.id.
        Backend receives lowercase meeting_id when matching.
        This test documents the behavior, not a requirement.
        """
        meeting_id_lower = "550e8400-e29b-41d4-a716-446655440000"
        meeting_id_upper = "550E8400-E29B-41D4-A716-446655440000"
        raw_lower = generate_raw_tracks_instance_id(meeting_id_lower)
        raw_upper = generate_raw_tracks_instance_id(meeting_id_upper)
        assert raw_lower != raw_upper
 class TestMtgSessionIdVsInstanceId:
    """
    Documents that Daily.co's mtgSessionId differs from our instanceId.
    Why this matters: We investigated using mtgSessionId for matching but discovered
    it's Daily.co-generated and unrelated to instanceId we send. This test documents
    that finding so we don't investigate it again.
    Production data from 2026-01-13:
    - Meeting ID:            4ad503b6-8189-4910-a8f7-68cdd1b7f990
    - Cloud instanceId:      4ad503b6-8189-4910-a8f7-68cdd1b7f990 (same as meeting ID)
    - Raw-tracks instanceId: 784b3af3-c7dd-57f0-ac54-2ee91c6927cb (UUIDv5 derived)
    - Recording mtgSessionId: f25a2e09-740f-4932-9c0d-b1bebaa669c6 (different!)
    Conclusion: Cannot use mtgSessionId for recording-to-meeting matching.
    """
    def test_mtg_session_id_differs_from_our_instance_ids(self):
        """mtgSessionId (Daily.co) != instanceId (ours) for both cloud and raw-tracks."""
        meeting_id = "4ad503b6-8189-4910-a8f7-68cdd1b7f990"
        expected_raw_tracks_id = "784b3af3-c7dd-57f0-ac54-2ee91c6927cb"
        mtg_session_id = "f25a2e09-740f-4932-9c0d-b1bebaa669c6"
        cloud_instance_id = generate_cloud_instance_id(meeting_id)
        raw_tracks_instance_id = generate_raw_tracks_instance_id(meeting_id)
        assert str(cloud_instance_id) == meeting_id
        assert str(raw_tracks_instance_id) == expected_raw_tracks_id
        assert str(cloud_instance_id) != mtg_session_id
        assert str(raw_tracks_instance_id) != mtg_session_id
--- a/server/tests/test_hatchet_dispatch.py
+++ b/server/tests/test_hatchet_dispatch.py
@@ -2,10 +2,9 @@
 Tests for Hatchet workflow dispatch and routing logic.
 These tests verify:
-1. Routing to Hatchet when HATCHET_ENABLED=True
+1. Hatchet workflow validation and replay logic
-2. Replay logic for failed workflows
+2. Force flag to cancel and restart workflows
-3. Force flag to cancel and restart
+3. Validation prevents concurrent workflows
 4. Validation prevents concurrent workflows
 """
 from unittest.mock import AsyncMock, patch
@@ -34,25 +33,22 @@ async def test_hatchet_validation_blocks_running_workflow():
        workflow_run_id="running-workflow-123",
    )
-    with patch("reflector.services.transcript_process.settings") as mock_settings:
+    with patch(
-        mock_settings.HATCHET_ENABLED = True
+        "reflector.services.transcript_process.HatchetClientManager"
    ) as mock_hatchet:
        mock_hatchet.get_workflow_run_status = AsyncMock(
            return_value=V1TaskStatus.RUNNING
        )
        with patch(
-            "reflector.services.transcript_process.HatchetClientManager"
+            "reflector.services.transcript_process.task_is_scheduled_or_active"
-        ) as mock_hatchet:
+        ) as mock_celery_check:
-            mock_hatchet.get_workflow_run_status = AsyncMock(
+            mock_celery_check.return_value = False
                return_value=V1TaskStatus.RUNNING
            )
-            with patch(
+            result = await validate_transcript_for_processing(mock_transcript)
                "reflector.services.transcript_process.task_is_scheduled_or_active"
            ) as mock_celery_check:
                mock_celery_check.return_value = False
-                result = await validate_transcript_for_processing(mock_transcript)
+        assert isinstance(result, ValidationAlreadyScheduled)
-
+        assert "running" in result.detail.lower()
            assert isinstance(result, ValidationAlreadyScheduled)
            assert "running" in result.detail.lower()
@pytest.mark.usefixtures("setup_database")
@@ -72,24 +68,21 @@ async def test_hatchet_validation_blocks_queued_workflow():
        workflow_run_id="queued-workflow-123",
    )
-    with patch("reflector.services.transcript_process.settings") as mock_settings:
+    with patch(
-        mock_settings.HATCHET_ENABLED = True
+        "reflector.services.transcript_process.HatchetClientManager"
    ) as mock_hatchet:
        mock_hatchet.get_workflow_run_status = AsyncMock(
            return_value=V1TaskStatus.QUEUED
        )
        with patch(
-            "reflector.services.transcript_process.HatchetClientManager"
+            "reflector.services.transcript_process.task_is_scheduled_or_active"
-        ) as mock_hatchet:
+        ) as mock_celery_check:
-            mock_hatchet.get_workflow_run_status = AsyncMock(
+            mock_celery_check.return_value = False
                return_value=V1TaskStatus.QUEUED
            )
-            with patch(
+            result = await validate_transcript_for_processing(mock_transcript)
                "reflector.services.transcript_process.task_is_scheduled_or_active"
            ) as mock_celery_check:
                mock_celery_check.return_value = False
-                result = await validate_transcript_for_processing(mock_transcript)
+        assert isinstance(result, ValidationAlreadyScheduled)
            assert isinstance(result, ValidationAlreadyScheduled)
@pytest.mark.usefixtures("setup_database")
@@ -110,25 +103,22 @@ async def test_hatchet_validation_allows_failed_workflow():
        recording_id="test-recording-id",
    )
-    with patch("reflector.services.transcript_process.settings") as mock_settings:
+    with patch(
-        mock_settings.HATCHET_ENABLED = True
+        "reflector.services.transcript_process.HatchetClientManager"
    ) as mock_hatchet:
        mock_hatchet.get_workflow_run_status = AsyncMock(
            return_value=V1TaskStatus.FAILED
        )
        with patch(
-            "reflector.services.transcript_process.HatchetClientManager"
+            "reflector.services.transcript_process.task_is_scheduled_or_active"
-        ) as mock_hatchet:
+        ) as mock_celery_check:
-            mock_hatchet.get_workflow_run_status = AsyncMock(
+            mock_celery_check.return_value = False
                return_value=V1TaskStatus.FAILED
            )
-            with patch(
+            result = await validate_transcript_for_processing(mock_transcript)
                "reflector.services.transcript_process.task_is_scheduled_or_active"
            ) as mock_celery_check:
                mock_celery_check.return_value = False
-                result = await validate_transcript_for_processing(mock_transcript)
+        assert isinstance(result, ValidationOk)
-
+        assert result.transcript_id == "test-transcript-id"
            assert isinstance(result, ValidationOk)
            assert result.transcript_id == "test-transcript-id"
@pytest.mark.usefixtures("setup_database")
@@ -149,24 +139,21 @@ async def test_hatchet_validation_allows_completed_workflow():
        recording_id="test-recording-id",
    )
-    with patch("reflector.services.transcript_process.settings") as mock_settings:
+    with patch(
-        mock_settings.HATCHET_ENABLED = True
+        "reflector.services.transcript_process.HatchetClientManager"
    ) as mock_hatchet:
        mock_hatchet.get_workflow_run_status = AsyncMock(
            return_value=V1TaskStatus.COMPLETED
        )
        with patch(
-            "reflector.services.transcript_process.HatchetClientManager"
+            "reflector.services.transcript_process.task_is_scheduled_or_active"
-        ) as mock_hatchet:
+        ) as mock_celery_check:
-            mock_hatchet.get_workflow_run_status = AsyncMock(
+            mock_celery_check.return_value = False
                return_value=V1TaskStatus.COMPLETED
            )
-            with patch(
+            result = await validate_transcript_for_processing(mock_transcript)
                "reflector.services.transcript_process.task_is_scheduled_or_active"
            ) as mock_celery_check:
                mock_celery_check.return_value = False
-                result = await validate_transcript_for_processing(mock_transcript)
+        assert isinstance(result, ValidationOk)
            assert isinstance(result, ValidationOk)
@pytest.mark.usefixtures("setup_database")
@@ -187,26 +174,23 @@ async def test_hatchet_validation_allows_when_status_check_fails():
        recording_id="test-recording-id",
    )
-    with patch("reflector.services.transcript_process.settings") as mock_settings:
+    with patch(
-        mock_settings.HATCHET_ENABLED = True
+        "reflector.services.transcript_process.HatchetClientManager"
    ) as mock_hatchet:
        # Status check fails (workflow might be deleted)
        mock_hatchet.get_workflow_run_status = AsyncMock(
            side_effect=ApiException("Workflow not found")
        )
        with patch(
-            "reflector.services.transcript_process.HatchetClientManager"
+            "reflector.services.transcript_process.task_is_scheduled_or_active"
-        ) as mock_hatchet:
+        ) as mock_celery_check:
-            # Status check fails (workflow might be deleted)
+            mock_celery_check.return_value = False
            mock_hatchet.get_workflow_run_status = AsyncMock(
                side_effect=ApiException("Workflow not found")
            )
-            with patch(
+            result = await validate_transcript_for_processing(mock_transcript)
                "reflector.services.transcript_process.task_is_scheduled_or_active"
            ) as mock_celery_check:
                mock_celery_check.return_value = False
-                result = await validate_transcript_for_processing(mock_transcript)
+        # Should allow processing when we can't get status
-
+        assert isinstance(result, ValidationOk)
            # Should allow processing when we can't get status
            assert isinstance(result, ValidationOk)
@pytest.mark.usefixtures("setup_database")
@@ -227,47 +211,11 @@ async def test_hatchet_validation_skipped_when_no_workflow_id():
        recording_id="test-recording-id",
    )
-    with patch("reflector.services.transcript_process.settings") as mock_settings:
+    with patch(
-        mock_settings.HATCHET_ENABLED = True
+        "reflector.services.transcript_process.HatchetClientManager"
-
+    ) as mock_hatchet:
-        with patch(
+        # Should not be called
-            "reflector.services.transcript_process.HatchetClientManager"
+        mock_hatchet.get_workflow_run_status = AsyncMock()
        ) as mock_hatchet:
            # Should not be called
            mock_hatchet.get_workflow_run_status = AsyncMock()
            with patch(
                "reflector.services.transcript_process.task_is_scheduled_or_active"
            ) as mock_celery_check:
                mock_celery_check.return_value = False
                result = await validate_transcript_for_processing(mock_transcript)
            # Should not check Hatchet status
            mock_hatchet.get_workflow_run_status.assert_not_called()
            assert isinstance(result, ValidationOk)
@pytest.mark.usefixtures("setup_database")
@pytest.mark.asyncio
 async def test_hatchet_validation_skipped_when_disabled():
    """Test that Hatchet validation is skipped when HATCHET_ENABLED is False."""
    from reflector.services.transcript_process import (
        ValidationOk,
        validate_transcript_for_processing,
    )
    mock_transcript = Transcript(
        id="test-transcript-id",
        name="Test",
        status="uploaded",
        source_kind="room",
        workflow_run_id="some-workflow-123",
        recording_id="test-recording-id",
    )
    with patch("reflector.services.transcript_process.settings") as mock_settings:
        mock_settings.HATCHET_ENABLED = False  # Hatchet disabled
        with patch(
            "reflector.services.transcript_process.task_is_scheduled_or_active"
@@ -276,7 +224,8 @@ async def test_hatchet_validation_skipped_when_disabled():
            result = await validate_transcript_for_processing(mock_transcript)
-        # Should not check Hatchet at all
+        # Should not check Hatchet status
        mock_hatchet.get_workflow_run_status.assert_not_called()
        assert isinstance(result, ValidationOk)
--- a/server/tests/test_ics_sync.py
+++ b/server/tests/test_ics_sync.py
@@ -189,14 +189,17 @@ async def test_ics_sync_service_sync_room_calendar():
        assert events[0].ics_uid == "sync-event-1"
        assert events[0].title == "Sync Test Meeting"
-        # Second sync with same content (should be unchanged)
+        # Second sync with same content (calendar unchanged, but sync always runs)
        # Refresh room to get updated etag and force sync by setting old sync time
        room = await rooms_controller.get_by_id(room.id)
        await rooms_controller.update(
            room, {"ics_last_sync": datetime.now(timezone.utc) - timedelta(minutes=10)}
        )
        result = await sync_service.sync_room_calendar(room)
-        assert result["status"] == "unchanged"
+        assert result["status"] == "success"
        assert result["events_created"] == 0
        assert result["events_updated"] == 0
        assert result["events_deleted"] == 0
        # Third sync with updated event
        event["summary"] = "Updated Meeting Title"
@@ -288,3 +291,43 @@ async def test_ics_sync_service_error_handling():
        result = await sync_service.sync_room_calendar(room)
        assert result["status"] == "error"
        assert "Network error" in result["error"]
@pytest.mark.asyncio
 async def test_event_data_changed_exhaustiveness():
    """Test that _event_data_changed compares all EventData fields (except ics_uid).
    This test ensures programmers don't forget to update the comparison logic
    when adding new fields to EventData/CalendarEvent.
    """
    from reflector.services.ics_sync import EventData
    sync_service = ICSSyncService()
    from reflector.db.calendar_events import CalendarEvent
    now = datetime.now(timezone.utc)
    event_data: EventData = {
        "ics_uid": "test-123",
        "title": "Test",
        "description": "Desc",
        "location": "Loc",
        "start_time": now,
        "end_time": now + timedelta(hours=1),
        "attendees": [],
        "ics_raw_data": "raw",
    }
    existing = CalendarEvent(
        room_id="room1",
        **event_data,
    )
    # Will raise RuntimeError if fields are missing from comparison
    result = sync_service._event_data_changed(existing, event_data)
    assert result is False
    modified_data = event_data.copy()
    modified_data["title"] = "Changed Title"
    result = sync_service._event_data_changed(existing, modified_data)
    assert result is True
--- a/server/tests/test_time_based_meeting_matching.py
+++ b/server/tests/test_time_based_meeting_matching.py
@@ -0,0 +1,374 @@
 """
 Integration tests for time-based meeting-to-recording matching.
 Tests the critical path for matching Daily.co recordings to meetings when
 API doesn't return instanceId.
 """
 from datetime import datetime, timedelta, timezone
 import pytest
 from reflector.db.meetings import meetings_controller
 from reflector.db.rooms import rooms_controller
@pytest.fixture
 async def test_room():
    """Create a test room for meetings."""
    room = await rooms_controller.add(
        name="test-room-time",
        user_id="test-user-id",
        zulip_auto_post=False,
        zulip_stream="",
        zulip_topic="",
        is_locked=False,
        room_mode="normal",
        recording_type="cloud",
        recording_trigger="automatic",
        is_shared=False,
        platform="daily",
    )
    return room
@pytest.fixture
 def base_time():
    """Fixed timestamp for deterministic tests."""
    return datetime(2026, 1, 14, 9, 0, 0, tzinfo=timezone.utc)
 class TestTimeBasedMatching:
    """Test get_by_room_name_and_time() matching logic."""
    async def test_exact_time_match(self, test_room, base_time):
        """Recording timestamp exactly matches meeting start_date."""
        meeting = await meetings_controller.create(
            id="meeting-exact",
            room_name="daily-test-20260114090000",
            room_url="https://example.daily.co/test",
            host_room_url="https://example.daily.co/test?t=host",
            start_date=base_time,
            end_date=base_time + timedelta(hours=1),
            room=test_room,
        )
        result = await meetings_controller.get_by_room_name_and_time(
            room_name="daily-test-20260114090000",
            recording_start=base_time,
            time_window_hours=168,
        )
        assert result is not None
        assert result.id == meeting.id
    async def test_recording_slightly_after_meeting_start(self, test_room, base_time):
        """Recording started 1 minute after meeting (participants joined late)."""
        meeting = await meetings_controller.create(
            id="meeting-late",
            room_name="daily-test-20260114090100",
            room_url="https://example.daily.co/test",
            host_room_url="https://example.daily.co/test?t=host",
            start_date=base_time,
            end_date=base_time + timedelta(hours=1),
            room=test_room,
        )
        recording_start = base_time + timedelta(minutes=1)
        result = await meetings_controller.get_by_room_name_and_time(
            room_name="daily-test-20260114090100",
            recording_start=recording_start,
            time_window_hours=168,
        )
        assert result is not None
        assert result.id == meeting.id
    async def test_duplicate_room_names_picks_closest(self, test_room, base_time):
        """
        Two meetings with same room_name (duplicate/race condition).
        Should pick closest by timestamp.
        """
        meeting1 = await meetings_controller.create(
            id="meeting-1-first",
            room_name="daily-duplicate-room",
            room_url="https://example.daily.co/test",
            host_room_url="https://example.daily.co/test?t=host",
            start_date=base_time,
            end_date=base_time + timedelta(hours=1),
            room=test_room,
        )
        meeting2 = await meetings_controller.create(
            id="meeting-2-second",
            room_name="daily-duplicate-room",  # Same room_name!
            room_url="https://example.daily.co/test",
            host_room_url="https://example.daily.co/test?t=host",
            start_date=base_time + timedelta(seconds=0.99),  # 0.99s later
            end_date=base_time + timedelta(hours=1),
            room=test_room,
        )
        # Recording started 0.5s after meeting1
        # Distance: meeting1 = 0.5s, meeting2 = 0.49s → meeting2 is closer
        recording_start = base_time + timedelta(seconds=0.5)
        result = await meetings_controller.get_by_room_name_and_time(
            room_name="daily-duplicate-room",
            recording_start=recording_start,
            time_window_hours=168,
        )
        assert result is not None
        assert result.id == meeting2.id  # meeting2 is closer (0.49s vs 0.5s)
    async def test_outside_time_window_returns_none(self, test_room, base_time):
        """Recording outside 1-week window returns None."""
        await meetings_controller.create(
            id="meeting-old",
            room_name="daily-test-old",
            room_url="https://example.daily.co/test",
            host_room_url="https://example.daily.co/test?t=host",
            start_date=base_time,
            end_date=base_time + timedelta(hours=1),
            room=test_room,
        )
        # Recording 8 days later (outside 7-day window)
        recording_start = base_time + timedelta(days=8)
        result = await meetings_controller.get_by_room_name_and_time(
            room_name="daily-test-old",
            recording_start=recording_start,
            time_window_hours=168,
        )
        assert result is None
    async def test_tie_breaker_deterministic(self, test_room, base_time):
        """When time delta identical, tie-breaker by meeting.id is deterministic."""
        meeting_z = await meetings_controller.create(
            id="zzz-last-uuid",
            room_name="daily-test-tie",
            room_url="https://example.daily.co/test",
            host_room_url="https://example.daily.co/test?t=host",
            start_date=base_time,
            end_date=base_time + timedelta(hours=1),
            room=test_room,
        )
        meeting_a = await meetings_controller.create(
            id="aaa-first-uuid",
            room_name="daily-test-tie",
            room_url="https://example.daily.co/test",
            host_room_url="https://example.daily.co/test?t=host",
            start_date=base_time,  # Exact same start_date
            end_date=base_time + timedelta(hours=1),
            room=test_room,
        )
        result = await meetings_controller.get_by_room_name_and_time(
            room_name="daily-test-tie",
            recording_start=base_time,
            time_window_hours=168,
        )
        assert result is not None
        # Tie-breaker: lexicographically first UUID
        assert result.id == "aaa-first-uuid"
    async def test_timezone_naive_datetime_raises(self, test_room, base_time):
        """Timezone-naive datetime raises ValueError."""
        await meetings_controller.create(
            id="meeting-tz",
            room_name="daily-test-tz",
            room_url="https://example.daily.co/test",
            host_room_url="https://example.daily.co/test?t=host",
            start_date=base_time,
            end_date=base_time + timedelta(hours=1),
            room=test_room,
        )
        # Naive datetime (no timezone)
        naive_dt = datetime(2026, 1, 14, 9, 0, 0)
        with pytest.raises(ValueError, match="timezone-aware"):
            await meetings_controller.get_by_room_name_and_time(
                room_name="daily-test-tz",
                recording_start=naive_dt,
                time_window_hours=168,
            )
    async def test_one_week_boundary_after_included(self, test_room, base_time):
        """Meeting 1-week AFTER recording is included (window_end boundary)."""
        meeting_time = base_time + timedelta(hours=168)
        await meetings_controller.create(
            id="meeting-boundary-after",
            room_name="daily-test-boundary-after",
            room_url="https://example.daily.co/test",
            host_room_url="https://example.daily.co/test?t=host",
            start_date=meeting_time,
            end_date=meeting_time + timedelta(hours=1),
            room=test_room,
        )
        result = await meetings_controller.get_by_room_name_and_time(
            room_name="daily-test-boundary-after",
            recording_start=base_time,
            time_window_hours=168,
        )
        assert result is not None
        assert result.id == "meeting-boundary-after"
    async def test_one_week_boundary_before_included(self, test_room, base_time):
        """Meeting 1-week BEFORE recording is included (window_start boundary)."""
        meeting_time = base_time - timedelta(hours=168)
        await meetings_controller.create(
            id="meeting-boundary-before",
            room_name="daily-test-boundary-before",
            room_url="https://example.daily.co/test",
            host_room_url="https://example.daily.co/test?t=host",
            start_date=meeting_time,
            end_date=meeting_time + timedelta(hours=1),
            room=test_room,
        )
        result = await meetings_controller.get_by_room_name_and_time(
            room_name="daily-test-boundary-before",
            recording_start=base_time,
            time_window_hours=168,
        )
        assert result is not None
        assert result.id == "meeting-boundary-before"
    async def test_recording_before_meeting_start(self, test_room, base_time):
        """Recording started before meeting (clock skew or early join)."""
        await meetings_controller.create(
            id="meeting-early",
            room_name="daily-test-early",
            room_url="https://example.daily.co/test",
            host_room_url="https://example.daily.co/test?t=host",
            start_date=base_time,
            end_date=base_time + timedelta(hours=1),
            room=test_room,
        )
        recording_start = base_time - timedelta(minutes=2)
        result = await meetings_controller.get_by_room_name_and_time(
            room_name="daily-test-early",
            recording_start=recording_start,
            time_window_hours=168,
        )
        assert result is not None
        assert result.id == "meeting-early"
    async def test_mixed_inside_outside_window(self, test_room, base_time):
        """Multiple meetings, only one inside window - returns the inside one."""
        await meetings_controller.create(
            id="meeting-old",
            room_name="daily-test-mixed",
            room_url="https://example.daily.co/test",
            host_room_url="https://example.daily.co/test?t=host",
            start_date=base_time - timedelta(days=10),
            end_date=base_time - timedelta(days=10, hours=-1),
            room=test_room,
        )
        await meetings_controller.create(
            id="meeting-inside",
            room_name="daily-test-mixed",
            room_url="https://example.daily.co/test",
            host_room_url="https://example.daily.co/test?t=host",
            start_date=base_time - timedelta(days=2),
            end_date=base_time - timedelta(days=2, hours=-1),
            room=test_room,
        )
        await meetings_controller.create(
            id="meeting-future",
            room_name="daily-test-mixed",
            room_url="https://example.daily.co/test",
            host_room_url="https://example.daily.co/test?t=host",
            start_date=base_time + timedelta(days=10),
            end_date=base_time + timedelta(days=10, hours=1),
            room=test_room,
        )
        result = await meetings_controller.get_by_room_name_and_time(
            room_name="daily-test-mixed",
            recording_start=base_time,
            time_window_hours=168,
        )
        assert result is not None
        assert result.id == "meeting-inside"
 class TestAtomicCloudRecordingUpdate:
    """Test atomic update prevents race conditions."""
    async def test_first_update_succeeds(self, test_room, base_time):
        """First call to set_cloud_recording_if_missing succeeds."""
        meeting = await meetings_controller.create(
            id="meeting-atomic-1",
            room_name="daily-test-atomic",
            room_url="https://example.daily.co/test",
            host_room_url="https://example.daily.co/test?t=host",
            start_date=base_time,
            end_date=base_time + timedelta(hours=1),
            room=test_room,
        )
        success = await meetings_controller.set_cloud_recording_if_missing(
            meeting_id=meeting.id,
            s3_key="first-s3-key",
            duration=100,
        )
        assert success is True
        updated = await meetings_controller.get_by_id(meeting.id)
        assert updated.daily_composed_video_s3_key == "first-s3-key"
        assert updated.daily_composed_video_duration == 100
    async def test_second_update_fails_atomically(self, test_room, base_time):
        """Second call to update same meeting doesn't overwrite (atomic check)."""
        meeting = await meetings_controller.create(
            id="meeting-atomic-2",
            room_name="daily-test-atomic2",
            room_url="https://example.daily.co/test",
            host_room_url="https://example.daily.co/test?t=host",
            start_date=base_time,
            end_date=base_time + timedelta(hours=1),
            room=test_room,
        )
        success1 = await meetings_controller.set_cloud_recording_if_missing(
            meeting_id=meeting.id,
            s3_key="first-s3-key",
            duration=100,
        )
        assert success1 is True
        after_first = await meetings_controller.get_by_id(meeting.id)
        assert after_first.daily_composed_video_s3_key == "first-s3-key"
        success2 = await meetings_controller.set_cloud_recording_if_missing(
            meeting_id=meeting.id,
            s3_key="bucket/path/should-not-overwrite",
            duration=200,
        )
        assert success2 is False
        final = await meetings_controller.get_by_id(meeting.id)
        assert final.daily_composed_video_s3_key == "first-s3-key"
        assert final.daily_composed_video_duration == 100
--- a/server/tests/test_transcripts_process.py
+++ b/server/tests/test_transcripts_process.py
@@ -162,9 +162,24 @@ async def test_dailyco_recording_uses_multitrack_pipeline(client):
    from datetime import datetime, timezone
    from reflector.db.recordings import Recording, recordings_controller
    from reflector.db.rooms import rooms_controller
    from reflector.db.transcripts import transcripts_controller
-    # Create transcript with Daily.co multitrack recording
+    room = await rooms_controller.add(
        name="test-room",
        user_id="test-user",
        zulip_auto_post=False,
        zulip_stream="",
        zulip_topic="",
        is_locked=False,
        room_mode="normal",
        recording_type="cloud",
        recording_trigger="automatic-2nd-participant",
        is_shared=False,
    )
    # Force Celery backend for test
    await rooms_controller.update(room, {"use_celery": True})
    transcript = await transcripts_controller.add(
        "",
        source_kind="room",
@@ -172,6 +187,7 @@ async def test_dailyco_recording_uses_multitrack_pipeline(client):
        target_language="en",
        user_id="test-user",
        share_mode="public",
        room_id=room.id,
    )
    track_keys = [
--- a/server/uv.lock
+++ b/server/uv.lock
@@ -159,21 +159,20 @@ wheels = [
 [[package]]
 name = "aiortc"
-version = "1.13.0"
+version = "1.14.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "aioice" },
    { name = "av" },
    { name = "cffi" },
    { name = "cryptography" },
    { name = "google-crc32c" },
    { name = "pyee" },
    { name = "pylibsrtp" },
    { name = "pyopenssl" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/62/03/bc947d74c548e0c17cf94e5d5bdacaed0ee9e5b2bb7b8b8cf1ac7a7c01ec/aiortc-1.13.0.tar.gz", hash = "sha256:5d209975c22d0910fb5a0f0e2caa828f2da966c53580f7c7170ac3a16a871620", size = 1179894 }
+sdist = { url = "https://files.pythonhosted.org/packages/51/9c/4e027bfe0195de0442da301e2389329496745d40ae44d2d7c4571c4290ce/aiortc-1.14.0.tar.gz", hash = "sha256:adc8a67ace10a085721e588e06a00358ed8eaf5f6b62f0a95358ff45628dd762", size = 1180864 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/87/29/765633cab5f1888890f5f172d1d53009b9b14e079cdfa01a62d9896a9ea9/aiortc-1.13.0-py3-none-any.whl", hash = "sha256:9ccccec98796f6a96bd1c3dd437a06da7e0f57521c96bd56e4b965a91b03a0a0", size = 92910 },
+    { url = "https://files.pythonhosted.org/packages/57/ab/31646a49209568cde3b97eeade0d28bb78b400e6645c56422c101df68932/aiortc-1.14.0-py3-none-any.whl", hash = "sha256:4b244d7e482f4e1f67e685b3468269628eca1ec91fa5b329ab517738cfca086e", size = 93183 },
 ]
 [[package]]
@@ -327,28 +326,24 @@ wheels = [
 [[package]]
 name = "av"
-version = "14.4.0"
+version = "16.1.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/86/f6/0b473dab52dfdea05f28f3578b1c56b6c796ce85e76951bab7c4e38d5a74/av-14.4.0.tar.gz", hash = "sha256:3ecbf803a7fdf67229c0edada0830d6bfaea4d10bfb24f0c3f4e607cd1064b42", size = 3892203 }
+sdist = { url = "https://files.pythonhosted.org/packages/78/cd/3a83ffbc3cc25b39721d174487fb0d51a76582f4a1703f98e46170ce83d4/av-16.1.0.tar.gz", hash = "sha256:a094b4fd87a3721dacf02794d3d2c82b8d712c85b9534437e82a8a978c175ffd", size = 4285203 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/18/8a/d57418b686ffd05fabd5a0a9cfa97e63b38c35d7101af00e87c51c8cc43c/av-14.4.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:5b21d5586a88b9fce0ab78e26bd1c38f8642f8e2aad5b35e619f4d202217c701", size = 19965048 },
+    { url = "https://files.pythonhosted.org/packages/48/d0/b71b65d1b36520dcb8291a2307d98b7fc12329a45614a303ff92ada4d723/av-16.1.0-cp311-cp311-macosx_11_0_x86_64.whl", hash = "sha256:e88ad64ee9d2b9c4c5d891f16c22ae78e725188b8926eb88187538d9dd0b232f", size = 26927747 },
-    { url = "https://files.pythonhosted.org/packages/f5/aa/3f878b0301efe587e9b07bb773dd6b47ef44ca09a3cffb4af50c08a170f3/av-14.4.0-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:cf8762d90b0f94a20c9f6e25a94f1757db5a256707964dfd0b1d4403e7a16835", size = 23750064 },
+    { url = "https://files.pythonhosted.org/packages/2f/79/720a5a6ccdee06eafa211b945b0a450e3a0b8fc3d12922f0f3c454d870d2/av-16.1.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:cb296073fa6935724de72593800ba86ae49ed48af03960a4aee34f8a611f442b", size = 21492232 },
-    { url = "https://files.pythonhosted.org/packages/9a/b4/6fe94a31f9ed3a927daa72df67c7151968587106f30f9f8fcd792b186633/av-14.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c0ac9f08920c7bbe0795319689d901e27cb3d7870b9a0acae3f26fc9daa801a6", size = 33648775 },
+    { url = "https://files.pythonhosted.org/packages/8e/4f/a1ba8d922f2f6d1a3d52419463ef26dd6c4d43ee364164a71b424b5ae204/av-16.1.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:720edd4d25aa73723c1532bb0597806d7b9af5ee34fc02358782c358cfe2f879", size = 39291737 },
-    { url = "https://files.pythonhosted.org/packages/6c/f3/7f3130753521d779450c935aec3f4beefc8d4645471159f27b54e896470c/av-14.4.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a56d9ad2afdb638ec0404e962dc570960aae7e08ae331ad7ff70fbe99a6cf40e", size = 32216915 },
+    { url = "https://files.pythonhosted.org/packages/1a/31/fc62b9fe8738d2693e18d99f040b219e26e8df894c10d065f27c6b4f07e3/av-16.1.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:c7f2bc703d0df260a1fdf4de4253c7f5500ca9fc57772ea241b0cb241bcf972e", size = 40846822 },
-    { url = "https://files.pythonhosted.org/packages/f8/9a/8ffabfcafb42154b4b3a67d63f9b69e68fa8c34cb39ddd5cb813dd049ed4/av-14.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6bed513cbcb3437d0ae47743edc1f5b4a113c0b66cdd4e1aafc533abf5b2fbf2", size = 35287279 },
+    { url = "https://files.pythonhosted.org/packages/53/10/ab446583dbce730000e8e6beec6ec3c2753e628c7f78f334a35cad0317f4/av-16.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d69c393809babada7d54964d56099e4b30a3e1f8b5736ca5e27bd7be0e0f3c83", size = 40675604 },
-    { url = "https://files.pythonhosted.org/packages/ad/11/7023ba0a2ca94a57aedf3114ab8cfcecb0819b50c30982a4c5be4d31df41/av-14.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d030c2d3647931e53d51f2f6e0fcf465263e7acf9ec6e4faa8dbfc77975318c3", size = 36294683 },
+    { url = "https://files.pythonhosted.org/packages/31/d7/1003be685277005f6d63fd9e64904ee222fe1f7a0ea70af313468bb597db/av-16.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:441892be28582356d53f282873c5a951592daaf71642c7f20165e3ddcb0b4c63", size = 42015955 },
-    { url = "https://files.pythonhosted.org/packages/3d/fa/b8ac9636bd5034e2b899354468bef9f4dadb067420a16d8a493a514b7817/av-14.4.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1cc21582a4f606271d8c2036ec7a6247df0831050306c55cf8a905701d0f0474", size = 34552391 },
+    { url = "https://files.pythonhosted.org/packages/2f/4a/fa2a38ee9306bf4579f556f94ecbc757520652eb91294d2a99c7cf7623b9/av-16.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:273a3e32de64819e4a1cd96341824299fe06f70c46f2288b5dc4173944f0fd62", size = 31750339 },
-    { url = "https://files.pythonhosted.org/packages/fb/29/0db48079c207d1cba7a2783896db5aec3816e17de55942262c244dffbc0f/av-14.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ce7c9cd452153d36f1b1478f904ed5f9ab191d76db873bdd3a597193290805d4", size = 37265250 },
+    { url = "https://files.pythonhosted.org/packages/9c/84/2535f55edcd426cebec02eb37b811b1b0c163f26b8d3f53b059e2ec32665/av-16.1.0-cp312-cp312-macosx_11_0_x86_64.whl", hash = "sha256:640f57b93f927fba8689f6966c956737ee95388a91bd0b8c8b5e0481f73513d6", size = 26945785 },
-    { url = "https://files.pythonhosted.org/packages/1c/55/715858c3feb7efa4d667ce83a829c8e6ee3862e297fb2b568da3f968639d/av-14.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:fd261e31cc6b43ca722f80656c39934199d8f2eb391e0147e704b6226acebc29", size = 27925845 },
+    { url = "https://files.pythonhosted.org/packages/b6/17/ffb940c9e490bf42e86db4db1ff426ee1559cd355a69609ec1efe4d3a9eb/av-16.1.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:ae3fb658eec00852ebd7412fdc141f17f3ddce8afee2d2e1cf366263ad2a3b35", size = 21481147 },
-    { url = "https://files.pythonhosted.org/packages/a6/75/b8641653780336c90ba89e5352cac0afa6256a86a150c7703c0b38851c6d/av-14.4.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:a53e682b239dd23b4e3bc9568cfb1168fc629ab01925fdb2e7556eb426339e94", size = 19954125 },
+    { url = "https://files.pythonhosted.org/packages/15/c1/e0d58003d2d83c3921887d5c8c9b8f5f7de9b58dc2194356a2656a45cfdc/av-16.1.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:27ee558d9c02a142eebcbe55578a6d817fedfde42ff5676275504e16d07a7f86", size = 39517197 },
-    { url = "https://files.pythonhosted.org/packages/99/e6/37fe6fa5853a48d54d749526365780a63a4bc530be6abf2115e3a21e292a/av-14.4.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:5aa0b901751a32703fa938d2155d56ce3faf3630e4a48d238b35d2f7e49e5395", size = 23751479 },
+    { url = "https://files.pythonhosted.org/packages/32/77/787797b43475d1b90626af76f80bfb0c12cfec5e11eafcfc4151b8c80218/av-16.1.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:7ae547f6d5fa31763f73900d43901e8c5fa6367bb9a9840978d57b5a7ae14ed2", size = 41174337 },
-    { url = "https://files.pythonhosted.org/packages/f7/75/9a5f0e6bda5f513b62bafd1cff2b495441a8b07ab7fb7b8e62f0c0d1683f/av-14.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3b316fed3597675fe2aacfed34e25fc9d5bb0196dc8c0b014ae5ed4adda48de", size = 33801401 },
+    { url = "https://files.pythonhosted.org/packages/8e/ac/d90df7f1e3b97fc5554cf45076df5045f1e0a6adf13899e10121229b826c/av-16.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8cf065f9d438e1921dc31fc7aa045790b58aee71736897866420d80b5450f62a", size = 40817720 },
-    { url = "https://files.pythonhosted.org/packages/6a/c9/e4df32a2ad1cb7f3a112d0ed610c5e43c89da80b63c60d60e3dc23793ec0/av-14.4.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a587b5c5014c3c0e16143a0f8d99874e46b5d0c50db6111aa0b54206b5687c81", size = 32364330 },
+    { url = "https://files.pythonhosted.org/packages/80/6f/13c3a35f9dbcebafd03fe0c4cbd075d71ac8968ec849a3cfce406c35a9d2/av-16.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a345877a9d3cc0f08e2bc4ec163ee83176864b92587afb9d08dff50f37a9a829", size = 42267396 },
-    { url = "https://files.pythonhosted.org/packages/ca/f0/64e7444a41817fde49a07d0239c033f7e9280bec4a4bb4784f5c79af95e6/av-14.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:10d53f75e8ac1ec8877a551c0db32a83c0aaeae719d05285281eaaba211bbc30", size = 35519508 },
+    { url = "https://files.pythonhosted.org/packages/c8/b9/275df9607f7fb44317ccb1d4be74827185c0d410f52b6e2cd770fe209118/av-16.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:f49243b1d27c91cd8c66fdba90a674e344eb8eb917264f36117bf2b6879118fd", size = 31752045 },
    { url = "https://files.pythonhosted.org/packages/c2/a8/a370099daa9033a3b6f9b9bd815304b3d8396907a14d09845f27467ba138/av-14.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c8558cfde79dd8fc92d97c70e0f0fa8c94c7a66f68ae73afdf58598f0fe5e10d", size = 36448593 },
    { url = "https://files.pythonhosted.org/packages/27/bb/edb6ceff8fa7259cb6330c51dbfbc98dd1912bd6eb5f7bc05a4bb14a9d6e/av-14.4.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:455b6410dea0ab2d30234ffb28df7d62ca3cdf10708528e247bec3a4cdcced09", size = 34701485 },
    { url = "https://files.pythonhosted.org/packages/a7/8a/957da1f581aa1faa9a5dfa8b47ca955edb47f2b76b949950933b457bfa1d/av-14.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1661efbe9d975f927b8512d654704223d936f39016fad2ddab00aee7c40f412c", size = 37521981 },
    { url = "https://files.pythonhosted.org/packages/28/76/3f1cf0568592f100fd68eb40ed8c491ce95ca3c1378cc2d4c1f6d1bd295d/av-14.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:fbbeef1f421a3461086853d6464ad5526b56ffe8ccb0ab3fd0a1f121dfbf26ad", size = 27925944 },
 ]
 [[package]]
@@ -3267,7 +3262,7 @@ requires-dist = [
    { name = "aiohttp-cors", specifier = ">=0.7.0" },
    { name = "aiortc", specifier = ">=1.5.0" },
    { name = "alembic", specifier = ">=1.11.3" },
-    { name = "av", specifier = ">=10.0.0" },
+    { name = "av", specifier = ">=15.0.0" },
    { name = "celery", specifier = ">=5.3.4" },
    { name = "databases", extras = ["aiosqlite", "asyncpg"], specifier = ">=0.7.0" },
    { name = "fastapi", extras = ["standard"], specifier = ">=0.100.1" },
--- a/www/app/(app)/rooms/page.tsx
+++ b/www/app/(app)/rooms/page.tsx
@@ -302,10 +302,10 @@ export default function RoomsList() {
        return;
      }
-      const platform: "whereby" | "daily" | null =
+      const platform: "whereby" | "daily" =
        room.platform === "whereby" || room.platform === "daily"
          ? room.platform
-          : null;
+          : "daily";
      const roomData = {
        name: room.name,
--- a/www/app/(app)/transcripts/[transcriptId]/_components/TopicList.tsx
+++ b/www/app/(app)/transcripts/[transcriptId]/_components/TopicList.tsx
@@ -1,12 +1,12 @@
 import React, { useState, useEffect } from "react";
 import ScrollToBottom from "../../scrollToBottom";
 import { Topic } from "../../webSocketTypes";
-import { Box, Flex, Text } from "@chakra-ui/react";
+import useParticipants from "../../useParticipants";
-import { formatTime } from "../../../../lib/time";
+import { Box, Flex, Text, Accordion } from "@chakra-ui/react";
-import { getTopicColor } from "../../../../lib/topicColors";
+import { TopicItem } from "./TopicItem";
 import { TranscriptStatus } from "../../../../lib/transcript";
 import { featureEnabled } from "../../../../lib/features";
 import { TOPICS_SCROLL_DIV_ID } from "./constants";
 type TopicListProps = {
  topics: Topic[];
@@ -18,7 +18,6 @@ type TopicListProps = {
  transcriptId: string;
  status: TranscriptStatus | null;
  currentTranscriptText: any;
  onTopicClick?: (topicId: string) => void;
 };
 export function TopicList({
@@ -28,13 +27,30 @@ export function TopicList({
  transcriptId,
  status,
  currentTranscriptText,
  onTopicClick,
 }: TopicListProps) {
  const [activeTopic, setActiveTopic] = useActiveTopic;
  const [hoveredTopicId, setHoveredTopicId] = useState<string | null>(null);
  const [autoscrollEnabled, setAutoscrollEnabled] = useState<boolean>(true);
  const participants = useParticipants(transcriptId);
-  const toggleScroll = (element: HTMLElement) => {
+  const scrollToTopic = () => {
    const topicDiv = document.getElementById(`topic-${activeTopic?.id}`);
    setTimeout(() => {
      topicDiv?.scrollIntoView({
        behavior: "smooth",
        block: "start",
        inline: "nearest",
      });
    }, 200);
  };
  useEffect(() => {
    if (activeTopic && autoscroll) scrollToTopic();
  }, [activeTopic, autoscroll]);
  // scroll top is not rounded, heights are, so exact match won't work.
  // https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollHeight#determine_if_an_element_has_been_totally_scrolled
  const toggleScroll = (element) => {
    const bottom =
      Math.abs(
        element.scrollHeight - element.clientHeight - element.scrollTop,
@@ -45,19 +61,14 @@ export function TopicList({
      setAutoscrollEnabled(true);
    }
  };
-
+  const handleScroll = (e) => {
-  const handleScroll = (e: React.UIEvent<HTMLDivElement>) => {
+    toggleScroll(e.target);
    toggleScroll(e.target as HTMLElement);
  };
  const scrollToBottom = () => {
    const topicsDiv = document.getElementById(TOPICS_SCROLL_DIV_ID);
    if (topicsDiv) topicsDiv.scrollTop = topicsDiv.scrollHeight;
  };
  useEffect(() => {
    if (autoscroll) {
-      const topicsDiv = document.getElementById(TOPICS_SCROLL_DIV_ID);
+      const topicsDiv = document.getElementById("scroll-div");
      topicsDiv && toggleScroll(topicsDiv);
    }
  }, [activeTopic, autoscroll]);
@@ -66,41 +77,37 @@ export function TopicList({
    if (autoscroll && autoscrollEnabled) scrollToBottom();
  }, [topics.length, currentTranscriptText]);
  const scrollToBottom = () => {
    const topicsDiv = document.getElementById("scroll-div");
    if (topicsDiv) topicsDiv.scrollTop = topicsDiv.scrollHeight;
  };
  const getSpeakerName = (speakerNumber: number) => {
    if (!participants.response) return;
    return (
      participants.response.find(
        (participant) => participant.speaker == speakerNumber,
      )?.name || `Speaker ${speakerNumber}`
    );
  };
  const requireLogin = featureEnabled("requireLogin");
  useEffect(() => {
    if (autoscroll) {
      setActiveTopic(topics[topics.length - 1]);
    }
  }, [topics, autoscroll]);
  const handleTopicClick = (topic: Topic) => {
    setActiveTopic(topic);
    if (onTopicClick) {
      onTopicClick(topic.id);
    }
  };
  const handleTopicMouseEnter = (topic: Topic) => {
    setHoveredTopicId(topic.id);
    // If already active, toggle off when mousing over
    if (activeTopic?.id === topic.id) {
      setActiveTopic(null);
    } else {
      setActiveTopic(topic);
    }
  };
  const handleTopicMouseLeave = () => {
    setHoveredTopicId(null);
  };
  const requireLogin = featureEnabled("requireLogin");
  return (
    <Flex
-      position="relative"
+      position={"relative"}
-      w="full"
+      w={"100%"}
-      h="200px"
+      h={"95%"}
-      flexDirection="column"
+      flexDirection={"column"}
      justify={"center"}
      align={"center"}
      flexShrink={0}
    >
      {autoscroll && (
@@ -111,71 +118,45 @@ export function TopicList({
      )}
      <Box
-        id={TOPICS_SCROLL_DIV_ID}
+        id="scroll-div"
-        overflowY="auto"
+        overflowY={"auto"}
-        h="full"
+        h={"100%"}
        onScroll={handleScroll}
        width="full"
      >
        {topics.length > 0 && (
-          <Flex direction="column" gap={1} p={2}>
+          <Accordion.Root
-            {topics.map((topic, index) => {
+            multiple={false}
-              const color = getTopicColor(index);
+            collapsible={true}
-              const isActive = activeTopic?.id === topic.id;
+            value={activeTopic ? [activeTopic.id] : []}
-              const isHovered = hoveredTopicId === topic.id;
+            onValueChange={(details) => {
-
+              const selectedTopicId = details.value[0];
-              return (
+              const selectedTopic = selectedTopicId
-                <Flex
+                ? topics.find((t) => t.id === selectedTopicId)
-                  key={topic.id}
+                : null;
-                  id={`topic-${topic.id}`}
+              setActiveTopic(selectedTopic || null);
-                  gap={2}
+            }}
-                  align="center"
+          >
-                  py={1}
+            {topics.map((topic) => (
-                  px={2}
+              <TopicItem
-                  cursor="pointer"
+                key={topic.id}
-                  bg={isActive || isHovered ? "gray.100" : "transparent"}
+                topic={topic}
-                  _hover={{ bg: "gray.50" }}
+                isActive={activeTopic?.id === topic.id}
-                  onClick={() => handleTopicClick(topic)}
+                getSpeakerName={getSpeakerName}
-                  onMouseEnter={() => handleTopicMouseEnter(topic)}
+              />
-                  onMouseLeave={handleTopicMouseLeave}
+            ))}
-                >
+          </Accordion.Root>
                  {/* Color indicator */}
                  <Box
                    w="12px"
                    h="12px"
                    borderRadius="full"
                    bg={color}
                    flexShrink={0}
                  />
                  {/* Topic title */}
                  <Text
                    flex={1}
                    fontSize="sm"
                    fontWeight={isActive ? "semibold" : "normal"}
                  >
                    {topic.title}
                  </Text>
                  {/* Timestamp */}
                  <Text as="span" color="gray.500" fontSize="xs" flexShrink={0}>
                    {formatTime(topic.timestamp)}
                  </Text>
                </Flex>
              );
            })}
          </Flex>
        )}
        {status == "recording" && (
-          <Box textAlign="center">
+          <Box textAlign={"center"}>
            <Text>{currentTranscriptText}</Text>
          </Box>
        )}
        {(status == "recording" || status == "idle") &&
          currentTranscriptText.length == 0 &&
          topics.length == 0 && (
-            <Box textAlign="center" color="gray">
+            <Box textAlign={"center"} color="gray">
              <Text>
                Full discussion transcript will appear here after you start
                recording.
@@ -186,7 +167,7 @@ export function TopicList({
            </Box>
          )}
        {status == "processing" && (
-          <Box textAlign="center" color="gray">
+          <Box textAlign={"center"} color="gray">
            <Text>We are processing the recording, please wait.</Text>
            {!requireLogin && (
              <span>
@@ -196,12 +177,12 @@ export function TopicList({
          </Box>
        )}
        {status == "ended" && topics.length == 0 && (
-          <Box textAlign="center" color="gray">
+          <Box textAlign={"center"} color="gray">
            <Text>Recording has ended without topics being found.</Text>
          </Box>
        )}
        {status == "error" && (
-          <Box textAlign="center" color="gray">
+          <Box textAlign={"center"} color="gray">
            <Text>There was an error processing your recording</Text>
          </Box>
        )}
--- a/www/app/(app)/transcripts/[transcriptId]/_components/TranscriptWithGutter.tsx
+++ b/www/app/(app)/transcripts/[transcriptId]/_components/TranscriptWithGutter.tsx
@@ -1,106 +0,0 @@
 import { Box, Text, IconButton } from "@chakra-ui/react";
 import { ChevronUp } from "lucide-react";
 import { Topic } from "../../webSocketTypes";
 import { getTopicColor } from "../../../../lib/topicColors";
 import { TOPICS_SCROLL_DIV_ID } from "./constants";
 interface TranscriptWithGutterProps {
  topics: Topic[];
  getSpeakerName: (speakerNumber: number) => string | undefined;
  onGutterClick: (topicId: string) => void;
 }
 export function TranscriptWithGutter({
  topics,
  getSpeakerName,
  onGutterClick,
 }: TranscriptWithGutterProps) {
  const scrollToTopics = () => {
    // Scroll to the topic list at the top
    const topicList = document.getElementById(TOPICS_SCROLL_DIV_ID);
    if (topicList) {
      topicList.scrollIntoView({
        behavior: "smooth",
        block: "start",
      });
    }
  };
  return (
    <Box>
      {topics.map((topic, topicIndex) => {
        const color = getTopicColor(topicIndex);
        return (
          <Box key={topic.id} position="relative">
            {/* Topic Header with Up Button */}
            <Box
              py={3}
              px={4}
              fontWeight="semibold"
              fontSize="lg"
              display="flex"
              alignItems="center"
              justifyContent="space-between"
            >
              <Text>{topic.title}</Text>
              <IconButton
                aria-label="Scroll to topics"
                size="sm"
                variant="ghost"
                onClick={scrollToTopics}
              >
                <ChevronUp size={16} />
              </IconButton>
            </Box>
            {/* Segments container with single gutter */}
            <Box position="relative">
              {/* Single continuous gutter for entire topic */}
              <Box
                className="topic-gutter"
                position="absolute"
                left={0}
                top={0}
                bottom={0}
                width="4px"
                bg={color}
                cursor="pointer"
                transition="all 0.2s"
                _hover={{
                  filter: "brightness(1.2)",
                  width: "6px",
                }}
                onClick={() => onGutterClick(topic.id)}
              />
              {/* Segments */}
              {topic.segments?.map((segment, segmentIndex) => (
                <Box
                  key={segmentIndex}
                  id={`segment-${topic.id}-${segmentIndex}`}
                  py={2}
                  px={4}
                  pl={12}
                  _hover={{
                    bg: "gray.50",
                  }}
                >
                  {/* Segment Content */}
                  <Text fontSize="sm">
                    <Text as="span" fontWeight="semibold" color="gray.700">
                      {getSpeakerName(segment.speaker) ||
                        `Speaker ${segment.speaker}`}
                      :
                    </Text>{" "}
                    {segment.text}
                  </Text>
                </Box>
              ))}
            </Box>
          </Box>
        );
      })}
    </Box>
  );
 }
--- a/www/app/(app)/transcripts/[transcriptId]/_components/constants.ts
+++ b/www/app/(app)/transcripts/[transcriptId]/_components/constants.ts
@@ -1 +0,0 @@
 export const TOPICS_SCROLL_DIV_ID = "topics-scroll-div";
--- a/www/app/(app)/transcripts/[transcriptId]/correct/page.tsx
+++ b/www/app/(app)/transcripts/[transcriptId]/correct/page.tsx
@@ -16,6 +16,7 @@ import {
 import { useError } from "../../../../(errors)/errorContext";
 import { useRouter } from "next/navigation";
 import { Box, Grid } from "@chakra-ui/react";
 import { parseNonEmptyString } from "../../../../lib/utils";
 export type TranscriptCorrect = {
  params: Promise<{
@@ -25,8 +26,7 @@ export type TranscriptCorrect = {
 export default function TranscriptCorrect(props: TranscriptCorrect) {
  const params = use(props.params);
-
+  const transcriptId = parseNonEmptyString(params.transcriptId);
  const { transcriptId } = params;
  const updateTranscriptMutation = useTranscriptUpdate();
  const transcript = useTranscriptGet(transcriptId);
--- a/www/app/(app)/transcripts/[transcriptId]/finalSummary.tsx
+++ b/www/app/(app)/transcripts/[transcriptId]/finalSummary.tsx
@@ -3,7 +3,8 @@ import React from "react";
 import Markdown from "react-markdown";
 import "../../../styles/markdown.css";
 import type { components } from "../../../reflector-api";
-type GetTranscript = components["schemas"]["GetTranscript"];
+type GetTranscriptWithParticipants =
  components["schemas"]["GetTranscriptWithParticipants"];
 type GetTranscriptTopic = components["schemas"]["GetTranscriptTopic"];
 import { useTranscriptUpdate } from "../../../lib/apiHooks";
 import {
@@ -18,7 +19,7 @@ import { LuPen } from "react-icons/lu";
 import { useError } from "../../../(errors)/errorContext";
 type FinalSummaryProps = {
-  transcript: GetTranscript;
+  transcript: GetTranscriptWithParticipants;
  topics: GetTranscriptTopic[];
  onUpdate: (newSummary: string) => void;
  finalSummaryRef: React.Dispatch<React.SetStateAction<HTMLDivElement | null>>;
--- a/www/app/(app)/transcripts/[transcriptId]/page.tsx
+++ b/www/app/(app)/transcripts/[transcriptId]/page.tsx
@@ -3,15 +3,15 @@ import Modal from "../modal";
 import useTopics from "../useTopics";
 import useWaveform from "../useWaveform";
 import useMp3 from "../useMp3";
 import useParticipants from "../useParticipants";
 import { TopicList } from "./_components/TopicList";
 import { TranscriptWithGutter } from "./_components/TranscriptWithGutter";
 import { Topic } from "../webSocketTypes";
 import React, { useEffect, useState, use } from "react";
 import FinalSummary from "./finalSummary";
 import TranscriptTitle from "../transcriptTitle";
 import Player from "../player";
 import { useWebSockets } from "../useWebSockets";
 import { useRouter } from "next/navigation";
 import { parseNonEmptyString } from "../../../lib/utils";
 import {
  Box,
  Flex,
@@ -32,7 +32,7 @@ type TranscriptDetails = {
 export default function TranscriptDetails(details: TranscriptDetails) {
  const params = use(details.params);
-  const transcriptId = params.transcriptId;
+  const transcriptId = parseNonEmptyString(params.transcriptId);
  const router = useRouter();
  const statusToRedirect = [
    "idle",
@@ -47,91 +47,15 @@ export default function TranscriptDetails(details: TranscriptDetails) {
  const mp3 = useMp3(transcriptId, waiting);
  const topics = useTopics(transcriptId);
  const participants = useParticipants(transcriptId);
  const waveform = useWaveform(
    transcriptId,
    waiting || mp3.audioDeleted === true,
  );
  useWebSockets(transcriptId);
  const useActiveTopic = useState<Topic | null>(null);
  const [activeTopic, setActiveTopic] = useActiveTopic;
  const [finalSummaryElement, setFinalSummaryElement] =
    useState<HTMLDivElement | null>(null);
  // IntersectionObserver for active topic detection based on scroll position
  useEffect(() => {
    if (!topics.topics || topics.topics.length === 0) return;
    const observer = new IntersectionObserver(
      (entries) => {
        // Find the most visible segment
        let mostVisibleEntry: IntersectionObserverEntry | null = null;
        let maxRatio = 0;
        entries.forEach((entry) => {
          if (entry.isIntersecting && entry.intersectionRatio > maxRatio) {
            maxRatio = entry.intersectionRatio;
            mostVisibleEntry = entry;
          }
        });
        if (mostVisibleEntry) {
          // Extract topicId from segment id (format: "segment-{topicId}-{idx}")
          const segmentId = mostVisibleEntry.target.id;
          const match = segmentId.match(/^segment-([^-]+)-/);
          if (match) {
            const topicId = match[1];
            const topic = topics.topics?.find((t) => t.id === topicId);
            if (topic && activeTopic?.id !== topic.id) {
              setActiveTopic(topic);
            }
          }
        }
      },
      {
        threshold: [0, 0.25, 0.5, 0.75, 1],
        rootMargin: "-20% 0px -20% 0px",
      },
    );
    // Observe all segment elements
    const segments = document.querySelectorAll('[id^="segment-"]');
    segments.forEach((segment) => observer.observe(segment));
    return () => observer.disconnect();
  }, [topics.topics, activeTopic?.id, setActiveTopic]);
  // Scroll handlers for bidirectional navigation
  const handleTopicClick = (topicId: string) => {
    // Scroll to first segment of this topic in transcript
    const firstSegment = document.querySelector(`[id^="segment-${topicId}-"]`);
    if (firstSegment) {
      firstSegment.scrollIntoView({
        behavior: "smooth",
        block: "center",
      });
    }
  };
  const handleGutterClick = (topicId: string) => {
    // Scroll to topic in list
    const topicChip = document.getElementById(`topic-${topicId}`);
    if (topicChip) {
      topicChip.scrollIntoView({
        behavior: "smooth",
        block: "center",
      });
    }
  };
  const getSpeakerName = (speakerNumber: number) => {
    if (!participants.response) return `Speaker ${speakerNumber}`;
    return (
      participants.response.find(
        (participant) => participant.speaker == speakerNumber,
      )?.name || `Speaker ${speakerNumber}`
    );
  };
  useEffect(() => {
    if (!waiting || !transcript.data) return;
@@ -200,7 +124,7 @@ export default function TranscriptDetails(details: TranscriptDetails) {
    <>
      <Grid
        templateColumns="1fr"
-        templateRows="auto auto"
+        templateRows="auto minmax(0, 1fr)"
        gap={4}
        mt={4}
        mb={4}
@@ -232,18 +156,18 @@ export default function TranscriptDetails(details: TranscriptDetails) {
        <Grid
          templateColumns={{ base: "minmax(0, 1fr)", md: "repeat(2, 1fr)" }}
          templateRows={{
-            base: "auto auto auto",
+            base: "auto minmax(0, 1fr) minmax(0, 1fr)",
-            md: "auto auto",
+            md: "auto minmax(0, 1fr)",
          }}
          gap={4}
          gridRowGap={2}
          padding={4}
          paddingBottom={0}
          background="gray.bg"
          border={"2px solid"}
          borderColor={"gray.bg"}
          borderRadius={8}
        >
          {/* Title */}
          <GridItem colSpan={{ base: 1, md: 2 }}>
            <Flex direction="column" gap={0}>
              <Flex alignItems="center" gap={2}>
@@ -266,64 +190,28 @@ export default function TranscriptDetails(details: TranscriptDetails) {
              )}
            </Flex>
          </GridItem>
-
+          <TopicList
-          {/* Left column: Topics List */}
+            topics={topics.topics || []}
-          <GridItem display="flex" flexDirection="column" gap={4} h="100%">
+            useActiveTopic={useActiveTopic}
-            <TopicList
+            autoscroll={false}
-              topics={topics.topics || []}
+            transcriptId={transcriptId}
-              useActiveTopic={useActiveTopic}
+            status={transcript.data?.status || null}
-              autoscroll={false}
+            currentTranscriptText=""
-              transcriptId={transcriptId}
+          />
              status={transcript.data?.status || null}
              currentTranscriptText=""
              onTopicClick={handleTopicClick}
            />
            {/* Transcript with colored gutter (scrollable) */}
            {topics.topics && topics.topics.length > 0 && (
              <Box
                overflowY="auto"
                flex={1}
                minH="0"
                pr={2}
                css={{
                  "&::-webkit-scrollbar": {
                    width: "8px",
                  },
                  "&::-webkit-scrollbar-track": {
                    background: "transparent",
                  },
                  "&::-webkit-scrollbar-thumb": {
                    background: "#CBD5E0",
                    borderRadius: "4px",
                  },
                  "&::-webkit-scrollbar-thumb:hover": {
                    background: "#A0AEC0",
                  },
                }}
              >
                <TranscriptWithGutter
                  topics={topics.topics}
                  getSpeakerName={getSpeakerName}
                  onGutterClick={handleGutterClick}
                />
              </Box>
            )}
          </GridItem>
          {/* Right column: Final Summary */}
          {transcript.data && topics.topics ? (
-            <FinalSummary
+            <>
-              transcript={transcript.data}
+              <FinalSummary
-              topics={topics.topics}
+                transcript={transcript.data}
-              onUpdate={() => {
+                topics={topics.topics}
-                transcript.refetch().then(() => {});
+                onUpdate={() => {
-              }}
+                  transcript.refetch().then(() => {});
-              finalSummaryRef={setFinalSummaryElement}
+                }}
-            />
+                finalSummaryRef={setFinalSummaryElement}
              />
            </>
          ) : (
-            <Flex justify="center" alignItems="center" h="100%">
+            <Flex justify={"center"} alignItems={"center"} h={"100%"}>
-              <Flex direction="column" h="full" justify="center" align="center">
+              <div className="flex flex-col h-full justify-center content-center">
                {transcript?.data?.status == "processing" ? (
                  <Text>Loading Transcript</Text>
                ) : (
@@ -332,7 +220,7 @@ export default function TranscriptDetails(details: TranscriptDetails) {
                    back later
                  </Text>
                )}
-              </Flex>
+              </div>
            </Flex>
          )}
        </Grid>
--- a/www/app/(app)/transcripts/[transcriptId]/processing/page.tsx
+++ b/www/app/(app)/transcripts/[transcriptId]/processing/page.tsx
@@ -10,6 +10,7 @@ import {
 } from "@chakra-ui/react";
 import { useRouter } from "next/navigation";
 import { useTranscriptGet } from "../../../../lib/apiHooks";
 import { parseNonEmptyString } from "../../../../lib/utils";
 type TranscriptProcessing = {
  params: Promise<{
@@ -19,7 +20,7 @@ type TranscriptProcessing = {
 export default function TranscriptProcessing(details: TranscriptProcessing) {
  const params = use(details.params);
-  const transcriptId = params.transcriptId;
+  const transcriptId = parseNonEmptyString(params.transcriptId);
  const router = useRouter();
  const transcript = useTranscriptGet(transcriptId);
--- a/www/app/(app)/transcripts/[transcriptId]/record/page.tsx
+++ b/www/app/(app)/transcripts/[transcriptId]/record/page.tsx
@@ -12,6 +12,7 @@ import { Box, Text, Grid, Heading, VStack, Flex } from "@chakra-ui/react";
 import LiveTrancription from "../../liveTranscription";
 import { useTranscriptGet } from "../../../../lib/apiHooks";
 import { TranscriptStatus } from "../../../../lib/transcript";
 import { parseNonEmptyString } from "../../../../lib/utils";
 type TranscriptDetails = {
  params: Promise<{
@@ -21,13 +22,14 @@ type TranscriptDetails = {
 const TranscriptRecord = (details: TranscriptDetails) => {
  const params = use(details.params);
-  const transcript = useTranscriptGet(params.transcriptId);
+  const transcriptId = parseNonEmptyString(params.transcriptId);
  const transcript = useTranscriptGet(transcriptId);
  const [transcriptStarted, setTranscriptStarted] = useState(false);
  const useActiveTopic = useState<Topic | null>(null);
-  const webSockets = useWebSockets(params.transcriptId);
+  const webSockets = useWebSockets(transcriptId);
-  const mp3 = useMp3(params.transcriptId, true);
+  const mp3 = useMp3(transcriptId, true);
  const router = useRouter();
--- a/www/app/(app)/transcripts/[transcriptId]/upload/page.tsx
+++ b/www/app/(app)/transcripts/[transcriptId]/upload/page.tsx
@@ -7,6 +7,7 @@ import useMp3 from "../../useMp3";
 import { Center, VStack, Text, Heading } from "@chakra-ui/react";
 import FileUploadButton from "../../fileUploadButton";
 import { useTranscriptGet } from "../../../../lib/apiHooks";
 import { parseNonEmptyString } from "../../../../lib/utils";
 type TranscriptUpload = {
  params: Promise<{
@@ -16,12 +17,13 @@ type TranscriptUpload = {
 const TranscriptUpload = (details: TranscriptUpload) => {
  const params = use(details.params);
-  const transcript = useTranscriptGet(params.transcriptId);
+  const transcriptId = parseNonEmptyString(params.transcriptId);
  const transcript = useTranscriptGet(transcriptId);
  const [transcriptStarted, setTranscriptStarted] = useState(false);
-  const webSockets = useWebSockets(params.transcriptId);
+  const webSockets = useWebSockets(transcriptId);
-  const mp3 = useMp3(params.transcriptId, true);
+  const mp3 = useMp3(transcriptId, true);
  const router = useRouter();
--- a/www/app/(app)/transcripts/createTranscript.ts
+++ b/www/app/(app)/transcripts/createTranscript.ts
@@ -2,10 +2,11 @@ import type { components } from "../../reflector-api";
 import { useTranscriptCreate } from "../../lib/apiHooks";
 type CreateTranscript = components["schemas"]["CreateTranscript"];
-type GetTranscript = components["schemas"]["GetTranscript"];
+type GetTranscriptWithParticipants =
  components["schemas"]["GetTranscriptWithParticipants"];
 type UseCreateTranscript = {
-  transcript: GetTranscript | null;
+  transcript: GetTranscriptWithParticipants | null;
  loading: boolean;
  error: Error | null;
  create: (transcriptCreationDetails: CreateTranscript) => Promise<void>;
--- a/www/app/(app)/transcripts/shareAndPrivacy.tsx
+++ b/www/app/(app)/transcripts/shareAndPrivacy.tsx
@@ -2,7 +2,8 @@ import { useEffect, useState } from "react";
 import { ShareMode, toShareMode } from "../../lib/shareMode";
 import type { components } from "../../reflector-api";
-type GetTranscript = components["schemas"]["GetTranscript"];
+type GetTranscriptWithParticipants =
  components["schemas"]["GetTranscriptWithParticipants"];
 type GetTranscriptTopic = components["schemas"]["GetTranscriptTopic"];
 type UpdateTranscript = components["schemas"]["UpdateTranscript"];
 import {
@@ -27,7 +28,7 @@ import { featureEnabled } from "../../lib/features";
 type ShareAndPrivacyProps = {
  finalSummaryElement: HTMLDivElement | null;
-  transcript: GetTranscript;
+  transcript: GetTranscriptWithParticipants;
  topics: GetTranscriptTopic[];
 };
--- a/www/app/(app)/transcripts/shareZulip.tsx
+++ b/www/app/(app)/transcripts/shareZulip.tsx
@@ -1,7 +1,8 @@
 import { useState, useEffect, useMemo } from "react";
 import type { components } from "../../reflector-api";
-type GetTranscript = components["schemas"]["GetTranscript"];
+type GetTranscriptWithParticipants =
  components["schemas"]["GetTranscriptWithParticipants"];
 type GetTranscriptTopic = components["schemas"]["GetTranscriptTopic"];
 import {
  BoxProps,
@@ -26,7 +27,7 @@ import {
 import { featureEnabled } from "../../lib/features";
 type ShareZulipProps = {
-  transcript: GetTranscript;
+  transcript: GetTranscriptWithParticipants;
  topics: GetTranscriptTopic[];
  disabled: boolean;
 };
--- a/www/app/(app)/transcripts/transcriptTitle.tsx
+++ b/www/app/(app)/transcripts/transcriptTitle.tsx
@@ -1,8 +1,10 @@
 import { useState } from "react";
 import type { components } from "../../reflector-api";
 import { parseMaybeNonEmptyString } from "../../lib/utils";
 type UpdateTranscript = components["schemas"]["UpdateTranscript"];
-type GetTranscript = components["schemas"]["GetTranscript"];
+type GetTranscriptWithParticipants =
  components["schemas"]["GetTranscriptWithParticipants"];
 type GetTranscriptTopic = components["schemas"]["GetTranscriptTopic"];
 import {
  useTranscriptUpdate,
@@ -20,7 +22,7 @@ type TranscriptTitle = {
  onUpdate: (newTitle: string) => void;
  // share props
-  transcript: GetTranscript | null;
+  transcript: GetTranscriptWithParticipants | null;
  topics: GetTranscriptTopic[] | null;
  finalSummaryElement: HTMLDivElement | null;
 };
@@ -31,7 +33,7 @@ const TranscriptTitle = (props: TranscriptTitle) => {
  const [isEditing, setIsEditing] = useState(false);
  const updateTranscriptMutation = useTranscriptUpdate();
  const participantsQuery = useTranscriptParticipants(
-    props.transcript?.id || null,
+    props.transcript?.id ? parseMaybeNonEmptyString(props.transcript.id) : null,
  );
  const updateTitle = async (newTitle: string, transcriptId: string) => {
--- a/www/app/(app)/transcripts/useMp3.ts
+++ b/www/app/(app)/transcripts/useMp3.ts
@@ -1,5 +1,6 @@
 import { useEffect, useState } from "react";
 import { useTranscriptGet } from "../../lib/apiHooks";
 import { parseMaybeNonEmptyString } from "../../lib/utils";
 import { useAuth } from "../../lib/AuthProvider";
 import { API_URL } from "../../lib/apiClient";
@@ -27,7 +28,7 @@ const useMp3 = (transcriptId: string, waiting?: boolean): Mp3Response => {
    data: transcript,
    isLoading: transcriptMetadataLoading,
    error: transcriptError,
-  } = useTranscriptGet(later ? null : transcriptId);
+  } = useTranscriptGet(later ? null : parseMaybeNonEmptyString(transcriptId));
  const [serviceWorker, setServiceWorker] =
    useState<ServiceWorkerRegistration | null>(null);
--- a/www/app/(app)/transcripts/useParticipants.ts
+++ b/www/app/(app)/transcripts/useParticipants.ts
@@ -1,6 +1,7 @@
 import type { components } from "../../reflector-api";
 type Participant = components["schemas"]["Participant"];
 import { useTranscriptParticipants } from "../../lib/apiHooks";
 import { parseMaybeNonEmptyString } from "../../lib/utils";
 type ErrorParticipants = {
  error: Error;
@@ -32,7 +33,7 @@ const useParticipants = (transcriptId: string): UseParticipants => {
    isLoading: loading,
    error,
    refetch,
-  } = useTranscriptParticipants(transcriptId || null);
+  } = useTranscriptParticipants(parseMaybeNonEmptyString(transcriptId));
  // Type-safe return based on state
  if (error) {
--- a/www/app/(app)/transcripts/useTopicWithWords.ts
+++ b/www/app/(app)/transcripts/useTopicWithWords.ts
@@ -1,5 +1,6 @@
 import type { components } from "../../reflector-api";
 import { useTranscriptTopicsWithWordsPerSpeaker } from "../../lib/apiHooks";
 import { parseMaybeNonEmptyString } from "../../lib/utils";
 type GetTranscriptTopicWithWordsPerSpeaker =
  components["schemas"]["GetTranscriptTopicWithWordsPerSpeaker"];
@@ -38,7 +39,7 @@ const useTopicWithWords = (
    error,
    refetch,
  } = useTranscriptTopicsWithWordsPerSpeaker(
-    transcriptId || null,
+    parseMaybeNonEmptyString(transcriptId),
    topicId || null,
  );
--- a/www/app/(app)/transcripts/useTopics.ts
+++ b/www/app/(app)/transcripts/useTopics.ts
@@ -1,5 +1,6 @@
 import { useTranscriptTopics } from "../../lib/apiHooks";
 import type { components } from "../../reflector-api";
 import { parseMaybeNonEmptyString } from "../../lib/utils";
 type GetTranscriptTopic = components["schemas"]["GetTranscriptTopic"];
@@ -10,7 +11,11 @@ type TranscriptTopics = {
 };
 const useTopics = (id: string): TranscriptTopics => {
-  const { data: topics, isLoading: loading, error } = useTranscriptTopics(id);
+  const {
    data: topics,
    isLoading: loading,
    error,
  } = useTranscriptTopics(parseMaybeNonEmptyString(id));
  return {
    topics: topics || null,
--- a/www/app/(app)/transcripts/useWaveform.ts
+++ b/www/app/(app)/transcripts/useWaveform.ts
@@ -1,5 +1,6 @@
 import type { components } from "../../reflector-api";
 import { useTranscriptWaveform } from "../../lib/apiHooks";
 import { parseMaybeNonEmptyString } from "../../lib/utils";
 type AudioWaveform = components["schemas"]["AudioWaveform"];
@@ -14,7 +15,7 @@ const useWaveform = (id: string, skip: boolean): AudioWaveFormResponse => {
    data: waveform,
    isLoading: loading,
    error,
-  } = useTranscriptWaveform(skip ? null : id);
+  } = useTranscriptWaveform(skip ? null : parseMaybeNonEmptyString(id));
  return {
    waveform: waveform || null,
--- a/www/app/(app)/transcripts/useWebSockets.ts
+++ b/www/app/(app)/transcripts/useWebSockets.ts
@@ -7,6 +7,12 @@ type GetTranscriptSegmentTopic =
  components["schemas"]["GetTranscriptSegmentTopic"];
 import { useQueryClient } from "@tanstack/react-query";
 import { $api, WEBSOCKET_URL } from "../../lib/apiClient";
 import {
  invalidateTranscript,
  invalidateTranscriptTopics,
  invalidateTranscriptWaveform,
 } from "../../lib/apiHooks";
 import { NonEmptyString } from "../../lib/utils";
 export type UseWebSockets = {
  transcriptTextLive: string;
@@ -369,15 +375,10 @@ export const useWebSockets = (transcriptId: string | null): UseWebSockets => {
            });
            console.debug("TOPIC event:", message.data);
            // Invalidate topics query to sync with WebSocket data
-            queryClient.invalidateQueries({
+            invalidateTranscriptTopics(
-              queryKey: $api.queryOptions(
+              queryClient,
-                "get",
+              transcriptId as NonEmptyString,
-                "/v1/transcripts/{transcript_id}/topics",
+            );
                {
                  params: { path: { transcript_id: transcriptId } },
                },
              ).queryKey,
            });
            break;
          case "FINAL_SHORT_SUMMARY":
@@ -388,15 +389,7 @@ export const useWebSockets = (transcriptId: string | null): UseWebSockets => {
            if (message.data) {
              setFinalSummary(message.data);
              // Invalidate transcript query to sync summary
-              queryClient.invalidateQueries({
+              invalidateTranscript(queryClient, transcriptId as NonEmptyString);
                queryKey: $api.queryOptions(
                  "get",
                  "/v1/transcripts/{transcript_id}",
                  {
                    params: { path: { transcript_id: transcriptId } },
                  },
                ).queryKey,
              });
            }
            break;
@@ -405,15 +398,7 @@ export const useWebSockets = (transcriptId: string | null): UseWebSockets => {
            if (message.data) {
              setTitle(message.data.title);
              // Invalidate transcript query to sync title
-              queryClient.invalidateQueries({
+              invalidateTranscript(queryClient, transcriptId as NonEmptyString);
                queryKey: $api.queryOptions(
                  "get",
                  "/v1/transcripts/{transcript_id}",
                  {
                    params: { path: { transcript_id: transcriptId } },
                  },
                ).queryKey,
              });
            }
            break;
@@ -424,6 +409,10 @@ export const useWebSockets = (transcriptId: string | null): UseWebSockets => {
            );
            if (message.data) {
              setWaveForm(message.data.waveform);
              invalidateTranscriptWaveform(
                queryClient,
                transcriptId as NonEmptyString,
              );
            }
            break;
          case "DURATION":
--- a/www/app/[roomName]/MeetingSelection.tsx
+++ b/www/app/[roomName]/MeetingSelection.tsx
@@ -26,7 +26,7 @@ import { useRouter } from "next/navigation";
 import { formatDateTime, formatStartedAgo } from "../lib/timeUtils";
 import MeetingMinimalHeader from "../components/MeetingMinimalHeader";
 import { NonEmptyString } from "../lib/utils";
-import { MeetingId } from "../lib/types";
+import { MeetingId, assertMeetingId } from "../lib/types";
 type Meeting = components["schemas"]["Meeting"];
@@ -315,7 +315,9 @@ export default function MeetingSelection({
                        variant="outline"
                        colorScheme="red"
                        size="md"
-                        onClick={() => handleEndMeeting(meeting.id)}
+                        onClick={() =>
                          handleEndMeeting(assertMeetingId(meeting.id))
                        }
                        loading={deactivateMeetingMutation.isPending}
                      >
                        <Icon as={LuX} me={2} />
@@ -460,7 +462,9 @@ export default function MeetingSelection({
                          variant="outline"
                          colorScheme="red"
                          size="md"
-                          onClick={() => handleEndMeeting(meeting.id)}
+                          onClick={() =>
                            handleEndMeeting(assertMeetingId(meeting.id))
                          }
                          loading={deactivateMeetingMutation.isPending}
                        >
                          <Icon as={LuX} me={2} />
--- a/www/app/[roomName]/components/DailyRoom.tsx
+++ b/www/app/[roomName]/components/DailyRoom.tsx
@@ -22,14 +22,29 @@ import DailyIframe, {
 import type { components } from "../../reflector-api";
 import { useAuth } from "../../lib/AuthProvider";
 import { useConsentDialog } from "../../lib/consent";
-import { useRoomJoinMeeting } from "../../lib/apiHooks";
+import {
  useRoomJoinMeeting,
  useMeetingStartRecording,
 } from "../../lib/apiHooks";
 import { omit } from "remeda";
-import { assertExists } from "../../lib/utils";
+import {
-import { assertMeetingId } from "../../lib/types";
+  assertExists,
  NonEmptyString,
  parseNonEmptyString,
 } from "../../lib/utils";
 import { assertMeetingId, DailyRecordingType } from "../../lib/types";
 import { useUuidV5 } from "react-uuid-hook";
 const CONSENT_BUTTON_ID = "recording-consent";
 const RECORDING_INDICATOR_ID = "recording-indicator";
 // Namespace UUID for UUIDv5 generation of raw-tracks instanceIds
 // DO NOT CHANGE: Breaks instanceId determinism across deployments
 const RAW_TRACKS_NAMESPACE = "a1b2c3d4-e5f6-7890-abcd-ef1234567890";
 const RECORDING_START_DELAY_MS = 2000;
 const RECORDING_START_MAX_RETRIES = 5;
 type Meeting = components["schemas"]["Meeting"];
 type Room = components["schemas"]["RoomDetails"];
@@ -73,9 +88,7 @@ const useFrame = (
  cbs: {
    onLeftMeeting: () => void;
    onCustomButtonClick: (ev: DailyEventObjectCustomButtonClick) => void;
-    onJoinMeeting: (
+    onJoinMeeting: () => void;
      startRecording: (args: { type: "raw-tracks" }) => void,
    ) => void;
  },
 ) => {
  const [{ frame, joined }, setState] = useState(USE_FRAME_INIT_STATE);
@@ -126,7 +139,7 @@ const useFrame = (
        console.error("frame is null in joined-meeting callback");
        return;
      }
-      cbs.onJoinMeeting(frame.startRecording.bind(frame));
+      cbs.onJoinMeeting();
    };
    frame.on("joined-meeting", joinCb);
    return () => {
@@ -173,8 +186,15 @@ export default function DailyRoom({ meeting, room }: DailyRoomProps) {
  const authLastUserId = auth.lastUserId;
  const [container, setContainer] = useState<HTMLDivElement | null>(null);
  const joinMutation = useRoomJoinMeeting();
  const startRecordingMutation = useMeetingStartRecording();
  const [joinedMeeting, setJoinedMeeting] = useState<Meeting | null>(null);
  // Generate deterministic instanceIds so all participants use SAME IDs
  const cloudInstanceId = parseNonEmptyString(meeting.id);
  const rawTracksInstanceId = parseNonEmptyString(
    useUuidV5(meeting.id, RAW_TRACKS_NAMESPACE)[0],
  );
  const roomName = params?.roomName as string;
  const {
@@ -228,19 +248,72 @@ export default function DailyRoom({ meeting, room }: DailyRoomProps) {
    ],
  );
-  const handleFrameJoinMeeting = useCallback(
+  const handleFrameJoinMeeting = useCallback(() => {
-    (startRecording: (args: { type: "raw-tracks" }) => void) => {
+    if (meeting.recording_type === "cloud") {
-      try {
+      console.log("Starting dual recording via REST API", {
-        if (meeting.recording_type === "cloud") {
+        cloudInstanceId,
-          console.log("Starting cloud recording");
+        rawTracksInstanceId,
-          startRecording({ type: "raw-tracks" });
+      });
-        }
+
-      } catch (error) {
+      // Start both cloud and raw-tracks via backend REST API (with retry on 404)
-        console.error("Failed to start recording:", error);
+      // Daily.co needs time to register call as "hosting" for REST API
-      }
+      const startRecordingWithRetry = (
-    },
+        type: DailyRecordingType,
-    [meeting.recording_type],
+        instanceId: NonEmptyString,
-  );
+        attempt: number = 1,
      ) => {
        setTimeout(() => {
          startRecordingMutation.mutate(
            {
              params: {
                path: {
                  meeting_id: meeting.id,
                },
              },
              body: {
                type,
                instanceId,
              },
            },
            {
              onError: (error: any) => {
                const errorText = error?.detail || error?.message || "";
                const is404NotHosting = errorText.includes(
                  "does not seem to be hosting a call",
                );
                const isActiveStream = errorText.includes(
                  "has an active stream",
                );
                if (is404NotHosting && attempt < RECORDING_START_MAX_RETRIES) {
                  console.log(
                    `${type}: Call not hosting yet, retry ${attempt + 1}/${RECORDING_START_MAX_RETRIES} in ${RECORDING_START_DELAY_MS}ms...`,
                  );
                  startRecordingWithRetry(type, instanceId, attempt + 1);
                } else if (isActiveStream) {
                  console.log(
                    `${type}: Recording already active (started by another participant)`,
                  );
                } else {
                  console.error(`Failed to start ${type} recording:`, error);
                }
              },
            },
          );
        }, RECORDING_START_DELAY_MS);
      };
      // Start both recordings
      startRecordingWithRetry("cloud", cloudInstanceId);
      startRecordingWithRetry("raw-tracks", rawTracksInstanceId);
    }
  }, [
    meeting.recording_type,
    meeting.id,
    startRecordingMutation,
    cloudInstanceId,
    rawTracksInstanceId,
  ]);
  const recordingIconUrl = useMemo(
    () => new URL("/recording-icon.svg", window.location.origin),
--- a/www/app/lib/apiHooks.ts
+++ b/www/app/lib/apiHooks.ts
@@ -6,6 +6,7 @@ import { QueryClient, useQueryClient } from "@tanstack/react-query";
 import type { components } from "../reflector-api";
 import { useAuth } from "./AuthProvider";
 import { MeetingId } from "./types";
 import { NonEmptyString } from "./utils";
 /*
 * XXX error types returned from the hooks are not always correct; declared types are ValidationError but real type could be string or any other
@@ -103,7 +104,7 @@ export function useTranscriptProcess() {
  });
 }
-export function useTranscriptGet(transcriptId: string | null) {
+export function useTranscriptGet(transcriptId: NonEmptyString | null) {
  return $api.useQuery(
    "get",
    "/v1/transcripts/{transcript_id}",
@@ -120,6 +121,16 @@ export function useTranscriptGet(transcriptId: string | null) {
  );
 }
 export const invalidateTranscript = (
  queryClient: QueryClient,
  transcriptId: NonEmptyString,
 ) =>
  queryClient.invalidateQueries({
    queryKey: $api.queryOptions("get", "/v1/transcripts/{transcript_id}", {
      params: { path: { transcript_id: transcriptId } },
    }).queryKey,
  });
 export function useRoomGet(roomId: string | null) {
  const { isAuthenticated } = useAuthReady();
@@ -297,7 +308,7 @@ export function useTranscriptUploadAudio() {
  );
 }
-export function useTranscriptWaveform(transcriptId: string | null) {
+export function useTranscriptWaveform(transcriptId: NonEmptyString | null) {
  return $api.useQuery(
    "get",
    "/v1/transcripts/{transcript_id}/audio/waveform",
@@ -312,7 +323,21 @@ export function useTranscriptWaveform(transcriptId: string | null) {
  );
 }
-export function useTranscriptMP3(transcriptId: string | null) {
+export const invalidateTranscriptWaveform = (
  queryClient: QueryClient,
  transcriptId: NonEmptyString,
 ) =>
  queryClient.invalidateQueries({
    queryKey: $api.queryOptions(
      "get",
      "/v1/transcripts/{transcript_id}/audio/waveform",
      {
        params: { path: { transcript_id: transcriptId } },
      },
    ).queryKey,
  });
 export function useTranscriptMP3(transcriptId: NonEmptyString | null) {
  const { isAuthenticated } = useAuthReady();
  return $api.useQuery(
@@ -329,7 +354,7 @@ export function useTranscriptMP3(transcriptId: string | null) {
  );
 }
-export function useTranscriptTopics(transcriptId: string | null) {
+export function useTranscriptTopics(transcriptId: NonEmptyString | null) {
  return $api.useQuery(
    "get",
    "/v1/transcripts/{transcript_id}/topics",
@@ -344,7 +369,23 @@ export function useTranscriptTopics(transcriptId: string | null) {
  );
 }
-export function useTranscriptTopicsWithWords(transcriptId: string | null) {
+export const invalidateTranscriptTopics = (
  queryClient: QueryClient,
  transcriptId: NonEmptyString,
 ) =>
  queryClient.invalidateQueries({
    queryKey: $api.queryOptions(
      "get",
      "/v1/transcripts/{transcript_id}/topics",
      {
        params: { path: { transcript_id: transcriptId } },
      },
    ).queryKey,
  });
 export function useTranscriptTopicsWithWords(
  transcriptId: NonEmptyString | null,
 ) {
  const { isAuthenticated } = useAuthReady();
  return $api.useQuery(
@@ -362,7 +403,7 @@ export function useTranscriptTopicsWithWords(transcriptId: string | null) {
 }
 export function useTranscriptTopicsWithWordsPerSpeaker(
-  transcriptId: string | null,
+  transcriptId: NonEmptyString | null,
  topicId: string | null,
 ) {
  const { isAuthenticated } = useAuthReady();
@@ -384,7 +425,7 @@ export function useTranscriptTopicsWithWordsPerSpeaker(
  );
 }
-export function useTranscriptParticipants(transcriptId: string | null) {
+export function useTranscriptParticipants(transcriptId: NonEmptyString | null) {
  const { isAuthenticated } = useAuthReady();
  return $api.useQuery(
@@ -567,6 +608,20 @@ export function useTranscriptSpeakerMerge() {
  );
 }
 export function useMeetingStartRecording() {
  const { setError } = useError();
  return $api.useMutation(
    "post",
    "/v1/meetings/{meeting_id}/recordings/start",
    {
      onError: (error) => {
        setError(error as Error, "Failed to start recording");
      },
    },
  );
 }
 export function useMeetingAudioConsent() {
  const { setError } = useError();
--- a/www/app/lib/topicColors.ts
+++ b/www/app/lib/topicColors.ts
@@ -1,18 +0,0 @@
 // Predefined color palette for topics
 // Colors chosen for good contrast and visual distinction
 export const TOPIC_COLORS = [
  "#3B82F6", // blue
  "#10B981", // green
  "#F59E0B", // amber
  "#EF4444", // red
  "#8B5CF6", // violet
  "#EC4899", // pink
  "#14B8A6", // teal
  "#F97316", // orange
  "#6366F1", // indigo
  "#84CC16", // lime
 ] as const;
 export function getTopicColor(topicIndex: number): string {
  return TOPIC_COLORS[topicIndex % TOPIC_COLORS.length];
 }
--- a/www/app/lib/transcript.ts
+++ b/www/app/lib/transcript.ts
@@ -1,5 +1,6 @@
 import { components } from "../reflector-api";
-type ApiTranscriptStatus = components["schemas"]["GetTranscript"]["status"];
+type ApiTranscriptStatus =
  components["schemas"]["GetTranscriptWithParticipants"]["status"];
 export type TranscriptStatus = ApiTranscriptStatus;
--- a/www/app/lib/types.ts
+++ b/www/app/lib/types.ts
@@ -89,3 +89,5 @@ export const assertMeetingId = (s: string): MeetingId => {
  // just cast for now
  return nes as MeetingId;
 };
 export type DailyRecordingType = "cloud" | "raw-tracks";
--- a/www/app/reflector-api.d.ts
+++ b/www/app/reflector-api.d.ts
@@ -75,6 +75,31 @@ export interface paths {
    patch: operations["v1_meeting_deactivate"];
    trace?: never;
  };
  "/v1/meetings/{meeting_id}/recordings/start": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    /**
     * Start Recording
     * @description Start cloud or raw-tracks recording via Daily.co REST API.
     *
     *     Both cloud and raw-tracks are started via REST API to bypass enable_recording limitation of allowing only 1 recording at a time.
     *     Uses different instanceIds for cloud vs raw-tracks (same won't work)
     *
     *     Note: No authentication required - anonymous users supported. TODO this is a DOS vector
     */
    post: operations["v1_start_recording"];
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/v1/rooms": {
    parameters: {
      query?: never;
@@ -1544,6 +1569,10 @@ export interface components {
       * @enum {string}
       */
      platform: "whereby" | "daily";
      /** Daily Composed Video S3 Key */
      daily_composed_video_s3_key?: string | null;
      /** Daily Composed Video Duration */
      daily_composed_video_duration?: number | null;
    };
    /** MeetingConsentRequest */
    MeetingConsentRequest: {
@@ -1818,6 +1847,19 @@ export interface components {
      /** Words */
      words: components["schemas"]["Word"][];
    };
    /** StartRecordingRequest */
    StartRecordingRequest: {
      /**
       * Type
       * @enum {string}
       */
      type: "cloud" | "raw-tracks";
      /**
       * Instanceid
       * Format: uuid
       */
      instanceId: string;
    };
    /** Stream */
    Stream: {
      /** Stream Id */
@@ -2126,6 +2168,43 @@ export interface operations {
      };
    };
  };
  v1_start_recording: {
    parameters: {
      query?: never;
      header?: never;
      path: {
        meeting_id: string;
      };
      cookie?: never;
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["StartRecordingRequest"];
      };
    };
    responses: {
      /** @description Successful Response */
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": {
            [key: string]: unknown;
          };
        };
      };
      /** @description Validation Error */
      422: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["HTTPValidationError"];
        };
      };
    };
  };
  v1_rooms_list: {
    parameters: {
      query?: {
--- a/www/package.json
+++ b/www/package.json
@@ -46,6 +46,7 @@
    "react-markdown": "^9.0.0",
    "react-qr-code": "^2.0.12",
    "react-select-search": "^4.1.7",
    "react-uuid-hook": "^0.0.6",
    "redlock": "5.0.0-beta.2",
    "remeda": "^2.31.1",
    "sass": "^1.63.6",
--- a/www/pnpm-lock.yaml
+++ b/www/pnpm-lock.yaml
@@ -106,6 +106,9 @@ importers:
      react-select-search:
        specifier: ^4.1.7
        version: 4.1.8(prop-types@15.8.1)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
      react-uuid-hook:
        specifier: ^0.0.6
        version: 0.0.6(react@18.3.1)
      redlock:
        specifier: 5.0.0-beta.2
        version: 5.0.0-beta.2
@@ -7628,6 +7631,14 @@ packages:
      "@types/react":
        optional: true
  react-uuid-hook@0.0.6:
    resolution:
      {
        integrity: sha512-u9+EvFbqpWfLE/ReYFry0vYu1BAg1fY9ekr0XLSDNnfWyrnVFytpurwz5qYsIB0psevuvrpZHIcvu7AjUwqinA==,
      }
    peerDependencies:
      react: ">=16.8.0"
  react@18.3.1:
    resolution:
      {
@@ -8771,6 +8782,13 @@ packages:
        integrity: sha512-Fykw5U4eZESbq739BeLvEBFRuJODfrlmjx5eJux7W817LjRaq4b7/i4t2zxQmhcX+fAj4nMfRdTzO4tmwLKn0w==,
      }
  uuid@13.0.0:
    resolution:
      {
        integrity: sha512-XQegIaBTVUjSHliKqcnFqYypAd4S+WCYt5NIeRs6w/UAry7z8Y9j5ZwRRL4kzq9U3sD6v+85er9FvkEaBpji2w==,
      }
    hasBin: true
  uuid@8.3.2:
    resolution:
      {
@@ -14570,6 +14588,11 @@ snapshots:
    optionalDependencies:
      "@types/react": 18.2.20
  react-uuid-hook@0.0.6(react@18.3.1):
    dependencies:
      react: 18.3.1
      uuid: 13.0.0
  react@18.3.1:
    dependencies:
      loose-envify: 1.4.0
@@ -15401,6 +15424,8 @@ snapshots:
  uuid-validate@0.0.3: {}
  uuid@13.0.0: {}
  uuid@8.3.2: {}
  uuid@9.0.1: {}
Author	SHA1	Message	Date
Mathieu Virbel	fa3cf5da0f	chore(main): release 0.32.2 (#842 )	2026-02-03 22:05:22 -05:00
Igor Monadical	8707c6694a	fix: use Daily API recording.duration as master source for transcript duration (#844 ) Set duration early in get_participants from Daily API (seconds -> ms), ensuring post_zulip has the value before mixdown_tracks completes. Removes redundant duration update from mixdown_tracks. Co-authored-by: Igor Loskutov <igor.loskutoff@gmail.com>	2026-02-03 17:15:03 -05:00
Igor Monadical	4acde4b7fd	fix: increase TIMEOUT_MEDIUM from 2m to 5m for LLM tasks (#843 ) Topic detection was timing out on longer transcripts when LLM responses are slow. This affects detect_chunk_topic and other LLM-calling tasks that use TIMEOUT_MEDIUM. Co-authored-by: Igor Loskutov <igor.loskutoff@gmail.com>	2026-02-03 16:05:16 -05:00
Sergey Mankovsky	a2ed7d60d5	fix: make caddy optional (#841 )	2026-02-03 00:18:47 +01:00
Mathieu Virbel	a08f94a5bf	chore(main): release 0.32.1 (#840 )	2026-01-30 17:34:48 -05:00
Igor Loskutov	c05d1f03cd	fix: match httpx pad with hatchet audio timeout	2026-01-30 15:56:18 -05:00
Igor Loskutov	23eb1371cb	fix: daily multitrack pipeline finalze dependency fix	2026-01-30 15:19:27 -05:00
Mathieu Virbel	2592e369f6	chore(main): release 0.32.0 (#838 )	2026-01-30 13:13:59 -05:00
Igor Monadical	7fde64e252	feat: modal padding (#837 ) * Add Modal backend for audio padding - Create reflector_padding.py Modal deployment (CPU-based) - Add PaddingWorkflow with conditional Modal/local backend - Update deploy-all.sh to include padding deployment --------- Co-authored-by: Igor Loskutov <igor.loskutoff@gmail.com>	2026-01-30 13:11:51 -05:00
Mathieu Virbel	2ca624f052	chore(main): release 0.31.0 (#835 )	2026-01-26 13:07:29 -05:00
Igor Monadical	fc3ef6c893	feat: mixdown optional (#834 ) * optional mixdown * optional mixdown --------- Co-authored-by: Igor Loskutov <igor.loskutoff@gmail.com>	2026-01-23 15:51:18 -05:00
Mathieu Virbel	5d26461477	chore(main): release 0.30.0 (#832 )	2026-01-23 13:58:33 -05:00
Igor Monadical	6c175a11d8	feat: brady bunch (#816 ) * brady bunch PRD/tasks * clean dead daily.co code * brady bunch prototype (no-mistakes) * brady bunch prototype (no-mistakes) review * self-review * daily poll time match (no-mistakes) * daily poll self-review (no-mistakes) * daily poll self-review (no-mistakes) * daily co doc * cleanup * cleanup * self-review (no-mistakes) * self-review (no-mistakes) * self-review * self-review * ui typefix * dupe calls error handling proper * daily reflector data model doc * logging style fix * migration merge --------- Co-authored-by: Igor Loskutov <igor.loskutoff@gmail.com>	2026-01-23 12:33:06 -05:00
Igor Monadical	6e786b7631	hatchet processing resilence several fixes (#831 ) Co-authored-by: Igor Loskutov <igor.loskutoff@gmail.com>	2026-01-22 19:03:33 -05:00
Mathieu Virbel	8fc8d8bf4a	chore(main): release 0.29.0 (#828 )	2026-01-22 12:52:39 -05:00
Igor Monadical	c723752b7e	feat: set hatchet as default for multitracks (#822 ) * set hatchet as default for multitracks * fix: pipeline routing tests for hatchet-default branch - Create room with use_celery=True to force Celery backend in tests - Link transcript to room to enable multitrack pipeline routing - Fixes test failures caused by missing HATCHET_CLIENT_TOKEN in test env * Update server/reflector/services/transcript_process.py Co-authored-by: pr-agent-monadical[bot] <198624643+pr-agent-monadical[bot]@users.noreply.github.com> --------- Co-authored-by: Igor Loskutov <igor.loskutoff@gmail.com> Co-authored-by: pr-agent-monadical[bot] <198624643+pr-agent-monadical[bot]@users.noreply.github.com>	2026-01-21 17:05:03 -05:00
Mathieu Virbel	4dc49e5b25	chore(main): release 0.28.1 (#827 )	2026-01-21 15:30:42 -05:00
Igor Monadical	23d2bc283d	fix: ics non-sync bugfix (#823 ) * ics non-sync bugfix * fix tests --------- Co-authored-by: Igor Loskutov <igor.loskutoff@gmail.com>	2026-01-21 15:10:19 -05:00
Igor Monadical	c8743fdf1c	fix webhook tests (#826 ) Co-authored-by: Igor Loskutov <igor.loskutoff@gmail.com>	2026-01-21 14:31:20 -05:00
Igor Monadical	8a293882ad	timeout to untighten ws python loop (#821 ) Co-authored-by: Igor Loskutov <igor.loskutoff@gmail.com>	2026-01-20 16:29:09 -05:00
Mathieu Virbel	d83c4a30b4	chore(main): release 0.28.0 (#820 )	2026-01-20 12:35:26 -05:00
Igor Monadical	3b6540eae5	feat: worker affinity (#819 ) * worker affinity * worker affinity * worker affinity --------- Co-authored-by: Igor Loskutov <igor.loskutoff@gmail.com>	2026-01-20 12:27:16 -05:00
		`@@ -1 +0,0 @@`
			`export const TOPICS_SCROLL_DIV_ID = "topics-scroll-div";`