active meetings type precision

* Identify action items

* Add action items to mock summary

* Add action items validator

* Remove final prefix from action items

* Make on action items callback required

* Don't mutation action items response

* Assign action items to none on error

* Use timeout constant

* Exclude action items from transcript list

.github/workflows/deploy.yml

@@ -1,90 +0,0 @@
-name: Build container/push to container registry
-
-on: [workflow_dispatch]
-
-env:
-  # 950402358378.dkr.ecr.us-east-1.amazonaws.com/reflector
-  AWS_REGION: us-east-1
-  ECR_REPOSITORY: reflector
-
-jobs:
-  build:
-    strategy:
-      matrix:
-        include:
-          - platform: linux/amd64
-            runner: linux-amd64
-            arch: amd64
-          - platform: linux/arm64
-            runner: linux-arm64
-            arch: arm64
-
-    runs-on: ${{ matrix.runner }}
-
-    permissions:
-      contents: read
-
-    outputs:
-      registry: ${{ steps.login-ecr.outputs.registry }}
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Configure AWS credentials
-        uses: aws-actions/configure-aws-credentials@v4
-        with:
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          aws-region: ${{ env.AWS_REGION }}
-
-      - name: Login to Amazon ECR
-        id: login-ecr
-        uses: aws-actions/amazon-ecr-login@v2
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Build and push ${{ matrix.arch }}
-        uses: docker/build-push-action@v5
-        with:
-          context: server
-          platforms: ${{ matrix.platform }}
-          push: true
-          tags: ${{ steps.login-ecr.outputs.registry }}/${{ env.ECR_REPOSITORY }}:latest-${{ matrix.arch }}
-          cache-from: type=gha,scope=${{ matrix.arch }}
-          cache-to: type=gha,mode=max,scope=${{ matrix.arch }}
-          github-token: ${{ secrets.GHA_CACHE_TOKEN }}
-          provenance: false
-
-  create-manifest:
-    runs-on: ubuntu-latest
-    needs: [build]
-
-    permissions:
-      deployments: write
-      contents: read
-
-    steps:
-      - name: Configure AWS credentials
-        uses: aws-actions/configure-aws-credentials@v4
-        with:
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          aws-region: ${{ env.AWS_REGION }}
-
-      - name: Login to Amazon ECR
-        uses: aws-actions/amazon-ecr-login@v2
-
-      - name: Create and push multi-arch manifest
-        run: |
-          # Get the registry URL (since we can't easily access job outputs in matrix)
-          ECR_REGISTRY=$(aws ecr describe-registry --query 'registryId' --output text).dkr.ecr.${{ env.AWS_REGION }}.amazonaws.com
-
-          docker manifest create \
-            $ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:latest \
-            $ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:latest-amd64 \
-            $ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:latest-arm64
-
-          docker manifest push $ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:latest
-
-          echo "✅ Multi-arch manifest pushed: $ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:latest"

.github/workflows/dockerhub-backend.yml

@@ -1,35 +1,31 @@
-name: Build and Push Frontend Docker Image
+name: Build and Push Backend Docker Image (Docker Hub)
 
 on:
   push:
-    branches:
+    tags:
-      - main
+      - "v*"
-    paths:
-      - 'www/**'
-      - '.github/workflows/docker-frontend.yml'
   workflow_dispatch:
 
 env:
-  REGISTRY: ghcr.io
+  REGISTRY: docker.io
-  IMAGE_NAME: ${{ github.repository }}-frontend
+  IMAGE_NAME: monadicalsas/reflector-backend
 
 jobs:
   build-and-push:
     runs-on: ubuntu-latest
     permissions:
       contents: read
-      packages: write
 
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
 
-      - name: Log in to GitHub Container Registry
+      - name: Log in to Docker Hub
         uses: docker/login-action@v3
         with:
           registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
+          username: monadicalsas
-          password: ${{ secrets.GITHUB_TOKEN }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Extract metadata
         id: meta
@@ -38,7 +34,7 @@ jobs:
           images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
           tags: |
             type=ref,event=branch
-            type=sha,prefix={{branch}}-
+            type=ref,event=tag
             type=raw,value=latest,enable={{is_default_branch}}
 
       - name: Set up Docker Buildx
@@ -47,11 +43,11 @@ jobs:
       - name: Build and push Docker image
         uses: docker/build-push-action@v5
         with:
-          context: ./www
+          context: ./server
-          file: ./www/Dockerfile
+          file: ./server/Dockerfile
           push: true
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
           cache-from: type=gha
           cache-to: type=gha,mode=max
-          platforms: linux/amd64,linux/arm64
+          platforms: linux/amd64,linux/arm64

.github/workflows/dockerhub-frontend.yml

@@ -0,0 +1,70 @@
+name: Build and Push Frontend Docker Image
+
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch:
+
+env:
+  REGISTRY: docker.io
+  IMAGE_NAME: monadicalsas/reflector-frontend
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: monadicalsas
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Extract metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+          tags: |
+            type=ref,event=branch
+            type=ref,event=tag
+            type=raw,value=latest,enable={{is_default_branch}}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: ./www
+          file: ./www/Dockerfile
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+          platforms: linux/amd64,linux/arm64
+
+  deploy:
+    needs: build-and-push
+    runs-on: ubuntu-latest
+    if: success()
+    strategy:
+      matrix:
+        environment: [reflector-monadical, reflector-media]
+    environment: ${{ matrix.environment }}
+    steps:
+      - name: Trigger Coolify deployment
+        run: |
+          curl -X POST "${{ secrets.COOLIFY_WEBHOOK_URL }}" \
+            -H "Content-Type: application/json" \
+            -H "Authorization: Bearer ${{ secrets.COOLIFY_WEBHOOK_TOKEN }}" \
+            -f || (echo "Failed to trigger Coolify deployment for ${{ matrix.environment }}" && exit 1)

.gitignore

@@ -18,3 +18,4 @@ CLAUDE.local.md
 www/.env.development
 www/.env.production
 .playwright-mcp
+.secrets

.secrets.example

@@ -0,0 +1,24 @@
+# Example secrets file for GitHub Actions workflows
+# Copy this to .secrets and fill in your values
+# These secrets should be configured in GitHub repository settings:
+# Settings > Secrets and variables > Actions
+
+# DockerHub Configuration (required for frontend and backend deployment)
+# Create a Docker Hub access token at https://hub.docker.com/settings/security
+# Username: monadicalsas
+DOCKERHUB_TOKEN=your-dockerhub-access-token
+
+# GitHub Token (required for frontend and backend deployment)
+# Used by docker/metadata-action for extracting image metadata
+# Can use the default GITHUB_TOKEN or create a personal access token
+GITHUB_TOKEN=your-github-token-or-use-default-GITHUB_TOKEN
+
+# Coolify Deployment Webhook (required for frontend deployment)
+# Used to trigger automatic deployment after image push
+# Configure these secrets in GitHub Environments:
+# Each environment should have:
+#   - COOLIFY_WEBHOOK_URL: The webhook URL for that specific deployment
+#   - COOLIFY_WEBHOOK_TOKEN: The webhook token (can be the same for both if using same token)
+
+# Optional: GitHub Actions Cache Token (for local testing with act)
+GHA_CACHE_TOKEN=your-github-token-or-empty

CHANGELOG.md

@@ -1,5 +1,78 @@
 # Changelog
 
+## [0.23.2](https://github.com/Monadical-SAS/reflector/compare/v0.23.1...v0.23.2) (2025-12-11)
+
+
+### Bug Fixes
+
+* build on push tags ([#785](https://github.com/Monadical-SAS/reflector/issues/785)) ([d7f140b](https://github.com/Monadical-SAS/reflector/commit/d7f140b7d1f4660d5da7a0da1357f68869e0b5cd))
+
+## [0.23.1](https://github.com/Monadical-SAS/reflector/compare/v0.23.0...v0.23.1) (2025-12-11)
+
+
+### Bug Fixes
+
+* populate room_name in transcript GET endpoint ([#783](https://github.com/Monadical-SAS/reflector/issues/783)) ([0eba147](https://github.com/Monadical-SAS/reflector/commit/0eba1470181c7b9e0a79964a1ef28c09bcbdd9d7))
+
+## [0.23.0](https://github.com/Monadical-SAS/reflector/compare/v0.22.4...v0.23.0) (2025-12-10)
+
+
+### Features
+
+* dockerhub ci ([#772](https://github.com/Monadical-SAS/reflector/issues/772)) ([00549f1](https://github.com/Monadical-SAS/reflector/commit/00549f153ade922cf4cb6c5358a7d11a39c426d2))
+* llm retries ([#739](https://github.com/Monadical-SAS/reflector/issues/739)) ([61f0e29](https://github.com/Monadical-SAS/reflector/commit/61f0e29d4c51eab54ee67af92141fbb171e8ccaa))
+
+
+### Bug Fixes
+
+* celery inspect bug sidestep in restart script ([#766](https://github.com/Monadical-SAS/reflector/issues/766)) ([ec17ed7](https://github.com/Monadical-SAS/reflector/commit/ec17ed7b587cf6ee143646baaee67a7c017044d4))
+* deploy frontend to coolify ([#779](https://github.com/Monadical-SAS/reflector/issues/779)) ([91650ec](https://github.com/Monadical-SAS/reflector/commit/91650ec65f65713faa7ee0dcfb75af427b7c4ba0))
+* hide rooms settings instead of disabling ([#763](https://github.com/Monadical-SAS/reflector/issues/763)) ([3ad78be](https://github.com/Monadical-SAS/reflector/commit/3ad78be7628c0d029296b301a0e87236c76b7598))
+* return participant emails from transcript endpoint ([#769](https://github.com/Monadical-SAS/reflector/issues/769)) ([d3a5cd1](https://github.com/Monadical-SAS/reflector/commit/d3a5cd12d2d0d9c32af2d5bd9322e030ef69b85d))
+
+## [0.22.4](https://github.com/Monadical-SAS/reflector/compare/v0.22.3...v0.22.4) (2025-12-02)
+
+
+### Bug Fixes
+
+* Multitrack mixdown optimisation 2 ([#764](https://github.com/Monadical-SAS/reflector/issues/764)) ([bd5df1c](https://github.com/Monadical-SAS/reflector/commit/bd5df1ce2ebf35d7f3413b295e56937a9a28ef7b))
+
+## [0.22.3](https://github.com/Monadical-SAS/reflector/compare/v0.22.2...v0.22.3) (2025-12-02)
+
+
+### Bug Fixes
+
+* align daily room settings ([#759](https://github.com/Monadical-SAS/reflector/issues/759)) ([28f87c0](https://github.com/Monadical-SAS/reflector/commit/28f87c09dc459846873d0dde65b03e3d7b2b9399))
+
+## [0.22.2](https://github.com/Monadical-SAS/reflector/compare/v0.22.1...v0.22.2) (2025-12-02)
+
+
+### Bug Fixes
+
+* daily auto refresh fix ([#755](https://github.com/Monadical-SAS/reflector/issues/755)) ([fe47c46](https://github.com/Monadical-SAS/reflector/commit/fe47c46489c5aa0cc538109f7559cc9accb35c01))
+* Skip mixdown for multitrack ([#760](https://github.com/Monadical-SAS/reflector/issues/760)) ([b51b7aa](https://github.com/Monadical-SAS/reflector/commit/b51b7aa9176c1a53ba57ad99f5e976c804a1e80c))
+
+## [0.22.1](https://github.com/Monadical-SAS/reflector/compare/v0.22.0...v0.22.1) (2025-11-27)
+
+
+### Bug Fixes
+
+* participants update from daily ([#749](https://github.com/Monadical-SAS/reflector/issues/749)) ([7f0b728](https://github.com/Monadical-SAS/reflector/commit/7f0b728991c1b9f9aae702c96297eae63b561ef5))
+
+## [0.22.0](https://github.com/Monadical-SAS/reflector/compare/v0.21.0...v0.22.0) (2025-11-26)
+
+
+### Features
+
+* Multitrack segmentation ([#747](https://github.com/Monadical-SAS/reflector/issues/747)) ([d63040e](https://github.com/Monadical-SAS/reflector/commit/d63040e2fdc07e7b272e85a39eb2411cd6a14798))
+
+## [0.21.0](https://github.com/Monadical-SAS/reflector/compare/v0.20.0...v0.21.0) (2025-11-26)
+
+
+### Features
+
+* add transcript format parameter to GET endpoint ([#709](https://github.com/Monadical-SAS/reflector/issues/709)) ([f6ca075](https://github.com/Monadical-SAS/reflector/commit/f6ca07505f34483b02270a2ef3bd809e9d2e1045))
+
 ## [0.20.0](https://github.com/Monadical-SAS/reflector/compare/v0.19.0...v0.20.0) (2025-11-25)
 
 

docker-compose.prod.yml

@@ -3,10 +3,8 @@
 
 services:
   web:
-    build:
+    image: monadicalsas/reflector-frontend:latest
-      context: ./www
+    pull_policy: always
-      dockerfile: Dockerfile
-    image: reflector-frontend:latest
     environment:
       - KV_URL=${KV_URL:-redis://redis:6379}
       - SITE_URL=${SITE_URL}
@@ -36,4 +34,4 @@ services:
       - redis_data:/data
 
 volumes:
-  redis_data:
+  redis_data:

docs/transcript.md

@@ -0,0 +1,241 @@
+# Transcript Formats
+
+The Reflector API provides multiple output formats for transcript data through the `transcript_format` query parameter on the GET `/v1/transcripts/{id}` endpoint.
+
+## Overview
+
+When retrieving a transcript, you can specify the desired format using the `transcript_format` query parameter. The API supports four formats optimized for different use cases:
+
+- **text** - Plain text with speaker names (default)
+- **text-timestamped** - Timestamped text with speaker names
+- **webvtt-named** - WebVTT subtitle format with participant names
+- **json** - Structured JSON segments with full metadata
+
+All formats include participant information when available, resolving speaker IDs to actual names.
+
+## Query Parameter Usage
+
+```
+GET /v1/transcripts/{id}?transcript_format={format}
+```
+
+### Parameters
+
+- `transcript_format` (optional): The desired output format
+  - Type: `"text" | "text-timestamped" | "webvtt-named" | "json"`
+  - Default: `"text"`
+
+## Format Descriptions
+
+### Text Format (`text`)
+
+**Use case:** Simple, human-readable transcript for display or export.
+
+**Format:** Speaker names followed by their dialogue, one line per segment.
+
+**Example:**
+```
+John Smith: Hello everyone
+Jane Doe: Hi there
+John Smith: How are you today?
+```
+
+**Request:**
+```bash
+GET /v1/transcripts/{id}?transcript_format=text
+```
+
+**Response:**
+```json
+{
+  "id": "transcript_123",
+  "name": "Meeting Recording",
+  "transcript_format": "text",
+  "transcript": "John Smith: Hello everyone\nJane Doe: Hi there\nJohn Smith: How are you today?",
+  "participants": [
+    {"id": "p1", "speaker": 0, "name": "John Smith"},
+    {"id": "p2", "speaker": 1, "name": "Jane Doe"}
+  ],
+  ...
+}
+```
+
+### Text Timestamped Format (`text-timestamped`)
+
+**Use case:** Transcript with timing information for navigation or reference.
+
+**Format:** `[MM:SS]` timestamp prefix before each speaker and dialogue.
+
+**Example:**
+```
+[00:00] John Smith: Hello everyone
+[00:05] Jane Doe: Hi there
+[00:12] John Smith: How are you today?
+```
+
+**Request:**
+```bash
+GET /v1/transcripts/{id}?transcript_format=text-timestamped
+```
+
+**Response:**
+```json
+{
+  "id": "transcript_123",
+  "name": "Meeting Recording",
+  "transcript_format": "text-timestamped",
+  "transcript": "[00:00] John Smith: Hello everyone\n[00:05] Jane Doe: Hi there\n[00:12] John Smith: How are you today?",
+  "participants": [
+    {"id": "p1", "speaker": 0, "name": "John Smith"},
+    {"id": "p2", "speaker": 1, "name": "Jane Doe"}
+  ],
+  ...
+}
+```
+
+### WebVTT Named Format (`webvtt-named`)
+
+**Use case:** Subtitle files for video players, accessibility tools, or video editing.
+
+**Format:** Standard WebVTT subtitle format with voice tags using participant names.
+
+**Example:**
+```
+WEBVTT
+
+00:00:00.000 --> 00:00:05.000
+<v John Smith>Hello everyone
+
+00:00:05.000 --> 00:00:12.000
+<v Jane Doe>Hi there
+
+00:00:12.000 --> 00:00:18.000
+<v John Smith>How are you today?
+```
+
+**Request:**
+```bash
+GET /v1/transcripts/{id}?transcript_format=webvtt-named
+```
+
+**Response:**
+```json
+{
+  "id": "transcript_123",
+  "name": "Meeting Recording",
+  "transcript_format": "webvtt-named",
+  "transcript": "WEBVTT\n\n00:00:00.000 --> 00:00:05.000\n<v John Smith>Hello everyone\n\n...",
+  "participants": [
+    {"id": "p1", "speaker": 0, "name": "John Smith"},
+    {"id": "p2", "speaker": 1, "name": "Jane Doe"}
+  ],
+  ...
+}
+```
+
+### JSON Format (`json`)
+
+**Use case:** Programmatic access with full timing and speaker metadata.
+
+**Format:** Array of segment objects with speaker information, text content, and precise timing.
+
+**Example:**
+```json
+[
+  {
+    "speaker": 0,
+    "speaker_name": "John Smith",
+    "text": "Hello everyone",
+    "start": 0.0,
+    "end": 5.0
+  },
+  {
+    "speaker": 1,
+    "speaker_name": "Jane Doe",
+    "text": "Hi there",
+    "start": 5.0,
+    "end": 12.0
+  },
+  {
+    "speaker": 0,
+    "speaker_name": "John Smith",
+    "text": "How are you today?",
+    "start": 12.0,
+    "end": 18.0
+  }
+]
+```
+
+**Request:**
+```bash
+GET /v1/transcripts/{id}?transcript_format=json
+```
+
+**Response:**
+```json
+{
+  "id": "transcript_123",
+  "name": "Meeting Recording",
+  "transcript_format": "json",
+  "transcript": [
+    {
+      "speaker": 0,
+      "speaker_name": "John Smith",
+      "text": "Hello everyone",
+      "start": 0.0,
+      "end": 5.0
+    },
+    {
+      "speaker": 1,
+      "speaker_name": "Jane Doe",
+      "text": "Hi there",
+      "start": 5.0,
+      "end": 12.0
+    }
+  ],
+  "participants": [
+    {"id": "p1", "speaker": 0, "name": "John Smith"},
+    {"id": "p2", "speaker": 1, "name": "Jane Doe"}
+  ],
+  ...
+}
+```
+
+## Response Structure
+
+All formats return the same base transcript metadata with an additional `transcript_format` field and format-specific `transcript` field:
+
+### Common Fields
+
+- `id`: Transcript identifier
+- `user_id`: Owner user ID (if authenticated)
+- `name`: Transcript name
+- `status`: Processing status
+- `locked`: Whether transcript is locked for editing
+- `duration`: Total duration in seconds
+- `title`: Auto-generated or custom title
+- `short_summary`: Brief summary
+- `long_summary`: Detailed summary
+- `created_at`: Creation timestamp
+- `share_mode`: Access control setting
+- `source_language`: Original audio language
+- `target_language`: Translation target language
+- `reviewed`: Whether transcript has been reviewed
+- `meeting_id`: Associated meeting ID (if applicable)
+- `source_kind`: Source type (live, file, room)
+- `room_id`: Associated room ID (if applicable)
+- `audio_deleted`: Whether audio has been deleted
+- `participants`: Array of participant objects with speaker mappings
+
+### Format-Specific Fields
+
+- `transcript_format`: The format identifier (discriminator field)
+- `transcript`: The formatted transcript content (string for text/webvtt formats, array for json format)
+
+## Speaker Name Resolution
+
+All formats resolve speaker IDs to participant names when available:
+
+- If a participant exists for the speaker ID, their name is used
+- If no participant exists, a default name like "Speaker 0" is generated
+- Speaker IDs are integers (0, 1, 2, etc.) assigned during diarization

server/migrations/versions/05f8688d6895_add_action_items.py

@@ -0,0 +1,26 @@
+"""add_action_items
+
+Revision ID: 05f8688d6895
+Revises: bbafedfa510c
+Create Date: 2025-12-12 11:57:50.209658
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "05f8688d6895"
+down_revision: Union[str, None] = "bbafedfa510c"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.add_column("transcript", sa.Column("action_items", sa.JSON(), nullable=True))
+
+
+def downgrade() -> None:
+    op.drop_column("transcript", "action_items")

server/migrations/versions/20251217000000_add_skip_consent_to_room.py

@@ -0,0 +1,35 @@
+"""add skip_consent to room
+
+Revision ID: 20251217000000
+Revises: 05f8688d6895
+Create Date: 2025-12-17 00:00:00.000000
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "20251217000000"
+down_revision: Union[str, None] = "05f8688d6895"
+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(
+                "skip_consent",
+                sa.Boolean(),
+                nullable=False,
+                server_default=sa.text("false"),
+            )
+        )
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("room", schema=None) as batch_op:
+        batch_op.drop_column("skip_consent")

server/pyproject.toml

@@ -126,6 +126,7 @@ markers = [
 select = [
     "I",       # isort - import sorting
     "F401",    # unused imports
+    "E402",    # module level import not at top of file
     "PLC0415", # import-outside-top-level - detect inline imports
 ]
 

server/reflector/asynctask.py

@@ -1,13 +1,19 @@
 import asyncio
 import functools
+from uuid import uuid4
+
+from celery import current_task
 
 from reflector.db import get_database
+from reflector.llm import llm_session_id
 
 
 def asynctask(f):
     @functools.wraps(f)
     def wrapper(*args, **kwargs):
         async def run_with_db():
+            task_id = current_task.request.id if current_task else None
+            llm_session_id.set(task_id or f"random-{uuid4().hex}")
             database = get_database()
             await database.connect()
             try:

server/reflector/dailyco_api/__init__.py

@@ -18,6 +18,7 @@ from .requests import (
 
 # Response models
 from .responses import (
+    FinishedRecordingResponse,
     MeetingParticipant,
     MeetingParticipantsResponse,
     MeetingResponse,
@@ -79,6 +80,7 @@ __all__ = [
     "MeetingParticipant",
     "MeetingResponse",
     "RecordingResponse",
+    "FinishedRecordingResponse",
     "RecordingS3Info",
     "MeetingTokenResponse",
     "WebhookResponse",

server/reflector/dailyco_api/requests.py

@@ -40,6 +40,10 @@ class RoomProperties(BaseModel):
     )
     enable_chat: bool = Field(default=True, description="Enable in-meeting chat")
     enable_screenshare: bool = Field(default=True, description="Enable screen sharing")
+    enable_knocking: bool = Field(
+        default=False,
+        description="Enable knocking for private rooms (allows participants to request access)",
+    )
     start_video_off: bool = Field(
         default=False, description="Start with video off for all participants"
     )

server/reflector/dailyco_api/responses.py

@@ -68,7 +68,7 @@ class MeetingParticipant(BaseModel):
     Reference: https://docs.daily.co/reference/rest-api/meetings/get-meeting-participants
     """
 
-    user_id: NonEmptyString = Field(description="User identifier")
+    user_id: NonEmptyString | None = Field(None, description="User identifier")
     participant_id: NonEmptyString = Field(description="Participant session identifier")
     user_name: NonEmptyString | None = Field(None, description="User display name")
     join_time: int = Field(description="Join timestamp (Unix epoch seconds)")
@@ -121,7 +121,10 @@ class RecordingS3Info(BaseModel):
 
 class RecordingResponse(BaseModel):
     """
-    Response from recording retrieval endpoint.
+    Response from recording retrieval endpoint (network layer).
+
+    Duration may be None for recordings still being processed by Daily.
+    Use FinishedRecordingResponse for recordings ready for processing.
 
     Reference: https://docs.daily.co/reference/rest-api/recordings
     """
@@ -135,7 +138,9 @@ class RecordingResponse(BaseModel):
     max_participants: int | None = Field(
         None, description="Maximum participants during recording (may be missing)"
     )
-    duration: int = Field(description="Recording duration in seconds")
+    duration: int | None = Field(
+        None, description="Recording duration in seconds (None if still processing)"
+    )
     share_token: NonEmptyString | None = Field(
         None, description="Token for sharing recording"
     )
@@ -149,6 +154,25 @@ class RecordingResponse(BaseModel):
         None, description="Meeting session identifier (may be missing)"
     )
 
+    def to_finished(self) -> "FinishedRecordingResponse | None":
+        """Convert to FinishedRecordingResponse if duration is available and status is finished."""
+        if self.duration is None or self.status != "finished":
+            return None
+        return FinishedRecordingResponse(**self.model_dump())
+
+
+class FinishedRecordingResponse(RecordingResponse):
+    """
+    Recording with confirmed duration - ready for processing.
+
+    This model guarantees duration is present and status is finished.
+    """
+
+    status: Literal["finished"] = Field(
+        description="Recording status (always 'finished')"
+    )
+    duration: int = Field(description="Recording duration in seconds")
+
 
 class MeetingTokenResponse(BaseModel):
     """

server/reflector/db/recordings.py

@@ -3,6 +3,7 @@ from typing import Literal
 
 import sqlalchemy as sa
 from pydantic import BaseModel, Field
+from sqlalchemy import or_
 
 from reflector.db import get_database, metadata
 from reflector.utils import generate_uuid4
@@ -35,8 +36,15 @@ class Recording(BaseModel):
     status: Literal["pending", "processing", "completed", "failed"] = "pending"
     meeting_id: str | None = None
     # for multitrack reprocessing
+    # track_keys can be empty list [] if recording finished but no audio was captured (silence/muted)
+    # None means not a multitrack recording, [] means multitrack with no tracks
     track_keys: list[str] | None = None
 
+    @property
+    def is_multitrack(self) -> bool:
+        """True if recording has separate audio tracks (1+ tracks counts as multitrack)."""
+        return self.track_keys is not None and len(self.track_keys) > 0
+
 
 class RecordingController:
     async def create(self, recording: Recording):
@@ -72,5 +80,35 @@ class RecordingController:
         results = await get_database().fetch_all(query)
         return [Recording(**row) for row in results]
 
+    async def get_multitrack_needing_reprocessing(
+        self, bucket_name: str
+    ) -> list[Recording]:
+        """
+        Get multitrack recordings that need reprocessing:
+        - Have track_keys (multitrack)
+        - Either have no transcript OR transcript has error status
+
+        This is more efficient than fetching all recordings and filtering in Python.
+        """
+        from reflector.db.transcripts import (
+            transcripts,  # noqa: PLC0415 cyclic import
+        )
+
+        query = (
+            recordings.select()
+            .outerjoin(transcripts, recordings.c.id == transcripts.c.recording_id)
+            .where(
+                recordings.c.bucket_name == bucket_name,
+                recordings.c.track_keys.isnot(None),
+                or_(
+                    transcripts.c.id.is_(None),
+                    transcripts.c.status == "error",
+                ),
+            )
+        )
+        results = await get_database().fetch_all(query)
+        recordings_list = [Recording(**row) for row in results]
+        return [r for r in recordings_list if r.is_multitrack]
+
 
 recordings_controller = RecordingController()

server/reflector/db/rooms.py

@@ -57,6 +57,12 @@ rooms = sqlalchemy.Table(
         sqlalchemy.String,
         nullable=False,
     ),
+    sqlalchemy.Column(
+        "skip_consent",
+        sqlalchemy.Boolean,
+        nullable=False,
+        server_default=sqlalchemy.sql.false(),
+    ),
     sqlalchemy.Index("idx_room_is_shared", "is_shared"),
     sqlalchemy.Index("idx_room_ics_enabled", "ics_enabled"),
 )
@@ -85,6 +91,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)
+    skip_consent: bool = False
 
 
 class RoomController:
@@ -139,6 +146,7 @@ class RoomController:
         ics_fetch_interval: int = 300,
         ics_enabled: bool = False,
         platform: Platform = settings.DEFAULT_VIDEO_PLATFORM,
+        skip_consent: bool = False,
     ):
         """
         Add a new room
@@ -163,6 +171,7 @@ class RoomController:
             "ics_fetch_interval": ics_fetch_interval,
             "ics_enabled": ics_enabled,
             "platform": platform,
+            "skip_consent": skip_consent,
         }
 
         room = Room(**room_data)

server/reflector/db/transcripts.py

@@ -44,6 +44,7 @@ transcripts = sqlalchemy.Table(
     sqlalchemy.Column("title", sqlalchemy.String),
     sqlalchemy.Column("short_summary", sqlalchemy.String),
     sqlalchemy.Column("long_summary", sqlalchemy.String),
+    sqlalchemy.Column("action_items", sqlalchemy.JSON),
     sqlalchemy.Column("topics", sqlalchemy.JSON),
     sqlalchemy.Column("events", sqlalchemy.JSON),
     sqlalchemy.Column("participants", sqlalchemy.JSON),
@@ -164,6 +165,10 @@ class TranscriptFinalLongSummary(BaseModel):
     long_summary: str
 
 
+class TranscriptActionItems(BaseModel):
+    action_items: dict
+
+
 class TranscriptFinalTitle(BaseModel):
     title: str
 
@@ -204,6 +209,7 @@ class Transcript(BaseModel):
     locked: bool = False
     short_summary: str | None = None
     long_summary: str | None = None
+    action_items: dict | None = None
     topics: list[TranscriptTopic] = []
     events: list[TranscriptEvent] = []
     participants: list[TranscriptParticipant] | None = []
@@ -368,7 +374,12 @@ class TranscriptController:
         room_id: str | None = None,
         search_term: str | None = None,
         return_query: bool = False,
-        exclude_columns: list[str] = ["topics", "events", "participants"],
+        exclude_columns: list[str] = [
+            "topics",
+            "events",
+            "participants",
+            "action_items",
+        ],
     ) -> list[Transcript]:
         """
         Get all transcripts

server/reflector/db/users.py

@@ -88,5 +88,11 @@ class UserController:
         results = await get_database().fetch_all(query)
         return [User(**r) for r in results]
 
+    @staticmethod
+    async def get_by_ids(user_ids: list[NonEmptyString]) -> dict[str, User]:
+        query = users.select().where(users.c.id.in_(user_ids))
+        results = await get_database().fetch_all(query)
+        return {user.id: User(**user) for user in results}
+
 
 user_controller = UserController()

server/reflector/llm.py

@@ -1,14 +1,32 @@
 import logging
-from typing import Type, TypeVar
+from contextvars import ContextVar
+from typing import Generic, Type, TypeVar
+from uuid import uuid4
 
 from llama_index.core import Settings
 from llama_index.core.output_parsers import PydanticOutputParser
-from llama_index.core.program import LLMTextCompletionProgram
 from llama_index.core.response_synthesizers import TreeSummarize
+from llama_index.core.workflow import (
+    Context,
+    Event,
+    StartEvent,
+    StopEvent,
+    Workflow,
+    step,
+)
 from llama_index.llms.openai_like import OpenAILike
 from pydantic import BaseModel, ValidationError
+from workflows.errors import WorkflowTimeoutError
+
+from reflector.utils.retry import retry
 
 T = TypeVar("T", bound=BaseModel)
+OutputT = TypeVar("OutputT", bound=BaseModel)
+
+# Session ID for LiteLLM request grouping - set per processing run
+llm_session_id: ContextVar[str | None] = ContextVar("llm_session_id", default=None)
+
+logger = logging.getLogger(__name__)
 
 STRUCTURED_RESPONSE_PROMPT_TEMPLATE = """
 Based on the following analysis, provide the information in the requested JSON format:
@@ -20,6 +38,158 @@ Analysis:
 """
 
 
+class LLMParseError(Exception):
+    """Raised when LLM output cannot be parsed after retries."""
+
+    def __init__(self, output_cls: Type[BaseModel], error_msg: str, attempts: int):
+        self.output_cls = output_cls
+        self.error_msg = error_msg
+        self.attempts = attempts
+        super().__init__(
+            f"Failed to parse {output_cls.__name__} after {attempts} attempts: {error_msg}"
+        )
+
+
+class ExtractionDone(Event):
+    """Event emitted when LLM JSON formatting completes."""
+
+    output: str
+
+
+class ValidationErrorEvent(Event):
+    """Event emitted when validation fails."""
+
+    error: str
+    wrong_output: str
+
+
+class StructuredOutputWorkflow(Workflow, Generic[OutputT]):
+    """Workflow for structured output extraction with validation retry.
+
+    This workflow handles parse/validation retries only. Network error retries
+    are handled internally by Settings.llm (OpenAILike max_retries=3).
+    The caller should NOT wrap this workflow in additional retry logic.
+    """
+
+    def __init__(
+        self,
+        output_cls: Type[OutputT],
+        max_retries: int = 3,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.output_cls: Type[OutputT] = output_cls
+        self.max_retries = max_retries
+        self.output_parser = PydanticOutputParser(output_cls)
+
+    @step
+    async def extract(
+        self, ctx: Context, ev: StartEvent | ValidationErrorEvent
+    ) -> StopEvent | ExtractionDone:
+        """Extract structured data from text using two-step LLM process.
+
+        Step 1 (first call only): TreeSummarize generates text analysis
+        Step 2 (every call): Settings.llm.acomplete formats analysis as JSON
+        """
+        current_retries = await ctx.store.get("retries", default=0)
+        await ctx.store.set("retries", current_retries + 1)
+
+        if current_retries >= self.max_retries:
+            last_error = await ctx.store.get("last_error", default=None)
+            logger.error(
+                f"Max retries ({self.max_retries}) reached for {self.output_cls.__name__}"
+            )
+            return StopEvent(result={"error": last_error, "attempts": current_retries})
+
+        if isinstance(ev, StartEvent):
+            # First call: run TreeSummarize to get analysis, store in context
+            prompt = ev.get("prompt")
+            texts = ev.get("texts")
+            tone_name = ev.get("tone_name")
+            if not prompt or not isinstance(texts, list):
+                raise ValueError(
+                    "StartEvent must contain 'prompt' (str) and 'texts' (list)"
+                )
+
+            summarizer = TreeSummarize(verbose=False)
+            analysis = await summarizer.aget_response(
+                prompt, texts, tone_name=tone_name
+            )
+            await ctx.store.set("analysis", str(analysis))
+            reflection = ""
+        else:
+            # Retry: reuse analysis from context
+            analysis = await ctx.store.get("analysis")
+            if not analysis:
+                raise RuntimeError("Internal error: analysis not found in context")
+
+            wrong_output = ev.wrong_output
+            if len(wrong_output) > 2000:
+                wrong_output = wrong_output[:2000] + "... [truncated]"
+            reflection = (
+                f"\n\nYour previous response could not be parsed:\n{wrong_output}\n\n"
+                f"Error:\n{ev.error}\n\n"
+                "Please try again. Return ONLY valid JSON matching the schema above, "
+                "with no markdown formatting or extra text."
+            )
+
+        # Step 2: Format analysis as JSON using LLM completion
+        format_instructions = self.output_parser.format(
+            "Please structure the above information in the following JSON format:"
+        )
+
+        json_prompt = STRUCTURED_RESPONSE_PROMPT_TEMPLATE.format(
+            analysis=analysis,
+            format_instructions=format_instructions + reflection,
+        )
+
+        # Network retries handled by OpenAILike (max_retries=3)
+        response = await Settings.llm.acomplete(json_prompt)
+        return ExtractionDone(output=response.text)
+
+    @step
+    async def validate(
+        self, ctx: Context, ev: ExtractionDone
+    ) -> StopEvent | ValidationErrorEvent:
+        """Validate extracted output against Pydantic schema."""
+        raw_output = ev.output
+        retries = await ctx.store.get("retries", default=0)
+
+        try:
+            parsed = self.output_parser.parse(raw_output)
+            if retries > 1:
+                logger.info(
+                    f"LLM parse succeeded on attempt {retries}/{self.max_retries} "
+                    f"for {self.output_cls.__name__}"
+                )
+            return StopEvent(result={"success": parsed})
+
+        except (ValidationError, ValueError) as e:
+            error_msg = self._format_error(e, raw_output)
+            await ctx.store.set("last_error", error_msg)
+
+            logger.error(
+                f"LLM parse error (attempt {retries}/{self.max_retries}): "
+                f"{type(e).__name__}: {e}\nRaw response: {raw_output[:500]}"
+            )
+
+            return ValidationErrorEvent(
+                error=error_msg,
+                wrong_output=raw_output,
+            )
+
+    def _format_error(self, error: Exception, raw_output: str) -> str:
+        """Format error for LLM feedback."""
+        if isinstance(error, ValidationError):
+            error_messages = []
+            for err in error.errors():
+                field = ".".join(str(loc) for loc in err["loc"])
+                error_messages.append(f"- {err['msg']} in field '{field}'")
+            return "Schema validation errors:\n" + "\n".join(error_messages)
+        else:
+            return f"Parse error: {str(error)}"
+
+
 class LLM:
     def __init__(self, settings, temperature: float = 0.4, max_tokens: int = 2048):
         self.settings_obj = settings
@@ -30,11 +200,12 @@ class LLM:
         self.temperature = temperature
         self.max_tokens = max_tokens
 
-        # Configure llamaindex Settings
         self._configure_llamaindex()
 
     def _configure_llamaindex(self):
         """Configure llamaindex Settings with OpenAILike LLM"""
+        session_id = llm_session_id.get() or f"fallback-{uuid4().hex}"
+
         Settings.llm = OpenAILike(
             model=self.model_name,
             api_base=self.url,
@@ -44,6 +215,7 @@ class LLM:
             is_function_calling_model=False,
             temperature=self.temperature,
             max_tokens=self.max_tokens,
+            additional_kwargs={"extra_body": {"litellm_session_id": session_id}},
         )
 
     async def get_response(
@@ -60,44 +232,38 @@ class LLM:
         texts: list[str],
         output_cls: Type[T],
         tone_name: str | None = None,
+        timeout: int | None = None,
     ) -> T:
-        """Get structured output from LLM for non-function-calling models"""
+        """Get structured output from LLM with validation retry via Workflow."""
-        logger = logging.getLogger(__name__)
+        if timeout is None:
+            timeout = self.settings_obj.LLM_STRUCTURED_RESPONSE_TIMEOUT
 
-        summarizer = TreeSummarize(verbose=True)
+        async def run_workflow():
-        response = await summarizer.aget_response(prompt, texts, tone_name=tone_name)
+            workflow = StructuredOutputWorkflow(
-
+                output_cls=output_cls,
-        output_parser = PydanticOutputParser(output_cls)
+                max_retries=self.settings_obj.LLM_PARSE_MAX_RETRIES + 1,
-
+                timeout=timeout,
-        program = LLMTextCompletionProgram.from_defaults(
-            output_parser=output_parser,
-            prompt_template_str=STRUCTURED_RESPONSE_PROMPT_TEMPLATE,
-            verbose=False,
-        )
-
-        format_instructions = output_parser.format(
-            "Please structure the above information in the following JSON format:"
-        )
-
-        try:
-            output = await program.acall(
-                analysis=str(response), format_instructions=format_instructions
             )
-        except ValidationError as e:
-            # Extract the raw JSON from the error details
-            errors = e.errors()
-            if errors and "input" in errors[0]:
-                raw_json = errors[0]["input"]
-                logger.error(
-                    f"JSON validation failed for {output_cls.__name__}. "
-                    f"Full raw JSON output:\n{raw_json}\n"
-                    f"Validation errors: {errors}"
-                )
-            else:
-                logger.error(
-                    f"JSON validation failed for {output_cls.__name__}. "
-                    f"Validation errors: {errors}"
-                )
-            raise
 
-        return output
+            result = await workflow.run(
+                prompt=prompt,
+                texts=texts,
+                tone_name=tone_name,
+            )
+
+            if "error" in result:
+                error_msg = result["error"] or "Max retries exceeded"
+                raise LLMParseError(
+                    output_cls=output_cls,
+                    error_msg=error_msg,
+                    attempts=result.get("attempts", 0),
+                )
+
+            return result["success"]
+
+        return await retry(run_workflow)(
+            retry_attempts=3,
+            retry_backoff_interval=1.0,
+            retry_backoff_max=30.0,
+            retry_ignore_exc_types=(WorkflowTimeoutError,),
+        )

server/reflector/pipelines/main_file_pipeline.py

@@ -309,6 +309,7 @@ class PipelineMainFile(PipelineMainBase):
             transcript,
             on_long_summary_callback=self.on_long_summary,
             on_short_summary_callback=self.on_short_summary,
+            on_action_items_callback=self.on_action_items,
             empty_pipeline=self.empty_pipeline,
             logger=self.logger,
         )
@@ -340,7 +341,6 @@ async def task_send_webhook_if_needed(*, transcript_id: str):
 @asynctask
 async def task_pipeline_file_process(*, transcript_id: str):
     """Celery task for file pipeline processing"""
-
     transcript = await transcripts_controller.get_by_id(transcript_id)
     if not transcript:
         raise Exception(f"Transcript {transcript_id} not found")

server/reflector/pipelines/main_live_pipeline.py

@@ -27,6 +27,7 @@ from reflector.db.recordings import recordings_controller
 from reflector.db.rooms import rooms_controller
 from reflector.db.transcripts import (
     Transcript,
+    TranscriptActionItems,
     TranscriptDuration,
     TranscriptFinalLongSummary,
     TranscriptFinalShortSummary,
@@ -111,7 +112,7 @@ def get_transcript(func):
         transcript_id = kwargs.pop("transcript_id")
         transcript = await transcripts_controller.get_by_id(transcript_id=transcript_id)
         if not transcript:
-            raise Exception("Transcript {transcript_id} not found")
+            raise Exception(f"Transcript {transcript_id} not found")
 
         # Enhanced logger with Celery task context
         tlogger = logger.bind(transcript_id=transcript.id)
@@ -306,6 +307,23 @@ class PipelineMainBase(PipelineRunner[PipelineMessage], Generic[PipelineMessage]
                 data=final_short_summary,
             )
 
+    @broadcast_to_sockets
+    async def on_action_items(self, data):
+        action_items = TranscriptActionItems(action_items=data.action_items)
+        async with self.transaction():
+            transcript = await self.get_transcript()
+            await transcripts_controller.update(
+                transcript,
+                {
+                    "action_items": action_items.action_items,
+                },
+            )
+            return await transcripts_controller.append_event(
+                transcript=transcript,
+                event="ACTION_ITEMS",
+                data=action_items,
+            )
+
     @broadcast_to_sockets
     async def on_duration(self, data):
         async with self.transaction():
@@ -465,6 +483,7 @@ class PipelineMainFinalSummaries(PipelineMainFromTopics):
                 transcript=self._transcript,
                 callback=self.on_long_summary,
                 on_short_summary=self.on_short_summary,
+                on_action_items=self.on_action_items,
             ),
         ]
 

server/reflector/pipelines/main_multitrack_pipeline.py

@@ -9,7 +9,10 @@ from av.audio.resampler import AudioResampler
 from celery import chain, shared_task
 
 from reflector.asynctask import asynctask
+from reflector.dailyco_api import MeetingParticipantsResponse
 from reflector.db.transcripts import (
+    Transcript,
+    TranscriptParticipant,
     TranscriptStatus,
     TranscriptWaveform,
     transcripts_controller,
@@ -29,7 +32,12 @@ from reflector.processors.audio_waveform_processor import AudioWaveformProcessor
 from reflector.processors.types import TitleSummary
 from reflector.processors.types import Transcript as TranscriptType
 from reflector.storage import Storage, get_transcripts_storage
+from reflector.utils.daily import (
+    filter_cam_audio_tracks,
+    parse_daily_recording_filename,
+)
 from reflector.utils.string import NonEmptyString
+from reflector.video_platforms.factory import create_platform_client
 
 # Audio encoding constants
 OPUS_STANDARD_SAMPLE_RATE = 48000
@@ -414,7 +422,15 @@ class PipelineMainMultitrack(PipelineMainBase):
             # Open all containers with cleanup guaranteed
             for i, url in enumerate(valid_track_urls):
                 try:
-                    c = av.open(url)
+                    c = av.open(
+                        url,
+                        options={
+                            # it's trying to stream from s3 by default
+                            "reconnect": "1",
+                            "reconnect_streamed": "1",
+                            "reconnect_delay_max": "5",
+                        },
+                    )
                     containers.append(c)
                 except Exception as e:
                     self.logger.warning(
@@ -443,6 +459,8 @@ class PipelineMainMultitrack(PipelineMainBase):
                         frame = next(dec)
                     except StopIteration:
                         active[i] = False
+                        # causes stream to move on / unclogs memory
+                        inputs[i].push(None)
                         continue
 
                     if frame.sample_rate != target_sample_rate:
@@ -462,8 +480,6 @@ class PipelineMainMultitrack(PipelineMainBase):
                         mixed.time_base = Fraction(1, target_sample_rate)
                         await writer.push(mixed)
 
-            for in_ctx in inputs:
-                in_ctx.push(None)
             while True:
                 try:
                     mixed = sink.pull()
@@ -494,6 +510,90 @@ class PipelineMainMultitrack(PipelineMainBase):
                 transcript=transcript, event="WAVEFORM", data=waveform
             )
 
+    async def update_participants_from_daily(
+        self, transcript: Transcript, track_keys: list[str]
+    ) -> None:
+        """Update transcript participants with user_id and names from Daily.co API."""
+        if not transcript.recording_id:
+            return
+
+        try:
+            async with create_platform_client("daily") as daily_client:
+                id_to_name = {}
+                id_to_user_id = {}
+
+                try:
+                    rec_details = await daily_client.get_recording(
+                        transcript.recording_id
+                    )
+                    mtg_session_id = rec_details.mtgSessionId
+                    if mtg_session_id:
+                        try:
+                            payload: MeetingParticipantsResponse = (
+                                await daily_client.get_meeting_participants(
+                                    mtg_session_id
+                                )
+                            )
+                            for p in payload.data:
+                                pid = p.participant_id
+                                name = p.user_name
+                                user_id = p.user_id
+                                if name:
+                                    id_to_name[pid] = name
+                                if user_id:
+                                    id_to_user_id[pid] = user_id
+                        except Exception as e:
+                            self.logger.warning(
+                                "Failed to fetch Daily meeting participants",
+                                error=str(e),
+                                mtg_session_id=mtg_session_id,
+                                exc_info=True,
+                            )
+                    else:
+                        self.logger.warning(
+                            "No mtgSessionId found for recording; participant names may be generic",
+                            recording_id=transcript.recording_id,
+                        )
+                except Exception as e:
+                    self.logger.warning(
+                        "Failed to fetch Daily recording details",
+                        error=str(e),
+                        recording_id=transcript.recording_id,
+                        exc_info=True,
+                    )
+                    return
+
+                cam_audio_keys = filter_cam_audio_tracks(track_keys)
+
+                for idx, key in enumerate(cam_audio_keys):
+                    try:
+                        parsed = parse_daily_recording_filename(key)
+                        participant_id = parsed.participant_id
+                    except ValueError as e:
+                        self.logger.error(
+                            "Failed to parse Daily recording filename",
+                            error=str(e),
+                            key=key,
+                            exc_info=True,
+                        )
+                        continue
+
+                    default_name = f"Speaker {idx}"
+                    name = id_to_name.get(participant_id, default_name)
+                    user_id = id_to_user_id.get(participant_id)
+
+                    participant = TranscriptParticipant(
+                        id=participant_id, speaker=idx, name=name, user_id=user_id
+                    )
+                    await transcripts_controller.upsert_participant(
+                        transcript, participant
+                    )
+
+        except Exception as e:
+            self.logger.warning(
+                "Failed to map participant names", error=str(e), exc_info=True
+            )
+
     async def process(self, bucket_name: str, track_keys: list[str]):
         transcript = await self.get_transcript()
         async with self.transaction():
@@ -502,9 +602,12 @@ class PipelineMainMultitrack(PipelineMainBase):
                 {
                     "events": [],
                     "topics": [],
+                    "participants": [],
                 },
             )
 
+        await self.update_participants_from_daily(transcript, track_keys)
+
         source_storage = get_transcripts_storage()
         transcript_storage = source_storage
 
@@ -669,6 +772,7 @@ class PipelineMainMultitrack(PipelineMainBase):
             transcript,
             on_long_summary_callback=self.on_long_summary,
             on_short_summary_callback=self.on_short_summary,
+            on_action_items_callback=self.on_action_items,
             empty_pipeline=self.empty_pipeline,
             logger=self.logger,
         )

server/reflector/pipelines/topic_processing.py

@@ -89,6 +89,7 @@ async def generate_summaries(
     *,
     on_long_summary_callback: Callable,
     on_short_summary_callback: Callable,
+    on_action_items_callback: Callable,
     empty_pipeline: EmptyPipeline,
     logger: structlog.BoundLogger,
 ):
@@ -96,11 +97,14 @@ async def generate_summaries(
         logger.warning("No topics for summary generation")
         return
 
-    processor = TranscriptFinalSummaryProcessor(
+    processor_kwargs = {
-        transcript=transcript,
+        "transcript": transcript,
-        callback=on_long_summary_callback,
+        "callback": on_long_summary_callback,
-        on_short_summary=on_short_summary_callback,
+        "on_short_summary": on_short_summary_callback,
-    )
+        "on_action_items": on_action_items_callback,
+    }
+
+    processor = TranscriptFinalSummaryProcessor(**processor_kwargs)
     processor.set_pipeline(empty_pipeline)
 
     for topic in topics:

server/reflector/processors/summary/summary_builder.py

@@ -96,6 +96,36 @@ RECAP_PROMPT = dedent(
     """
 ).strip()
 
+ACTION_ITEMS_PROMPT = dedent(
+    """
+    Identify action items from this meeting transcript. Your goal is to identify what was decided and what needs to happen next.
+
+    Look for:
+
+    1. **Decisions Made**: Any decisions, choices, or conclusions reached during the meeting. For each decision:
+       - What was decided? (be specific)
+       - Who made the decision or was involved? (use actual participant names)
+       - Why was this decision made? (key factors, reasoning, or rationale)
+
+    2. **Next Steps / Action Items**: Any tasks, follow-ups, or actions that were mentioned or assigned. For each action item:
+       - What specific task needs to be done? (be concrete and actionable)
+       - Who is responsible? (use actual participant names if mentioned, or "team" if unclear)
+       - When is it due? (any deadlines, timeframes, or "by next meeting" type commitments)
+       - What context is needed? (any additional details that help understand the task)
+
+    Guidelines:
+    - Be thorough and identify all action items, even if they seem minor
+    - Include items that were agreed upon, assigned, or committed to
+    - Include decisions even if they seem obvious or implicit
+    - If someone says "I'll do X" or "We should do Y", that's an action item
+    - If someone says "Let's go with option A", that's a decision
+    - Use the exact participant names from the transcript
+    - If no participant name is mentioned, you can leave assigned_to/decided_by as null
+
+    Only return empty lists if the transcript contains NO decisions and NO action items whatsoever.
+    """
+).strip()
+
 STRUCTURED_RESPONSE_PROMPT_TEMPLATE = dedent(
     """
     Based on the following analysis, provide the information in the requested JSON format:
@@ -155,6 +185,53 @@ class SubjectsResponse(BaseModel):
     )
 
 
+class ActionItem(BaseModel):
+    """A single action item from the meeting"""
+
+    task: str = Field(description="The task or action item to be completed")
+    assigned_to: str | None = Field(
+        default=None, description="Person or team assigned to this task (name)"
+    )
+    assigned_to_participant_id: str | None = Field(
+        default=None, description="Participant ID if assigned_to matches a participant"
+    )
+    deadline: str | None = Field(
+        default=None, description="Deadline or timeframe mentioned for this task"
+    )
+    context: str | None = Field(
+        default=None, description="Additional context or notes about this task"
+    )
+
+
+class Decision(BaseModel):
+    """A decision made during the meeting"""
+
+    decision: str = Field(description="What was decided")
+    rationale: str | None = Field(
+        default=None,
+        description="Reasoning or key factors that influenced this decision",
+    )
+    decided_by: str | None = Field(
+        default=None, description="Person or group who made the decision (name)"
+    )
+    decided_by_participant_id: str | None = Field(
+        default=None, description="Participant ID if decided_by matches a participant"
+    )
+
+
+class ActionItemsResponse(BaseModel):
+    """Pydantic model for identified action items"""
+
+    decisions: list[Decision] = Field(
+        default_factory=list,
+        description="List of decisions made during the meeting",
+    )
+    next_steps: list[ActionItem] = Field(
+        default_factory=list,
+        description="List of action items and next steps to be taken",
+    )
+
+
 class SummaryBuilder:
     def __init__(self, llm: LLM, filename: str | None = None, logger=None) -> None:
         self.transcript: str | None = None
@@ -166,6 +243,8 @@ class SummaryBuilder:
         self.model_name: str = llm.model_name
         self.logger = logger or structlog.get_logger()
         self.participant_instructions: str | None = None
+        self.action_items: ActionItemsResponse | None = None
+        self.participant_name_to_id: dict[str, str] = {}
         if filename:
             self.read_transcript_from_file(filename)
 
@@ -189,13 +268,20 @@ class SummaryBuilder:
         self.llm = llm
 
     async def _get_structured_response(
-        self, prompt: str, output_cls: Type[T], tone_name: str | None = None
+        self,
+        prompt: str,
+        output_cls: Type[T],
+        tone_name: str | None = None,
+        timeout: int | None = None,
     ) -> T:
         """Generic function to get structured output from LLM for non-function-calling models."""
-        # Add participant instructions to the prompt if available
         enhanced_prompt = self._enhance_prompt_with_participants(prompt)
         return await self.llm.get_structured_response(
-            enhanced_prompt, [self.transcript], output_cls, tone_name=tone_name
+            enhanced_prompt,
+            [self.transcript],
+            output_cls,
+            tone_name=tone_name,
+            timeout=timeout,
         )
 
     async def _get_response(
@@ -216,11 +302,19 @@ class SummaryBuilder:
     # Participants
     # ----------------------------------------------------------------------------
 
-    def set_known_participants(self, participants: list[str]) -> None:
+    def set_known_participants(
+        self,
+        participants: list[str],
+        participant_name_to_id: dict[str, str] | None = None,
+    ) -> None:
         """
         Set known participants directly without LLM identification.
         This is used when participants are already identified and stored.
         They are appended at the end of the transcript, providing more context for the assistant.
+
+        Args:
+            participants: List of participant names
+            participant_name_to_id: Optional mapping of participant names to their IDs
         """
         if not participants:
             self.logger.warning("No participants provided")
@@ -231,10 +325,12 @@ class SummaryBuilder:
             participants=participants,
         )
 
+        if participant_name_to_id:
+            self.participant_name_to_id = participant_name_to_id
+
         participants_md = self.format_list_md(participants)
         self.transcript += f"\n\n# Participants\n\n{participants_md}"
 
-        # Set instructions that will be automatically added to all prompts
         participants_list = ", ".join(participants)
         self.participant_instructions = dedent(
             f"""
@@ -413,6 +509,92 @@ class SummaryBuilder:
         self.recap = str(recap_response)
         self.logger.info(f"Quick recap: {self.recap}")
 
+    def _map_participant_names_to_ids(
+        self, response: ActionItemsResponse
+    ) -> ActionItemsResponse:
+        """Map participant names in action items to participant IDs."""
+        if not self.participant_name_to_id:
+            return response
+
+        decisions = []
+        for decision in response.decisions:
+            new_decision = decision.model_copy()
+            if (
+                decision.decided_by
+                and decision.decided_by in self.participant_name_to_id
+            ):
+                new_decision.decided_by_participant_id = self.participant_name_to_id[
+                    decision.decided_by
+                ]
+            decisions.append(new_decision)
+
+        next_steps = []
+        for item in response.next_steps:
+            new_item = item.model_copy()
+            if item.assigned_to and item.assigned_to in self.participant_name_to_id:
+                new_item.assigned_to_participant_id = self.participant_name_to_id[
+                    item.assigned_to
+                ]
+            next_steps.append(new_item)
+
+        return ActionItemsResponse(decisions=decisions, next_steps=next_steps)
+
+    async def identify_action_items(self) -> ActionItemsResponse | None:
+        """Identify action items (decisions and next steps) from the transcript."""
+        self.logger.info("--- identify action items using TreeSummarize")
+
+        if not self.transcript:
+            self.logger.warning(
+                "No transcript available for action items identification"
+            )
+            self.action_items = None
+            return None
+
+        action_items_prompt = ACTION_ITEMS_PROMPT
+
+        try:
+            response = await self._get_structured_response(
+                action_items_prompt,
+                ActionItemsResponse,
+                tone_name="Action item identifier",
+                timeout=settings.LLM_STRUCTURED_RESPONSE_TIMEOUT,
+            )
+
+            response = self._map_participant_names_to_ids(response)
+
+            self.action_items = response
+            self.logger.info(
+                f"Identified {len(response.decisions)} decisions and {len(response.next_steps)} action items",
+                decisions_count=len(response.decisions),
+                next_steps_count=len(response.next_steps),
+            )
+
+            if response.decisions:
+                self.logger.debug(
+                    "Decisions identified",
+                    decisions=[d.decision for d in response.decisions],
+                )
+            if response.next_steps:
+                self.logger.debug(
+                    "Action items identified",
+                    tasks=[item.task for item in response.next_steps],
+                )
+            if not response.decisions and not response.next_steps:
+                self.logger.warning(
+                    "No action items identified from transcript",
+                    transcript_length=len(self.transcript),
+                )
+
+            return response
+
+        except Exception as e:
+            self.logger.error(
+                f"Error identifying action items: {e}",
+                exc_info=True,
+            )
+            self.action_items = None
+            return None
+
     async def generate_summary(self, only_subjects: bool = False) -> None:
         """
         Generate summary by extracting subjects, creating summaries for each, and generating a recap.
@@ -424,6 +606,7 @@ class SummaryBuilder:
 
         await self.generate_subject_summaries()
         await self.generate_recap()
+        await self.identify_action_items()
 
     # ----------------------------------------------------------------------------
     # Markdown
@@ -526,8 +709,6 @@ if __name__ == "__main__":
         if args.summary:
             await sm.generate_summary()
 
-        # Note: action items generation has been removed
-
         print("")
         print("-" * 80)
         print("")

server/reflector/processors/transcript_final_summary.py

@@ -1,7 +1,12 @@
 from reflector.llm import LLM
 from reflector.processors.base import Processor
 from reflector.processors.summary.summary_builder import SummaryBuilder
-from reflector.processors.types import FinalLongSummary, FinalShortSummary, TitleSummary
+from reflector.processors.types import (
+    ActionItems,
+    FinalLongSummary,
+    FinalShortSummary,
+    TitleSummary,
+)
 from reflector.settings import settings
 
 
@@ -27,15 +32,20 @@ class TranscriptFinalSummaryProcessor(Processor):
         builder = SummaryBuilder(self.llm, logger=self.logger)
         builder.set_transcript(text)
 
-        # Use known participants if available, otherwise identify them
         if self.transcript and self.transcript.participants:
-            # Extract participant names from the stored participants
             participant_names = [p.name for p in self.transcript.participants if p.name]
             if participant_names:
                 self.logger.info(
                     f"Using {len(participant_names)} known participants from transcript"
                 )
-                builder.set_known_participants(participant_names)
+                participant_name_to_id = {
+                    p.name: p.id
+                    for p in self.transcript.participants
+                    if p.name and p.id
+                }
+                builder.set_known_participants(
+                    participant_names, participant_name_to_id=participant_name_to_id
+                )
             else:
                 self.logger.info(
                     "Participants field exists but is empty, identifying participants"
@@ -63,7 +73,6 @@ class TranscriptFinalSummaryProcessor(Processor):
             self.logger.warning("No summary to output")
             return
 
-        # build the speakermap from the transcript
         speakermap = {}
         if self.transcript:
             speakermap = {
@@ -76,8 +85,6 @@ class TranscriptFinalSummaryProcessor(Processor):
                 speakermap=speakermap,
             )
 
-        # build the transcript as a single string
-        # Replace speaker IDs with actual participant names if available
         text_transcript = []
         unique_speakers = set()
         for topic in self.chunks:
@@ -111,4 +118,9 @@ class TranscriptFinalSummaryProcessor(Processor):
             )
             await self.emit(final_short_summary, name="short_summary")
 
+        if self.builder and self.builder.action_items:
+            action_items = self.builder.action_items.model_dump()
+            action_items = ActionItems(action_items=action_items)
+            await self.emit(action_items, name="action_items")
+
         await self.emit(final_long_summary)

server/reflector/processors/transcript_topic_detector.py

@@ -78,7 +78,11 @@ class TranscriptTopicDetectorProcessor(Processor):
         """
         prompt = TOPIC_PROMPT.format(text=text)
         response = await self.llm.get_structured_response(
-            prompt, [text], TopicResponse, tone_name="Topic analyzer"
+            prompt,
+            [text],
+            TopicResponse,
+            tone_name="Topic analyzer",
+            timeout=settings.LLM_STRUCTURED_RESPONSE_TIMEOUT,
         )
         return response
 

server/reflector/processors/types.py

@@ -1,6 +1,7 @@
 import io
 import re
 import tempfile
+from collections import defaultdict
 from pathlib import Path
 from typing import Annotated, TypedDict
 
@@ -16,6 +17,17 @@ class DiarizationSegment(TypedDict):
 
 
 PUNC_RE = re.compile(r"[.;:?!…]")
+SENTENCE_END_RE = re.compile(r"[.?!…]$")
+
+# Max segment length for words_to_segments() - breaks on any punctuation (. ; : ? ! …)
+# when segment exceeds this limit. Used for non-multitrack recordings.
+MAX_SEGMENT_CHARS = 120
+
+# Max segment length for words_to_segments_by_sentence() - only breaks on sentence-ending
+# punctuation (. ? ! …) when segment exceeds this limit. Higher threshold allows complete
+# sentences in multitrack recordings where speakers overlap.
+# similar number to server/reflector/processors/transcript_liner.py
+MAX_SENTENCE_SEGMENT_CHARS = 1000
 
 
 class AudioFile(BaseModel):
@@ -76,7 +88,6 @@ def words_to_segments(words: list[Word]) -> list[TranscriptSegment]:
     # but separate if the speaker changes, or if the punctuation is a . , ; : ? !
     segments = []
     current_segment = None
-    MAX_SEGMENT_LENGTH = 120
 
     for word in words:
         if current_segment is None:
@@ -106,7 +117,7 @@ def words_to_segments(words: list[Word]) -> list[TranscriptSegment]:
         current_segment.end = word.end
 
         have_punc = PUNC_RE.search(word.text)
-        if have_punc and (len(current_segment.text) > MAX_SEGMENT_LENGTH):
+        if have_punc and (len(current_segment.text) > MAX_SEGMENT_CHARS):
             segments.append(current_segment)
             current_segment = None
 
@@ -116,6 +127,70 @@ def words_to_segments(words: list[Word]) -> list[TranscriptSegment]:
     return segments
 
 
+def words_to_segments_by_sentence(words: list[Word]) -> list[TranscriptSegment]:
+    """Group words by speaker, then split into sentences.
+
+    For multitrack recordings where words from different speakers are interleaved
+    by timestamp, this function first groups all words by speaker, then creates
+    segments based on sentence boundaries within each speaker's words.
+
+    This produces cleaner output than words_to_segments() which breaks on every
+    speaker change, resulting in many tiny segments when speakers overlap.
+    """
+    if not words:
+        return []
+
+    # Group words by speaker, preserving order within each speaker
+    by_speaker: dict[int, list[Word]] = defaultdict(list)
+    for w in words:
+        by_speaker[w.speaker].append(w)
+
+    segments: list[TranscriptSegment] = []
+
+    for speaker, speaker_words in by_speaker.items():
+        current_text = ""
+        current_start: float | None = None
+        current_end: float = 0.0
+
+        for word in speaker_words:
+            if current_start is None:
+                current_start = word.start
+
+            current_text += word.text
+            current_end = word.end
+
+            # Check for sentence end or max length
+            is_sentence_end = SENTENCE_END_RE.search(word.text.strip())
+            is_too_long = len(current_text) >= MAX_SENTENCE_SEGMENT_CHARS
+
+            if is_sentence_end or is_too_long:
+                segments.append(
+                    TranscriptSegment(
+                        text=current_text,
+                        start=current_start,
+                        end=current_end,
+                        speaker=speaker,
+                    )
+                )
+                current_text = ""
+                current_start = None
+
+        # Flush remaining words for this speaker
+        if current_text and current_start is not None:
+            segments.append(
+                TranscriptSegment(
+                    text=current_text,
+                    start=current_start,
+                    end=current_end,
+                    speaker=speaker,
+                )
+            )
+
+    # Sort segments by start time
+    segments.sort(key=lambda s: s.start)
+    return segments
+
+
 class Transcript(BaseModel):
     translation: str | None = None
     words: list[Word] = []
@@ -154,7 +229,9 @@ class Transcript(BaseModel):
             word.start += offset
             word.end += offset
 
-    def as_segments(self) -> list[TranscriptSegment]:
+    def as_segments(self, is_multitrack: bool = False) -> list[TranscriptSegment]:
+        if is_multitrack:
+            return words_to_segments_by_sentence(self.words)
         return words_to_segments(self.words)
 
 
@@ -187,6 +264,10 @@ class FinalShortSummary(BaseModel):
     duration: float
 
 
+class ActionItems(BaseModel):
+    action_items: dict  # JSON-serializable dict from ActionItemsResponse
+
+
 class FinalTitle(BaseModel):
     title: str
 

server/reflector/schemas/transcript_formats.py

@@ -0,0 +1,17 @@
+"""Schema definitions for transcript format types and segments."""
+
+from typing import Literal
+
+from pydantic import BaseModel
+
+TranscriptFormat = Literal["text", "text-timestamped", "webvtt-named", "json"]
+
+
+class TranscriptSegment(BaseModel):
+    """A single transcript segment with speaker and timing information."""
+
+    speaker: int
+    speaker_name: str
+    text: str
+    start: float
+    end: float

server/reflector/services/transcript_process.py

@@ -7,7 +7,7 @@ This module provides result-based error handling that works in both contexts:
 """
 
 from dataclasses import dataclass
-from typing import Literal, Union
+from typing import Literal, Union, assert_never
 
 import celery
 from celery.result import AsyncResult
@@ -18,7 +18,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.utils.match import absurd
 from reflector.utils.string import NonEmptyString
 
 
@@ -155,13 +154,16 @@ def dispatch_transcript_processing(config: ProcessingConfig) -> AsyncResult:
     elif isinstance(config, FileProcessingConfig):
         return task_pipeline_file_process.delay(transcript_id=config.transcript_id)
     else:
-        absurd(config)
+        assert_never(config)
 
 
 def task_is_scheduled_or_active(task_name: str, **kwargs):
     inspect = celery.current_app.control.inspect()
 
-    for worker, tasks in (inspect.scheduled() | inspect.active()).items():
+    scheduled = inspect.scheduled() or {}
+    active = inspect.active() or {}
+    all = scheduled | active
+    for worker, tasks in all.items():
         for task in tasks:
             if task["name"] == task_name and task["kwargs"] == kwargs:
                 return True

server/reflector/settings.py

@@ -74,6 +74,13 @@ class Settings(BaseSettings):
     LLM_API_KEY: str | None = None
     LLM_CONTEXT_WINDOW: int = 16000
 
+    LLM_PARSE_MAX_RETRIES: int = (
+        3  # Max retries for JSON/validation errors (total attempts = retries + 1)
+    )
+    LLM_STRUCTURED_RESPONSE_TIMEOUT: int = (
+        300  # Timeout in seconds for structured responses (5 minutes)
+    )
+
     # Diarization
     DIARIZATION_ENABLED: bool = True
     DIARIZATION_BACKEND: str = "modal"

server/reflector/utils/daily.py

@@ -64,6 +64,11 @@ def recording_lock_key(recording_id: NonEmptyString) -> NonEmptyString:
     return f"recording:{recording_id}"
 
 
+def filter_cam_audio_tracks(track_keys: list[str]) -> list[str]:
+    """Filter track keys to cam-audio tracks only (skip screen-audio, etc.)."""
+    return [k for k in track_keys if "cam-audio" in k]
+
+
 def extract_base_room_name(daily_room_name: DailyRoomName) -> NonEmptyString:
     """
     Extract base room name from Daily.co timestamped room name.

server/reflector/utils/match.py

@@ -1,10 +0,0 @@
-from typing import NoReturn
-
-
-def assert_exhaustiveness(x: NoReturn) -> NoReturn:
-    """Provide an assertion at type-check time that this function is never called."""
-    raise AssertionError(f"Invalid value: {x!r}")
-
-
-def absurd(x: NoReturn) -> NoReturn:
-    return assert_exhaustiveness(x)

server/reflector/utils/transcript_formats.py

@@ -0,0 +1,133 @@
+"""Utilities for converting transcript data to various output formats."""
+
+import webvtt
+
+from reflector.db.transcripts import TranscriptParticipant, TranscriptTopic
+from reflector.processors.types import (
+    Transcript as ProcessorTranscript,
+)
+from reflector.schemas.transcript_formats import TranscriptSegment
+from reflector.utils.webvtt import seconds_to_timestamp
+
+
+def get_speaker_name(
+    speaker: int, participants: list[TranscriptParticipant] | None
+) -> str:
+    """Get participant name for speaker or default to 'Speaker N'."""
+    if participants:
+        for participant in participants:
+            if participant.speaker == speaker:
+                return participant.name
+    return f"Speaker {speaker}"
+
+
+def format_timestamp_mmss(seconds: float | int) -> str:
+    """Format seconds as MM:SS timestamp."""
+    minutes = int(seconds // 60)
+    secs = int(seconds % 60)
+    return f"{minutes:02d}:{secs:02d}"
+
+
+def transcript_to_text(
+    topics: list[TranscriptTopic],
+    participants: list[TranscriptParticipant] | None,
+    is_multitrack: bool = False,
+) -> str:
+    """Convert transcript topics to plain text with speaker names."""
+    lines = []
+    for topic in topics:
+        if not topic.words:
+            continue
+
+        transcript = ProcessorTranscript(words=topic.words)
+        segments = transcript.as_segments(is_multitrack)
+
+        for segment in segments:
+            speaker_name = get_speaker_name(segment.speaker, participants)
+            text = segment.text.strip()
+            lines.append(f"{speaker_name}: {text}")
+
+    return "\n".join(lines)
+
+
+def transcript_to_text_timestamped(
+    topics: list[TranscriptTopic],
+    participants: list[TranscriptParticipant] | None,
+    is_multitrack: bool = False,
+) -> str:
+    """Convert transcript topics to timestamped text with speaker names."""
+    lines = []
+    for topic in topics:
+        if not topic.words:
+            continue
+
+        transcript = ProcessorTranscript(words=topic.words)
+        segments = transcript.as_segments(is_multitrack)
+
+        for segment in segments:
+            speaker_name = get_speaker_name(segment.speaker, participants)
+            timestamp = format_timestamp_mmss(segment.start)
+            text = segment.text.strip()
+            lines.append(f"[{timestamp}] {speaker_name}: {text}")
+
+    return "\n".join(lines)
+
+
+def topics_to_webvtt_named(
+    topics: list[TranscriptTopic],
+    participants: list[TranscriptParticipant] | None,
+    is_multitrack: bool = False,
+) -> str:
+    """Convert transcript topics to WebVTT format with participant names."""
+    vtt = webvtt.WebVTT()
+
+    for topic in topics:
+        if not topic.words:
+            continue
+
+        transcript = ProcessorTranscript(words=topic.words)
+        segments = transcript.as_segments(is_multitrack)
+
+        for segment in segments:
+            speaker_name = get_speaker_name(segment.speaker, participants)
+            text = segment.text.strip()
+            text = f"<v {speaker_name}>{text}"
+
+            caption = webvtt.Caption(
+                start=seconds_to_timestamp(segment.start),
+                end=seconds_to_timestamp(segment.end),
+                text=text,
+            )
+            vtt.captions.append(caption)
+
+    return vtt.content
+
+
+def transcript_to_json_segments(
+    topics: list[TranscriptTopic],
+    participants: list[TranscriptParticipant] | None,
+    is_multitrack: bool = False,
+) -> list[TranscriptSegment]:
+    """Convert transcript topics to a flat list of JSON segments."""
+    result = []
+
+    for topic in topics:
+        if not topic.words:
+            continue
+
+        transcript = ProcessorTranscript(words=topic.words)
+        segments = transcript.as_segments(is_multitrack)
+
+        for segment in segments:
+            speaker_name = get_speaker_name(segment.speaker, participants)
+            result.append(
+                TranscriptSegment(
+                    speaker=segment.speaker,
+                    speaker_name=speaker_name,
+                    text=segment.text.strip(),
+                    start=segment.start,
+                    end=segment.end,
+                )
+            )
+
+    return result

server/reflector/utils/webvtt.py

@@ -13,7 +13,7 @@ VttTimestamp = Annotated[str, "vtt_timestamp"]
 WebVTTStr = Annotated[str, "webvtt_str"]
 
 
-def _seconds_to_timestamp(seconds: Seconds) -> VttTimestamp:
+def seconds_to_timestamp(seconds: Seconds) -> VttTimestamp:
     # lib doesn't do that
     hours = int(seconds // 3600)
     minutes = int((seconds % 3600) // 60)
@@ -37,8 +37,8 @@ def words_to_webvtt(words: list[Word]) -> WebVTTStr:
         text = f"<v Speaker{segment.speaker}>{text}"
 
         caption = webvtt.Caption(
-            start=_seconds_to_timestamp(segment.start),
+            start=seconds_to_timestamp(segment.start),
-            end=_seconds_to_timestamp(segment.end),
+            end=seconds_to_timestamp(segment.end),
             text=text,
         )
         vtt.captions.append(caption)

server/reflector/video_platforms/daily.py

@@ -31,6 +31,7 @@ class DailyClient(VideoPlatformClient):
     PLATFORM_NAME: Platform = "daily"
     TIMESTAMP_FORMAT = "%Y%m%d%H%M%S"
     RECORDING_NONE: RecordingType = "none"
+    RECORDING_LOCAL: RecordingType = "local"
     RECORDING_CLOUD: RecordingType = "cloud"
 
     def __init__(self, config: VideoPlatformConfig):
@@ -54,19 +55,23 @@ class DailyClient(VideoPlatformClient):
         timestamp = datetime.now().strftime(self.TIMESTAMP_FORMAT)
         room_name = f"{room_name_prefix}{ROOM_PREFIX_SEPARATOR}{timestamp}"
 
+        enable_recording = None
+        if room.recording_type == self.RECORDING_LOCAL:
+            enable_recording = "local"
+        elif room.recording_type == self.RECORDING_CLOUD:
+            enable_recording = "raw-tracks"
+
         properties = RoomProperties(
-            enable_recording="raw-tracks"
+            enable_recording=enable_recording,
-            if room.recording_type != self.RECORDING_NONE
-            else False,
             enable_chat=True,
             enable_screenshare=True,
+            enable_knocking=room.is_locked,
             start_video_off=False,
             start_audio_off=False,
             exp=int(end_date.timestamp()),
         )
 
-        # Only configure recordings_bucket if recording is enabled
+        if room.recording_type == self.RECORDING_CLOUD:
-        if room.recording_type != self.RECORDING_NONE:
             daily_storage = get_dailyco_storage()
             assert daily_storage.bucket_name, "S3 bucket must be configured"
             properties.recordings_bucket = RecordingsBucketConfig(
@@ -172,16 +177,18 @@ class DailyClient(VideoPlatformClient):
     async def create_meeting_token(
         self,
         room_name: DailyRoomName,
-        enable_recording: bool,
+        start_cloud_recording: bool,
-        user_id: str | None = None,
+        enable_recording_ui: bool,
-    ) -> str:
+        user_id: NonEmptyString | None = None,
+        is_owner: bool = False,
+    ) -> NonEmptyString:
         properties = MeetingTokenProperties(
             room_name=room_name,
             user_id=user_id,
-            start_cloud_recording=enable_recording,
+            start_cloud_recording=start_cloud_recording,
-            enable_recording_ui=not enable_recording,
+            enable_recording_ui=enable_recording_ui,
+            is_owner=is_owner,
         )
-
         request = CreateMeetingTokenRequest(properties=properties)
         result = await self._api_client.create_meeting_token(request)
         return result.token

server/reflector/views/rooms.py

@@ -44,6 +44,7 @@ class Room(BaseModel):
     ics_last_sync: Optional[datetime] = None
     ics_last_etag: Optional[str] = None
     platform: Platform
+    skip_consent: bool = False
 
 
 class RoomDetails(Room):
@@ -89,7 +90,8 @@ class CreateRoom(BaseModel):
     ics_url: Optional[str] = None
     ics_fetch_interval: int = 300
     ics_enabled: bool = False
-    platform: Optional[Platform] = None
+    platform: Platform
+    skip_consent: bool = False
 
 
 class UpdateRoom(BaseModel):
@@ -108,6 +110,7 @@ class UpdateRoom(BaseModel):
     ics_fetch_interval: Optional[int] = None
     ics_enabled: Optional[bool] = None
     platform: Optional[Platform] = None
+    skip_consent: Optional[bool] = None
 
 
 class CreateRoomMeeting(BaseModel):
@@ -249,6 +252,7 @@ async def rooms_create(
         ics_fetch_interval=room.ics_fetch_interval,
         ics_enabled=room.ics_enabled,
         platform=room.platform,
+        skip_consent=room.skip_consent,
     )
 
 
@@ -310,6 +314,22 @@ async def rooms_create_meeting(
                     room=room, current_time=current_time
                 )
 
+                if meeting is not None:
+                    settings_match = (
+                        meeting.is_locked == room.is_locked
+                        and meeting.room_mode == room.room_mode
+                        and meeting.recording_type == room.recording_type
+                        and meeting.recording_trigger == room.recording_trigger
+                        and meeting.platform == room.platform
+                    )
+                    if not settings_match:
+                        logger.info(
+                            f"Room settings changed for {room_name}, creating new meeting",
+                            room_id=room.id,
+                            old_meeting_id=meeting.id,
+                        )
+                        meeting = None
+
             if meeting is None:
                 end_date = current_time + timedelta(hours=8)
 
@@ -549,20 +569,23 @@ async def rooms_join_meeting(
     if meeting.end_date <= current_time:
         raise HTTPException(status_code=400, detail="Meeting has ended")
 
-    if meeting.platform == "daily":
+    if meeting.platform == "daily" and user_id is not None:
         client = create_platform_client(meeting.platform)
-        enable_recording = room.recording_trigger != "none"
+        # Show Daily's built-in recording UI when:
+        # - local recording (user controls when to record), OR
+        # - cloud recording with consent disabled (skip_consent=True)
+        # Hide it when cloud recording with consent enabled (we show custom consent UI)
+        enable_recording_ui = meeting.recording_type == "local" or (
+            meeting.recording_type == "cloud" and room.skip_consent
+        )
         token = await client.create_meeting_token(
             meeting.room_name,
-            enable_recording=enable_recording,
+            start_cloud_recording=meeting.recording_type == "cloud",
+            enable_recording_ui=enable_recording_ui,
             user_id=user_id,
+            is_owner=user_id == room.user_id,
         )
         meeting = meeting.model_copy()
         meeting.room_url = add_query_param(meeting.room_url, "t", token)
-        if meeting.host_room_url:
-            meeting.host_room_url = add_query_param(meeting.host_room_url, "t", token)
-
-    if user_id != room.user_id and meeting.platform == "whereby":
-        meeting.host_room_url = ""
 
     return meeting

server/reflector/views/transcripts.py

@@ -1,14 +1,23 @@
 from datetime import datetime, timedelta, timezone
-from typing import Annotated, Literal, Optional
+from typing import Annotated, Literal, Optional, assert_never
 
 from fastapi import APIRouter, Depends, HTTPException, Query
 from fastapi_pagination import Page
 from fastapi_pagination.ext.databases import apaginate
 from jose import jwt
-from pydantic import AwareDatetime, BaseModel, Field, constr, field_serializer
+from pydantic import (
+    AwareDatetime,
+    BaseModel,
+    Discriminator,
+    Field,
+    constr,
+    field_serializer,
+)
 
 import reflector.auth as auth
 from reflector.db import get_database
+from reflector.db.recordings import recordings_controller
+from reflector.db.rooms import rooms_controller
 from reflector.db.search import (
     DEFAULT_SEARCH_LIMIT,
     SearchLimit,
@@ -29,9 +38,17 @@ from reflector.db.transcripts import (
     TranscriptTopic,
     transcripts_controller,
 )
+from reflector.db.users import user_controller
 from reflector.processors.types import Transcript as ProcessorTranscript
 from reflector.processors.types import Word
+from reflector.schemas.transcript_formats import TranscriptFormat, TranscriptSegment
 from reflector.settings import settings
+from reflector.utils.transcript_formats import (
+    topics_to_webvtt_named,
+    transcript_to_json_segments,
+    transcript_to_text,
+    transcript_to_text_timestamped,
+)
 from reflector.ws_manager import get_ws_manager
 from reflector.zulip import (
     InvalidMessageError,
@@ -46,6 +63,14 @@ ALGORITHM = "HS256"
 DOWNLOAD_EXPIRE_MINUTES = 60
 
 
+async def _get_is_multitrack(transcript) -> bool:
+    """Detect if transcript is from multitrack recording."""
+    if not transcript.recording_id:
+        return False
+    recording = await recordings_controller.get_by_id(transcript.recording_id)
+    return recording is not None and recording.is_multitrack
+
+
 def create_access_token(data: dict, expires_delta: timedelta):
     to_encode = data.copy()
     expire = datetime.now(timezone.utc) + expires_delta
@@ -88,8 +113,86 @@ class GetTranscriptMinimal(BaseModel):
     audio_deleted: bool | None = None
 
 
-class GetTranscript(GetTranscriptMinimal):
+class TranscriptParticipantWithEmail(TranscriptParticipant):
-    participants: list[TranscriptParticipant] | None
+    email: str | None = None
+
+
+class GetTranscriptWithParticipants(GetTranscriptMinimal):
+    participants: list[TranscriptParticipantWithEmail] | None
+
+
+class GetTranscriptWithText(GetTranscriptWithParticipants):
+    """
+    Transcript response with plain text format.
+
+    Format: Speaker names followed by their dialogue, one line per segment.
+    Example:
+        John Smith: Hello everyone
+        Jane Doe: Hi there
+    """
+
+    transcript_format: Literal["text"] = "text"
+    transcript: str
+
+
+class GetTranscriptWithTextTimestamped(GetTranscriptWithParticipants):
+    """
+    Transcript response with timestamped text format.
+
+    Format: [MM:SS] timestamp prefix before each speaker and dialogue.
+    Example:
+        [00:00] John Smith: Hello everyone
+        [00:05] Jane Doe: Hi there
+    """
+
+    transcript_format: Literal["text-timestamped"] = "text-timestamped"
+    transcript: str
+
+
+class GetTranscriptWithWebVTTNamed(GetTranscriptWithParticipants):
+    """
+    Transcript response in WebVTT subtitle format with participant names.
+
+    Format: Standard WebVTT with voice tags using participant names.
+    Example:
+        WEBVTT
+
+        00:00:00.000 --> 00:00:05.000
+        <v John Smith>Hello everyone
+    """
+
+    transcript_format: Literal["webvtt-named"] = "webvtt-named"
+    transcript: str
+
+
+class GetTranscriptWithJSON(GetTranscriptWithParticipants):
+    """
+    Transcript response as structured JSON segments.
+
+    Format: Array of segment objects with speaker info, text, and timing.
+    Example:
+        [
+            {
+                "speaker": 0,
+                "speaker_name": "John Smith",
+                "text": "Hello everyone",
+                "start": 0.0,
+                "end": 5.0
+            }
+        ]
+    """
+
+    transcript_format: Literal["json"] = "json"
+    transcript: list[TranscriptSegment]
+
+
+GetTranscript = Annotated[
+    GetTranscriptWithText
+    | GetTranscriptWithTextTimestamped
+    | GetTranscriptWithWebVTTNamed
+    | GetTranscriptWithJSON,
+    Discriminator("transcript_format"),
+]
 
 
 class CreateTranscript(BaseModel):
@@ -228,7 +331,7 @@ async def transcripts_search(
     )
 
 
-@router.post("/transcripts", response_model=GetTranscript)
+@router.post("/transcripts", response_model=GetTranscriptWithParticipants)
 async def transcripts_create(
     info: CreateTranscript,
     user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
@@ -272,7 +375,7 @@ class GetTranscriptTopic(BaseModel):
     segments: list[GetTranscriptSegmentTopic] = []
 
     @classmethod
-    def from_transcript_topic(cls, topic: TranscriptTopic):
+    def from_transcript_topic(cls, topic: TranscriptTopic, is_multitrack: bool = False):
         if not topic.words:
             # In previous version, words were missing
             # Just output a segment with speaker 0
@@ -296,7 +399,7 @@ class GetTranscriptTopic(BaseModel):
                     start=segment.start,
                     speaker=segment.speaker,
                 )
-                for segment in transcript.as_segments()
+                for segment in transcript.as_segments(is_multitrack)
             ]
         return cls(
             id=topic.id,
@@ -313,8 +416,8 @@ class GetTranscriptTopicWithWords(GetTranscriptTopic):
     words: list[Word] = []
 
     @classmethod
-    def from_transcript_topic(cls, topic: TranscriptTopic):
+    def from_transcript_topic(cls, topic: TranscriptTopic, is_multitrack: bool = False):
-        instance = super().from_transcript_topic(topic)
+        instance = super().from_transcript_topic(topic, is_multitrack)
         if topic.words:
             instance.words = topic.words
         return instance
@@ -329,8 +432,8 @@ class GetTranscriptTopicWithWordsPerSpeaker(GetTranscriptTopic):
     words_per_speaker: list[SpeakerWords] = []
 
     @classmethod
-    def from_transcript_topic(cls, topic: TranscriptTopic):
+    def from_transcript_topic(cls, topic: TranscriptTopic, is_multitrack: bool = False):
-        instance = super().from_transcript_topic(topic)
+        instance = super().from_transcript_topic(topic, is_multitrack)
         if topic.words:
             words_per_speakers = []
             # group words by speaker
@@ -362,14 +465,95 @@ class GetTranscriptTopicWithWordsPerSpeaker(GetTranscriptTopic):
 async def transcript_get(
     transcript_id: str,
     user: Annotated[Optional[auth.UserInfo], Depends(auth.current_user_optional)],
+    transcript_format: TranscriptFormat = "text",
 ):
     user_id = user["sub"] if user else None
-    return await transcripts_controller.get_by_id_for_http(
+    transcript = await transcripts_controller.get_by_id_for_http(
         transcript_id, user_id=user_id
     )
 
+    is_multitrack = await _get_is_multitrack(transcript)
 
-@router.patch("/transcripts/{transcript_id}", response_model=GetTranscript)
+    room_name = None
+    if transcript.room_id:
+        room = await rooms_controller.get_by_id(transcript.room_id)
+        room_name = room.name if room else None
+
+    participants = []
+    if transcript.participants:
+        user_ids = [p.user_id for p in transcript.participants if p.user_id is not None]
+        users_dict = await user_controller.get_by_ids(user_ids) if user_ids else {}
+        for p in transcript.participants:
+            user = users_dict.get(p.user_id) if p.user_id else None
+            participants.append(
+                TranscriptParticipantWithEmail(
+                    **p.model_dump(), email=user.email if user else None
+                )
+            )
+
+    base_data = {
+        "id": transcript.id,
+        "user_id": transcript.user_id,
+        "name": transcript.name,
+        "status": transcript.status,
+        "locked": transcript.locked,
+        "duration": transcript.duration,
+        "title": transcript.title,
+        "short_summary": transcript.short_summary,
+        "long_summary": transcript.long_summary,
+        "action_items": transcript.action_items,
+        "created_at": transcript.created_at,
+        "share_mode": transcript.share_mode,
+        "source_language": transcript.source_language,
+        "target_language": transcript.target_language,
+        "reviewed": transcript.reviewed,
+        "meeting_id": transcript.meeting_id,
+        "source_kind": transcript.source_kind,
+        "room_id": transcript.room_id,
+        "room_name": room_name,
+        "audio_deleted": transcript.audio_deleted,
+        "participants": participants,
+    }
+
+    if transcript_format == "text":
+        return GetTranscriptWithText(
+            **base_data,
+            transcript_format="text",
+            transcript=transcript_to_text(
+                transcript.topics, transcript.participants, is_multitrack
+            ),
+        )
+    elif transcript_format == "text-timestamped":
+        return GetTranscriptWithTextTimestamped(
+            **base_data,
+            transcript_format="text-timestamped",
+            transcript=transcript_to_text_timestamped(
+                transcript.topics, transcript.participants, is_multitrack
+            ),
+        )
+    elif transcript_format == "webvtt-named":
+        return GetTranscriptWithWebVTTNamed(
+            **base_data,
+            transcript_format="webvtt-named",
+            transcript=topics_to_webvtt_named(
+                transcript.topics, transcript.participants, is_multitrack
+            ),
+        )
+    elif transcript_format == "json":
+        return GetTranscriptWithJSON(
+            **base_data,
+            transcript_format="json",
+            transcript=transcript_to_json_segments(
+                transcript.topics, transcript.participants, is_multitrack
+            ),
+        )
+    else:
+        assert_never(transcript_format)
+
+
+@router.patch(
+    "/transcripts/{transcript_id}", response_model=GetTranscriptWithParticipants
+)
 async def transcript_update(
     transcript_id: str,
     info: UpdateTranscript,
@@ -419,9 +603,12 @@ async def transcript_get_topics(
         transcript_id, user_id=user_id
     )
 
+    is_multitrack = await _get_is_multitrack(transcript)
+
     # convert to GetTranscriptTopic
     return [
-        GetTranscriptTopic.from_transcript_topic(topic) for topic in transcript.topics
+        GetTranscriptTopic.from_transcript_topic(topic, is_multitrack)
+        for topic in transcript.topics
     ]
 
 
@@ -438,9 +625,11 @@ async def transcript_get_topics_with_words(
         transcript_id, user_id=user_id
     )
 
+    is_multitrack = await _get_is_multitrack(transcript)
+
     # convert to GetTranscriptTopicWithWords
     return [
-        GetTranscriptTopicWithWords.from_transcript_topic(topic)
+        GetTranscriptTopicWithWords.from_transcript_topic(topic, is_multitrack)
         for topic in transcript.topics
     ]
 
@@ -459,13 +648,17 @@ async def transcript_get_topics_with_words_per_speaker(
         transcript_id, user_id=user_id
     )
 
+    is_multitrack = await _get_is_multitrack(transcript)
+
     # get the topic from the transcript
     topic = next((t for t in transcript.topics if t.id == topic_id), None)
     if not topic:
         raise HTTPException(status_code=404, detail="Topic not found")
 
     # convert to GetTranscriptTopicWithWordsPerSpeaker
-    return GetTranscriptTopicWithWordsPerSpeaker.from_transcript_topic(topic)
+    return GetTranscriptTopicWithWordsPerSpeaker.from_transcript_topic(
+        topic, is_multitrack
+    )
 
 
 @router.post("/transcripts/{transcript_id}/zulip")

server/reflector/views/transcripts_process.py

@@ -1,4 +1,4 @@
-from typing import Annotated, Optional
+from typing import Annotated, Optional, assert_never
 
 from fastapi import APIRouter, Depends, HTTPException
 from pydantic import BaseModel
@@ -15,7 +15,6 @@ from reflector.services.transcript_process import (
     prepare_transcript_processing,
     validate_transcript_for_processing,
 )
-from reflector.utils.match import absurd
 
 router = APIRouter()
 
@@ -44,7 +43,7 @@ async def transcript_process(
     elif isinstance(validation, ValidationOk):
         pass
     else:
-        absurd(validation)
+        assert_never(validation)
 
     config = await prepare_transcript_processing(validation)
 

server/reflector/worker/app.py

@@ -38,6 +38,10 @@ else:
             "task": "reflector.worker.process.reprocess_failed_recordings",
             "schedule": crontab(hour=5, minute=0),  # Midnight EST
         },
+        "reprocess_failed_daily_recordings": {
+            "task": "reflector.worker.process.reprocess_failed_daily_recordings",
+            "schedule": crontab(hour=5, minute=0),  # Midnight EST
+        },
         "poll_daily_recordings": {
             "task": "reflector.worker.process.poll_daily_recordings",
             "schedule": 180.0,  # Every 3 minutes (configurable lookback window)

server/reflector/worker/healthcheck.py

@@ -7,6 +7,12 @@ from reflector.settings import settings
 logger = structlog.get_logger(__name__)
 
 
+@shared_task(name="celery.ping")
+def celery_ping():
+    """Compatibility task for Celery 5.x - celery.ping was removed but monitoring tools still call it."""
+    return "pong"
+
+
 @shared_task
 def healthcheck_ping():
     url = settings.HEALTHCHECK_URL

server/reflector/worker/process.py

@@ -2,6 +2,7 @@ import json
 import os
 import re
 from datetime import datetime, timezone
+from typing import List
 from urllib.parse import unquote
 
 import av
@@ -11,7 +12,7 @@ from celery import shared_task
 from celery.utils.log import get_task_logger
 from pydantic import ValidationError
 
-from reflector.dailyco_api import MeetingParticipantsResponse
+from reflector.dailyco_api import FinishedRecordingResponse, RecordingResponse
 from reflector.db.daily_participant_sessions import (
     DailyParticipantSession,
     daily_participant_sessions_controller,
@@ -21,7 +22,6 @@ from reflector.db.recordings import Recording, recordings_controller
 from reflector.db.rooms import rooms_controller
 from reflector.db.transcripts import (
     SourceKind,
-    TranscriptParticipant,
     transcripts_controller,
 )
 from reflector.pipelines.main_file_pipeline import task_pipeline_file_process
@@ -38,7 +38,7 @@ from reflector.storage import get_transcripts_storage
 from reflector.utils.daily import (
     DailyRoomName,
     extract_base_room_name,
-    parse_daily_recording_filename,
+    filter_cam_audio_tracks,
     recording_lock_key,
 )
 from reflector.video_platforms.factory import create_platform_client
@@ -273,15 +273,7 @@ async def _process_multitrack_recording_inner(
     # else: Recording already exists; metadata set at creation time
 
     transcript = await transcripts_controller.get_by_recording_id(recording.id)
-    if transcript:
+    if not transcript:
-        await transcripts_controller.update(
-            transcript,
-            {
-                "topics": [],
-                "participants": [],
-            },
-        )
-    else:
         transcript = await transcripts_controller.add(
             "",
             source_kind=SourceKind.ROOM,
@@ -294,79 +286,10 @@ async def _process_multitrack_recording_inner(
             room_id=room.id,
         )
 
-    try:
-        async with create_platform_client("daily") as daily_client:
-            id_to_name = {}
-            id_to_user_id = {}
-
-            try:
-                rec_details = await daily_client.get_recording(recording_id)
-                mtg_session_id = rec_details.mtgSessionId
-                if mtg_session_id:
-                    try:
-                        payload: MeetingParticipantsResponse = (
-                            await daily_client.get_meeting_participants(mtg_session_id)
-                        )
-                        for p in payload.data:
-                            pid = p.participant_id
-                            assert (
-                                pid is not None
-                            ), "panic! participant id cannot be None"
-                            name = p.user_name
-                            user_id = p.user_id
-                            if name:
-                                id_to_name[pid] = name
-                            if user_id:
-                                id_to_user_id[pid] = user_id
-                    except Exception as e:
-                        logger.warning(
-                            "Failed to fetch Daily meeting participants",
-                            error=str(e),
-                            mtg_session_id=mtg_session_id,
-                            exc_info=True,
-                        )
-                else:
-                    logger.warning(
-                        "No mtgSessionId found for recording; participant names may be generic",
-                        recording_id=recording_id,
-                    )
-            except Exception as e:
-                logger.warning(
-                    "Failed to fetch Daily recording details",
-                    error=str(e),
-                    recording_id=recording_id,
-                    exc_info=True,
-                )
-
-            for idx, key in enumerate(track_keys):
-                try:
-                    parsed = parse_daily_recording_filename(key)
-                    participant_id = parsed.participant_id
-                except ValueError as e:
-                    logger.error(
-                        "Failed to parse Daily recording filename",
-                        error=str(e),
-                        key=key,
-                        exc_info=True,
-                    )
-                    continue
-
-                default_name = f"Speaker {idx}"
-                name = id_to_name.get(participant_id, default_name)
-                user_id = id_to_user_id.get(participant_id)
-
-                participant = TranscriptParticipant(
-                    id=participant_id, speaker=idx, name=name, user_id=user_id
-                )
-                await transcripts_controller.upsert_participant(transcript, participant)
-
-    except Exception as e:
-        logger.warning("Failed to map participant names", error=str(e), exc_info=True)
-
     task_pipeline_multitrack_process.delay(
         transcript_id=transcript.id,
         bucket_name=bucket_name,
-        track_keys=track_keys,
+        track_keys=filter_cam_audio_tracks(track_keys),
     )
 
 
@@ -391,7 +314,7 @@ async def poll_daily_recordings():
 
     async with create_platform_client("daily") as daily_client:
         # latest 100. TODO cursor-based state
-        api_recordings = await daily_client.list_recordings()
+        api_recordings: List[RecordingResponse] = await daily_client.list_recordings()
 
     if not api_recordings:
         logger.debug(
@@ -399,16 +322,38 @@ async def poll_daily_recordings():
         )
         return
 
-    recording_ids = [rec.id for rec in api_recordings]
+    finished_recordings: List[FinishedRecordingResponse] = []
+    for rec in api_recordings:
+        finished = rec.to_finished()
+        if finished is None:
+            logger.debug(
+                "Skipping unfinished recording",
+                recording_id=rec.id,
+                room_name=rec.room_name,
+                status=rec.status,
+            )
+            continue
+        finished_recordings.append(finished)
+
+    if not finished_recordings:
+        logger.debug(
+            "No finished recordings found from Daily.co API",
+            total_api_count=len(api_recordings),
+        )
+        return
+
+    recording_ids = [rec.id for rec in finished_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 api_recordings if rec.id not in existing_ids]
+    missing_recordings = [
+        rec for rec in finished_recordings if rec.id not in existing_ids
+    ]
 
     if not missing_recordings:
         logger.debug(
             "All recordings already in DB",
-            api_count=len(api_recordings),
+            api_count=len(finished_recordings),
             existing_count=len(existing_recordings),
         )
         return
@@ -416,23 +361,25 @@ async def poll_daily_recordings():
     logger.info(
         "Found recordings missing from DB",
         missing_count=len(missing_recordings),
-        total_api_count=len(api_recordings),
+        total_api_count=len(finished_recordings),
         existing_count=len(existing_recordings),
     )
 
     for recording in missing_recordings:
         if not recording.tracks:
-            assert recording.status != "finished", (
+            if recording.status == "finished":
-                f"Recording {recording.id} has status='finished' but no tracks. "
+                logger.warning(
-                f"Daily.co API guarantees finished recordings have tracks available. "
+                    "Finished recording has no tracks (no audio captured)",
-                f"room_name={recording.room_name}"
+                    recording_id=recording.id,
-            )
+                    room_name=recording.room_name,
-            logger.debug(
+                )
-                "No tracks in recording yet",
+            else:
-                recording_id=recording.id,
+                logger.debug(
-                room_name=recording.room_name,
+                    "No tracks in recording yet",
-                status=recording.status,
+                    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"]
@@ -623,12 +570,12 @@ async def process_meetings():
                 client = create_platform_client(meeting.platform)
                 room_sessions = await client.get_room_sessions(meeting.room_name)
 
-                has_active_sessions = room_sessions and any(
+                has_active_sessions = bool(
-                    s.ended_at is None for s in room_sessions
+                    room_sessions and any(s.ended_at is None for s in room_sessions)
                 )
                 has_had_sessions = bool(room_sessions)
                 logger_.info(
-                    f"found {has_active_sessions} active sessions, had {has_had_sessions}"
+                    f"has_active_sessions={has_active_sessions}, has_had_sessions={has_had_sessions}"
                 )
 
                 if has_active_sessions:
@@ -724,7 +671,7 @@ async def reprocess_failed_recordings():
     Find recordings in Whereby S3 bucket and check if they have proper transcriptions.
     If not, requeue them for processing.
 
-    Note: Daily.co recordings are processed via webhooks, not this cron job.
+    Note: Daily.co multitrack recordings are handled by reprocess_failed_daily_recordings.
     """
     logger.info("Checking Whereby recordings that need processing or reprocessing")
 
@@ -777,6 +724,103 @@ async def reprocess_failed_recordings():
     return reprocessed_count
 
 
+@shared_task
+@asynctask
+async def reprocess_failed_daily_recordings():
+    """
+    Find Daily.co multitrack recordings in the database and check if they have proper transcriptions.
+    If not, requeue them for processing.
+    """
+    logger.info(
+        "Checking Daily.co multitrack recordings that need processing or reprocessing"
+    )
+
+    if not settings.DAILYCO_STORAGE_AWS_BUCKET_NAME:
+        logger.debug(
+            "DAILYCO_STORAGE_AWS_BUCKET_NAME not configured; skipping Daily recording reprocessing"
+        )
+        return 0
+
+    bucket_name = settings.DAILYCO_STORAGE_AWS_BUCKET_NAME
+    reprocessed_count = 0
+
+    try:
+        multitrack_recordings = (
+            await recordings_controller.get_multitrack_needing_reprocessing(bucket_name)
+        )
+
+        logger.info(
+            "Found multitrack recordings needing reprocessing",
+            count=len(multitrack_recordings),
+            bucket=bucket_name,
+        )
+
+        for recording in multitrack_recordings:
+            if not recording.meeting_id:
+                logger.debug(
+                    "Skipping recording without meeting_id",
+                    recording_id=recording.id,
+                )
+                continue
+
+            meeting = await meetings_controller.get_by_id(recording.meeting_id)
+            if not meeting:
+                logger.warning(
+                    "Meeting not found for recording",
+                    recording_id=recording.id,
+                    meeting_id=recording.meeting_id,
+                )
+                continue
+
+            transcript = None
+            try:
+                transcript = await transcripts_controller.get_by_recording_id(
+                    recording.id
+                )
+            except ValidationError:
+                await transcripts_controller.remove_by_recording_id(recording.id)
+                logger.warning(
+                    "Removed invalid transcript for recording",
+                    recording_id=recording.id,
+                )
+
+            if not recording.track_keys:
+                logger.warning(
+                    "Recording has no track_keys, cannot reprocess",
+                    recording_id=recording.id,
+                )
+                continue
+
+            logger.info(
+                "Queueing Daily recording for reprocessing",
+                recording_id=recording.id,
+                room_name=meeting.room_name,
+                track_count=len(recording.track_keys),
+                transcript_status=transcript.status if transcript else None,
+            )
+
+            process_multitrack_recording.delay(
+                bucket_name=bucket_name,
+                daily_room_name=meeting.room_name,
+                recording_id=recording.id,
+                track_keys=recording.track_keys,
+            )
+            reprocessed_count += 1
+
+    except Exception as e:
+        logger.error(
+            "Error checking Daily multitrack recordings",
+            error=str(e),
+            exc_info=True,
+        )
+
+    logger.info(
+        "Daily reprocessing complete",
+        requeued_count=reprocessed_count,
+    )
+    return reprocessed_count
+
+
 @shared_task
 @asynctask
 async def trigger_daily_reconciliation() -> None:

server/reflector/worker/webhook.py

@@ -123,6 +123,7 @@ async def send_transcript_webhook(
                 "target_language": transcript.target_language,
                 "status": transcript.status,
                 "frontend_url": frontend_url,
+                "action_items": transcript.action_items,
             },
             "room": {
                 "id": room.id,

server/tests/conftest.py

@@ -318,6 +318,14 @@ async def dummy_storage():
         yield
 
 
+@pytest.fixture
+def test_settings():
+    """Provide isolated settings for tests to avoid modifying global settings"""
+    from reflector.settings import Settings
+
+    return Settings()
+
+
 @pytest.fixture(scope="session")
 def celery_enable_logging():
     return True

server/tests/test_llm_retry.py

@@ -0,0 +1,488 @@
+"""Tests for LLM parse error recovery using llama-index Workflow"""
+
+from time import monotonic
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from pydantic import BaseModel, Field
+from workflows.errors import WorkflowRuntimeError, WorkflowTimeoutError
+
+from reflector.llm import LLM, LLMParseError, StructuredOutputWorkflow
+from reflector.utils.retry import RetryException
+
+
+class TestResponse(BaseModel):
+    """Test response model for structured output"""
+
+    title: str = Field(description="A title")
+    summary: str = Field(description="A summary")
+    confidence: float = Field(description="Confidence score", ge=0, le=1)
+
+
+def make_completion_response(text: str):
+    """Create a mock CompletionResponse with .text attribute"""
+    response = MagicMock()
+    response.text = text
+    return response
+
+
+class TestLLMParseErrorRecovery:
+    """Test parse error recovery with Workflow feedback loop"""
+
+    @pytest.mark.asyncio
+    async def test_parse_error_recovery_with_feedback(self, test_settings):
+        """Test that parse errors trigger retry with error feedback"""
+        llm = LLM(settings=test_settings, temperature=0.4, max_tokens=100)
+
+        with (
+            patch("reflector.llm.TreeSummarize") as mock_summarize,
+            patch("reflector.llm.Settings") as mock_settings,
+        ):
+            mock_summarizer = MagicMock()
+            mock_summarize.return_value = mock_summarizer
+            # TreeSummarize returns plain text analysis (step 1)
+            mock_summarizer.aget_response = AsyncMock(
+                return_value="The analysis shows a test with summary and high confidence."
+            )
+
+            call_count = {"count": 0}
+
+            async def acomplete_handler(prompt, *args, **kwargs):
+                call_count["count"] += 1
+                if call_count["count"] == 1:
+                    # First JSON formatting call returns invalid JSON
+                    return make_completion_response('{"title": "Test"}')
+                else:
+                    # Second call should have error feedback in prompt
+                    assert "Your previous response could not be parsed:" in prompt
+                    assert '{"title": "Test"}' in prompt
+                    assert "Error:" in prompt
+                    assert "Please try again" in prompt
+                    return make_completion_response(
+                        '{"title": "Test", "summary": "Summary", "confidence": 0.95}'
+                    )
+
+            mock_settings.llm.acomplete = AsyncMock(side_effect=acomplete_handler)
+
+            result = await llm.get_structured_response(
+                prompt="Test prompt", texts=["Test text"], output_cls=TestResponse
+            )
+
+            assert result.title == "Test"
+            assert result.summary == "Summary"
+            assert result.confidence == 0.95
+            # TreeSummarize called once, Settings.llm.acomplete called twice
+            assert mock_summarizer.aget_response.call_count == 1
+            assert call_count["count"] == 2
+
+    @pytest.mark.asyncio
+    async def test_max_parse_retry_attempts(self, test_settings):
+        """Test that parse error retry stops after max attempts"""
+        llm = LLM(settings=test_settings, temperature=0.4, max_tokens=100)
+
+        with (
+            patch("reflector.llm.TreeSummarize") as mock_summarize,
+            patch("reflector.llm.Settings") as mock_settings,
+        ):
+            mock_summarizer = MagicMock()
+            mock_summarize.return_value = mock_summarizer
+            mock_summarizer.aget_response = AsyncMock(return_value="Some analysis")
+
+            # Always return invalid JSON from acomplete
+            mock_settings.llm.acomplete = AsyncMock(
+                return_value=make_completion_response(
+                    '{"invalid": "missing required fields"}'
+                )
+            )
+
+            with pytest.raises(LLMParseError, match="Failed to parse"):
+                await llm.get_structured_response(
+                    prompt="Test prompt", texts=["Test text"], output_cls=TestResponse
+                )
+
+            expected_attempts = test_settings.LLM_PARSE_MAX_RETRIES + 1
+            # TreeSummarize called once, acomplete called max_retries times
+            assert mock_summarizer.aget_response.call_count == 1
+            assert mock_settings.llm.acomplete.call_count == expected_attempts
+
+    @pytest.mark.asyncio
+    async def test_raw_response_logging_on_parse_error(self, test_settings, caplog):
+        """Test that raw response is logged when parse error occurs"""
+        llm = LLM(settings=test_settings, temperature=0.4, max_tokens=100)
+
+        with (
+            patch("reflector.llm.TreeSummarize") as mock_summarize,
+            patch("reflector.llm.Settings") as mock_settings,
+            caplog.at_level("ERROR"),
+        ):
+            mock_summarizer = MagicMock()
+            mock_summarize.return_value = mock_summarizer
+            mock_summarizer.aget_response = AsyncMock(return_value="Some analysis")
+
+            call_count = {"count": 0}
+
+            async def acomplete_handler(*args, **kwargs):
+                call_count["count"] += 1
+                if call_count["count"] == 1:
+                    return make_completion_response('{"title": "Test"}')  # Invalid
+                return make_completion_response(
+                    '{"title": "Test", "summary": "Summary", "confidence": 0.95}'
+                )
+
+            mock_settings.llm.acomplete = AsyncMock(side_effect=acomplete_handler)
+
+            result = await llm.get_structured_response(
+                prompt="Test prompt", texts=["Test text"], output_cls=TestResponse
+            )
+
+            assert result.title == "Test"
+
+            error_logs = [r for r in caplog.records if r.levelname == "ERROR"]
+            raw_response_logged = any("Raw response:" in r.message for r in error_logs)
+            assert raw_response_logged, "Raw response should be logged on parse error"
+
+    @pytest.mark.asyncio
+    async def test_multiple_validation_errors_in_feedback(self, test_settings):
+        """Test that validation errors are included in feedback"""
+        llm = LLM(settings=test_settings, temperature=0.4, max_tokens=100)
+
+        with (
+            patch("reflector.llm.TreeSummarize") as mock_summarize,
+            patch("reflector.llm.Settings") as mock_settings,
+        ):
+            mock_summarizer = MagicMock()
+            mock_summarize.return_value = mock_summarizer
+            mock_summarizer.aget_response = AsyncMock(return_value="Some analysis")
+
+            call_count = {"count": 0}
+
+            async def acomplete_handler(prompt, *args, **kwargs):
+                call_count["count"] += 1
+                if call_count["count"] == 1:
+                    # Missing title and summary
+                    return make_completion_response('{"confidence": 0.5}')
+                else:
+                    # Should have schema validation errors in prompt
+                    assert (
+                        "Schema validation errors" in prompt
+                        or "error" in prompt.lower()
+                    )
+                    return make_completion_response(
+                        '{"title": "Test", "summary": "Summary", "confidence": 0.95}'
+                    )
+
+            mock_settings.llm.acomplete = AsyncMock(side_effect=acomplete_handler)
+
+            result = await llm.get_structured_response(
+                prompt="Test prompt", texts=["Test text"], output_cls=TestResponse
+            )
+
+            assert result.title == "Test"
+            assert call_count["count"] == 2
+
+    @pytest.mark.asyncio
+    async def test_success_on_first_attempt(self, test_settings):
+        """Test that no retry happens when first attempt succeeds"""
+        llm = LLM(settings=test_settings, temperature=0.4, max_tokens=100)
+
+        with (
+            patch("reflector.llm.TreeSummarize") as mock_summarize,
+            patch("reflector.llm.Settings") as mock_settings,
+        ):
+            mock_summarizer = MagicMock()
+            mock_summarize.return_value = mock_summarizer
+            mock_summarizer.aget_response = AsyncMock(return_value="Some analysis")
+
+            mock_settings.llm.acomplete = AsyncMock(
+                return_value=make_completion_response(
+                    '{"title": "Test", "summary": "Summary", "confidence": 0.95}'
+                )
+            )
+
+            result = await llm.get_structured_response(
+                prompt="Test prompt", texts=["Test text"], output_cls=TestResponse
+            )
+
+            assert result.title == "Test"
+            assert result.summary == "Summary"
+            assert result.confidence == 0.95
+            assert mock_summarizer.aget_response.call_count == 1
+            assert mock_settings.llm.acomplete.call_count == 1
+
+
+class TestStructuredOutputWorkflow:
+    """Direct tests for the StructuredOutputWorkflow"""
+
+    @pytest.mark.asyncio
+    async def test_workflow_retries_on_validation_error(self):
+        """Test workflow retries when validation fails"""
+        workflow = StructuredOutputWorkflow(
+            output_cls=TestResponse,
+            max_retries=3,
+            timeout=30,
+        )
+
+        with (
+            patch("reflector.llm.TreeSummarize") as mock_summarize,
+            patch("reflector.llm.Settings") as mock_settings,
+        ):
+            mock_summarizer = MagicMock()
+            mock_summarize.return_value = mock_summarizer
+            mock_summarizer.aget_response = AsyncMock(return_value="Some analysis")
+
+            call_count = {"count": 0}
+
+            async def acomplete_handler(*args, **kwargs):
+                call_count["count"] += 1
+                if call_count["count"] < 2:
+                    return make_completion_response('{"title": "Only title"}')
+                return make_completion_response(
+                    '{"title": "Test", "summary": "Summary", "confidence": 0.9}'
+                )
+
+            mock_settings.llm.acomplete = AsyncMock(side_effect=acomplete_handler)
+
+            result = await workflow.run(
+                prompt="Extract data",
+                texts=["Some text"],
+                tone_name=None,
+            )
+
+            assert "success" in result
+            assert result["success"].title == "Test"
+            assert call_count["count"] == 2
+
+    @pytest.mark.asyncio
+    async def test_workflow_returns_error_after_max_retries(self):
+        """Test workflow returns error after exhausting retries"""
+        workflow = StructuredOutputWorkflow(
+            output_cls=TestResponse,
+            max_retries=2,
+            timeout=30,
+        )
+
+        with (
+            patch("reflector.llm.TreeSummarize") as mock_summarize,
+            patch("reflector.llm.Settings") as mock_settings,
+        ):
+            mock_summarizer = MagicMock()
+            mock_summarize.return_value = mock_summarizer
+            mock_summarizer.aget_response = AsyncMock(return_value="Some analysis")
+
+            # Always return invalid JSON
+            mock_settings.llm.acomplete = AsyncMock(
+                return_value=make_completion_response('{"invalid": true}')
+            )
+
+            result = await workflow.run(
+                prompt="Extract data",
+                texts=["Some text"],
+                tone_name=None,
+            )
+
+            assert "error" in result
+            # TreeSummarize called once, acomplete called max_retries times
+            assert mock_summarizer.aget_response.call_count == 1
+            assert mock_settings.llm.acomplete.call_count == 2
+
+
+class TestNetworkErrorRetries:
+    """Test that network error retries are handled by OpenAILike, not Workflow"""
+
+    @pytest.mark.asyncio
+    async def test_network_error_propagates_after_openai_retries(self, test_settings):
+        """Test that network errors are retried by OpenAILike and then propagate.
+
+        Network retries are handled by OpenAILike (max_retries=3), not by our
+        StructuredOutputWorkflow. This test verifies that network errors propagate
+        up after OpenAILike exhausts its retries.
+        """
+        llm = LLM(settings=test_settings, temperature=0.4, max_tokens=100)
+
+        with (
+            patch("reflector.llm.TreeSummarize") as mock_summarize,
+            patch("reflector.llm.Settings") as mock_settings,
+        ):
+            mock_summarizer = MagicMock()
+            mock_summarize.return_value = mock_summarizer
+            mock_summarizer.aget_response = AsyncMock(return_value="Some analysis")
+
+            # Simulate network error from acomplete (after OpenAILike retries exhausted)
+            network_error = ConnectionError("Connection refused")
+            mock_settings.llm.acomplete = AsyncMock(side_effect=network_error)
+
+            # Network error wrapped in WorkflowRuntimeError
+            with pytest.raises(WorkflowRuntimeError, match="Connection refused"):
+                await llm.get_structured_response(
+                    prompt="Test prompt", texts=["Test text"], output_cls=TestResponse
+                )
+
+            # acomplete called only once - network error propagates, not retried by Workflow
+            assert mock_settings.llm.acomplete.call_count == 1
+
+    @pytest.mark.asyncio
+    async def test_network_error_not_retried_by_workflow(self, test_settings):
+        """Test that Workflow does NOT retry network errors (OpenAILike handles those).
+
+        This verifies the separation of concerns:
+        - StructuredOutputWorkflow: retries parse/validation errors
+        - OpenAILike: retries network errors (internally, max_retries=3)
+        """
+        workflow = StructuredOutputWorkflow(
+            output_cls=TestResponse,
+            max_retries=3,
+            timeout=30,
+        )
+
+        with (
+            patch("reflector.llm.TreeSummarize") as mock_summarize,
+            patch("reflector.llm.Settings") as mock_settings,
+        ):
+            mock_summarizer = MagicMock()
+            mock_summarize.return_value = mock_summarizer
+            mock_summarizer.aget_response = AsyncMock(return_value="Some analysis")
+
+            # Network error should propagate immediately, not trigger Workflow retry
+            mock_settings.llm.acomplete = AsyncMock(
+                side_effect=TimeoutError("Request timed out")
+            )
+
+            # Network error wrapped in WorkflowRuntimeError
+            with pytest.raises(WorkflowRuntimeError, match="Request timed out"):
+                await workflow.run(
+                    prompt="Extract data",
+                    texts=["Some text"],
+                    tone_name=None,
+                )
+
+            # Only called once - Workflow doesn't retry network errors
+            assert mock_settings.llm.acomplete.call_count == 1
+
+
+class TestWorkflowTimeoutRetry:
+    """Test timeout retry mechanism in get_structured_response"""
+
+    @pytest.mark.asyncio
+    async def test_timeout_retry_succeeds_on_retry(self, test_settings):
+        """Test that WorkflowTimeoutError triggers retry and succeeds"""
+        llm = LLM(settings=test_settings, temperature=0.4, max_tokens=100)
+
+        call_count = {"count": 0}
+
+        async def workflow_run_side_effect(*args, **kwargs):
+            call_count["count"] += 1
+            if call_count["count"] == 1:
+                raise WorkflowTimeoutError("Operation timed out after 120 seconds")
+            return {
+                "success": TestResponse(
+                    title="Test", summary="Summary", confidence=0.95
+                )
+            }
+
+        with (
+            patch("reflector.llm.StructuredOutputWorkflow") as mock_workflow_class,
+            patch("reflector.llm.TreeSummarize") as mock_summarize,
+            patch("reflector.llm.Settings") as mock_settings,
+        ):
+            mock_workflow = MagicMock()
+            mock_workflow.run = AsyncMock(side_effect=workflow_run_side_effect)
+            mock_workflow_class.return_value = mock_workflow
+
+            mock_summarizer = MagicMock()
+            mock_summarize.return_value = mock_summarizer
+            mock_summarizer.aget_response = AsyncMock(return_value="Some analysis")
+            mock_settings.llm.acomplete = AsyncMock(
+                return_value=make_completion_response(
+                    '{"title": "Test", "summary": "Summary", "confidence": 0.95}'
+                )
+            )
+
+            result = await llm.get_structured_response(
+                prompt="Test prompt", texts=["Test text"], output_cls=TestResponse
+            )
+
+            assert result.title == "Test"
+            assert result.summary == "Summary"
+            assert call_count["count"] == 2
+
+    @pytest.mark.asyncio
+    async def test_timeout_retry_exhausts_after_max_attempts(self, test_settings):
+        """Test that timeout retry stops after max attempts"""
+        llm = LLM(settings=test_settings, temperature=0.4, max_tokens=100)
+
+        call_count = {"count": 0}
+
+        async def workflow_run_side_effect(*args, **kwargs):
+            call_count["count"] += 1
+            raise WorkflowTimeoutError("Operation timed out after 120 seconds")
+
+        with (
+            patch("reflector.llm.StructuredOutputWorkflow") as mock_workflow_class,
+            patch("reflector.llm.TreeSummarize") as mock_summarize,
+            patch("reflector.llm.Settings") as mock_settings,
+        ):
+            mock_workflow = MagicMock()
+            mock_workflow.run = AsyncMock(side_effect=workflow_run_side_effect)
+            mock_workflow_class.return_value = mock_workflow
+
+            mock_summarizer = MagicMock()
+            mock_summarize.return_value = mock_summarizer
+            mock_summarizer.aget_response = AsyncMock(return_value="Some analysis")
+            mock_settings.llm.acomplete = AsyncMock(
+                return_value=make_completion_response(
+                    '{"title": "Test", "summary": "Summary", "confidence": 0.95}'
+                )
+            )
+
+            with pytest.raises(RetryException, match="Retry attempts exceeded"):
+                await llm.get_structured_response(
+                    prompt="Test prompt", texts=["Test text"], output_cls=TestResponse
+                )
+
+            assert call_count["count"] == 3
+
+    @pytest.mark.asyncio
+    async def test_timeout_retry_with_backoff(self, test_settings):
+        """Test that exponential backoff is applied between retries"""
+        llm = LLM(settings=test_settings, temperature=0.4, max_tokens=100)
+
+        call_times = []
+
+        async def workflow_run_side_effect(*args, **kwargs):
+            call_times.append(monotonic())
+            if len(call_times) < 3:
+                raise WorkflowTimeoutError("Operation timed out after 120 seconds")
+            return {
+                "success": TestResponse(
+                    title="Test", summary="Summary", confidence=0.95
+                )
+            }
+
+        with (
+            patch("reflector.llm.StructuredOutputWorkflow") as mock_workflow_class,
+            patch("reflector.llm.TreeSummarize") as mock_summarize,
+            patch("reflector.llm.Settings") as mock_settings,
+        ):
+            mock_workflow = MagicMock()
+            mock_workflow.run = AsyncMock(side_effect=workflow_run_side_effect)
+            mock_workflow_class.return_value = mock_workflow
+
+            mock_summarizer = MagicMock()
+            mock_summarize.return_value = mock_summarizer
+            mock_summarizer.aget_response = AsyncMock(return_value="Some analysis")
+            mock_settings.llm.acomplete = AsyncMock(
+                return_value=make_completion_response(
+                    '{"title": "Test", "summary": "Summary", "confidence": 0.95}'
+                )
+            )
+
+            result = await llm.get_structured_response(
+                prompt="Test prompt", texts=["Test text"], output_cls=TestResponse
+            )
+
+            assert result.title == "Test"
+            if len(call_times) >= 2:
+                time_between_calls = call_times[1] - call_times[0]
+                assert (
+                    time_between_calls >= 1.5
+                ), f"Expected ~2s backoff, got {time_between_calls}s"

server/tests/test_pipeline_main_file.py

@@ -266,7 +266,11 @@ async def mock_summary_processor():
         # When flush is called, simulate summary generation by calling the callbacks
         async def flush_with_callback():
             mock_summary.flush_called = True
-            from reflector.processors.types import FinalLongSummary, FinalShortSummary
+            from reflector.processors.types import (
+                ActionItems,
+                FinalLongSummary,
+                FinalShortSummary,
+            )
 
             if hasattr(mock_summary, "_callback"):
                 await mock_summary._callback(
@@ -276,12 +280,19 @@ async def mock_summary_processor():
                 await mock_summary._on_short_summary(
                     FinalShortSummary(short_summary="Test short summary", duration=10.0)
                 )
+            if hasattr(mock_summary, "_on_action_items"):
+                await mock_summary._on_action_items(
+                    ActionItems(action_items={"test": "action item"})
+                )
 
         mock_summary.flush = flush_with_callback
 
-        def init_with_callback(transcript=None, callback=None, on_short_summary=None):
+        def init_with_callback(
+            transcript=None, callback=None, on_short_summary=None, on_action_items=None
+        ):
             mock_summary._callback = callback
             mock_summary._on_short_summary = on_short_summary
+            mock_summary._on_action_items = on_action_items
             return mock_summary
 
         mock_summary_class.side_effect = init_with_callback

server/tests/test_processor_transcript_segment.py

@@ -159,3 +159,78 @@ def test_processor_transcript_segment():
     assert segments[3].start == 30.72
     assert segments[4].start == 31.56
     assert segments[5].start == 32.38
+
+
+def test_processor_transcript_segment_multitrack_interleaved():
+    """Test as_segments(is_multitrack=True) with interleaved speakers.
+
+    Multitrack recordings have words from different speakers sorted by start time,
+    causing frequent speaker alternation. The multitrack mode should group by
+    speaker first, then split into sentences.
+    """
+    from reflector.processors.types import Transcript, Word
+
+    # Simulate real multitrack data: words sorted by start time, speakers interleave
+    # Speaker 0 says: "Hello there."
+    # Speaker 1 says: "I'm good."
+    # When sorted by time, words interleave
+    transcript = Transcript(
+        words=[
+            Word(text="Hello ", start=0.0, end=0.5, speaker=0),
+            Word(text="I'm ", start=0.5, end=0.8, speaker=1),
+            Word(text="there.", start=0.5, end=1.0, speaker=0),
+            Word(text="good.", start=1.0, end=1.5, speaker=1),
+        ]
+    )
+
+    # Default behavior (is_multitrack=False): breaks on every speaker change = 4 segments
+    segments_default = transcript.as_segments(is_multitrack=False)
+    assert len(segments_default) == 4
+
+    # Multitrack behavior: groups by speaker, then sentences = 2 segments
+    segments_multitrack = transcript.as_segments(is_multitrack=True)
+    assert len(segments_multitrack) == 2
+
+    # Check content - sorted by start time
+    assert segments_multitrack[0].speaker == 0
+    assert segments_multitrack[0].text == "Hello there."
+    assert segments_multitrack[0].start == 0.0
+    assert segments_multitrack[0].end == 1.0
+
+    assert segments_multitrack[1].speaker == 1
+    assert segments_multitrack[1].text == "I'm good."
+    assert segments_multitrack[1].start == 0.5
+    assert segments_multitrack[1].end == 1.5
+
+
+def test_processor_transcript_segment_multitrack_overlapping_timestamps():
+    """Test multitrack with exactly overlapping timestamps (real Daily.co data pattern)."""
+    from reflector.processors.types import Transcript, Word
+
+    # Real pattern from transcript 38d84d57: words with identical timestamps
+    transcript = Transcript(
+        words=[
+            Word(text="speaking ", start=6.71, end=7.11, speaker=0),
+            Word(text="Speaking ", start=6.71, end=7.11, speaker=1),
+            Word(text="at ", start=7.11, end=7.27, speaker=0),
+            Word(text="at ", start=7.11, end=7.27, speaker=1),
+            Word(text="the ", start=7.27, end=7.43, speaker=0),
+            Word(text="the ", start=7.27, end=7.43, speaker=1),
+            Word(text="same ", start=7.43, end=7.59, speaker=0),
+            Word(text="same ", start=7.43, end=7.59, speaker=1),
+            Word(text="time.", start=7.59, end=8.0, speaker=0),
+            Word(text="time.", start=7.59, end=8.0, speaker=1),
+        ]
+    )
+
+    # Default: 10 segments (one per speaker change)
+    segments_default = transcript.as_segments(is_multitrack=False)
+    assert len(segments_default) == 10
+
+    # Multitrack: 2 segments (one per speaker sentence)
+    segments_multitrack = transcript.as_segments(is_multitrack=True)
+    assert len(segments_multitrack) == 2
+
+    # Both should have complete sentences
+    assert "speaking at the same time." in segments_multitrack[0].text
+    assert "Speaking at the same time." in segments_multitrack[1].text

server/tests/test_transcript_formats.py

@@ -0,0 +1,779 @@
+"""Tests for transcript format conversion functionality."""
+
+import pytest
+
+from reflector.db.transcripts import TranscriptParticipant, TranscriptTopic
+from reflector.processors.types import Word
+from reflector.utils.transcript_formats import (
+    format_timestamp_mmss,
+    get_speaker_name,
+    topics_to_webvtt_named,
+    transcript_to_json_segments,
+    transcript_to_text,
+    transcript_to_text_timestamped,
+)
+
+
+@pytest.mark.asyncio
+async def test_get_speaker_name_with_participants():
+    """Test speaker name resolution with participants list."""
+    participants = [
+        TranscriptParticipant(id="1", speaker=0, name="John Smith"),
+        TranscriptParticipant(id="2", speaker=1, name="Jane Doe"),
+    ]
+
+    assert get_speaker_name(0, participants) == "John Smith"
+    assert get_speaker_name(1, participants) == "Jane Doe"
+    assert get_speaker_name(2, participants) == "Speaker 2"
+
+
+@pytest.mark.asyncio
+async def test_get_speaker_name_without_participants():
+    """Test speaker name resolution without participants list."""
+    assert get_speaker_name(0, None) == "Speaker 0"
+    assert get_speaker_name(1, None) == "Speaker 1"
+    assert get_speaker_name(5, []) == "Speaker 5"
+
+
+@pytest.mark.asyncio
+async def test_format_timestamp_mmss():
+    """Test timestamp formatting to MM:SS."""
+    assert format_timestamp_mmss(0) == "00:00"
+    assert format_timestamp_mmss(5) == "00:05"
+    assert format_timestamp_mmss(65) == "01:05"
+    assert format_timestamp_mmss(125.7) == "02:05"
+    assert format_timestamp_mmss(3661) == "61:01"
+
+
+@pytest.mark.asyncio
+async def test_transcript_to_text():
+    """Test plain text format conversion."""
+    topics = [
+        TranscriptTopic(
+            id="1",
+            title="Topic 1",
+            summary="Summary 1",
+            timestamp=0.0,
+            words=[
+                Word(text="Hello", start=0.0, end=1.0, speaker=0),
+                Word(text=" world.", start=1.0, end=2.0, speaker=0),
+            ],
+        ),
+        TranscriptTopic(
+            id="2",
+            title="Topic 2",
+            summary="Summary 2",
+            timestamp=2.0,
+            words=[
+                Word(text="How", start=2.0, end=3.0, speaker=1),
+                Word(text=" are", start=3.0, end=4.0, speaker=1),
+                Word(text=" you?", start=4.0, end=5.0, speaker=1),
+            ],
+        ),
+    ]
+
+    participants = [
+        TranscriptParticipant(id="1", speaker=0, name="John Smith"),
+        TranscriptParticipant(id="2", speaker=1, name="Jane Doe"),
+    ]
+
+    result = transcript_to_text(topics, participants)
+    lines = result.split("\n")
+
+    assert len(lines) == 2
+    assert lines[0] == "John Smith: Hello world."
+    assert lines[1] == "Jane Doe: How are you?"
+
+
+@pytest.mark.asyncio
+async def test_transcript_to_text_timestamped():
+    """Test timestamped text format conversion."""
+    topics = [
+        TranscriptTopic(
+            id="1",
+            title="Topic 1",
+            summary="Summary 1",
+            timestamp=0.0,
+            words=[
+                Word(text="Hello", start=0.0, end=1.0, speaker=0),
+                Word(text=" world.", start=1.0, end=2.0, speaker=0),
+            ],
+        ),
+        TranscriptTopic(
+            id="2",
+            title="Topic 2",
+            summary="Summary 2",
+            timestamp=65.0,
+            words=[
+                Word(text="How", start=65.0, end=66.0, speaker=1),
+                Word(text=" are", start=66.0, end=67.0, speaker=1),
+                Word(text=" you?", start=67.0, end=68.0, speaker=1),
+            ],
+        ),
+    ]
+
+    participants = [
+        TranscriptParticipant(id="1", speaker=0, name="John Smith"),
+        TranscriptParticipant(id="2", speaker=1, name="Jane Doe"),
+    ]
+
+    result = transcript_to_text_timestamped(topics, participants)
+    lines = result.split("\n")
+
+    assert len(lines) == 2
+    assert lines[0] == "[00:00] John Smith: Hello world."
+    assert lines[1] == "[01:05] Jane Doe: How are you?"
+
+
+@pytest.mark.asyncio
+async def test_topics_to_webvtt_named():
+    """Test WebVTT format conversion with participant names."""
+    topics = [
+        TranscriptTopic(
+            id="1",
+            title="Topic 1",
+            summary="Summary 1",
+            timestamp=0.0,
+            words=[
+                Word(text="Hello", start=0.0, end=1.0, speaker=0),
+                Word(text=" world.", start=1.0, end=2.0, speaker=0),
+            ],
+        ),
+    ]
+
+    participants = [
+        TranscriptParticipant(id="1", speaker=0, name="John Smith"),
+    ]
+
+    result = topics_to_webvtt_named(topics, participants)
+
+    assert result.startswith("WEBVTT")
+    assert "<v John Smith>" in result
+    assert "00:00:00.000 --> 00:00:02.000" in result
+    assert "Hello world." in result
+
+
+@pytest.mark.asyncio
+async def test_transcript_to_json_segments():
+    """Test JSON segments format conversion."""
+    topics = [
+        TranscriptTopic(
+            id="1",
+            title="Topic 1",
+            summary="Summary 1",
+            timestamp=0.0,
+            words=[
+                Word(text="Hello", start=0.0, end=1.0, speaker=0),
+                Word(text=" world.", start=1.0, end=2.0, speaker=0),
+            ],
+        ),
+        TranscriptTopic(
+            id="2",
+            title="Topic 2",
+            summary="Summary 2",
+            timestamp=2.0,
+            words=[
+                Word(text="How", start=2.0, end=3.0, speaker=1),
+                Word(text=" are", start=3.0, end=4.0, speaker=1),
+                Word(text=" you?", start=4.0, end=5.0, speaker=1),
+            ],
+        ),
+    ]
+
+    participants = [
+        TranscriptParticipant(id="1", speaker=0, name="John Smith"),
+        TranscriptParticipant(id="2", speaker=1, name="Jane Doe"),
+    ]
+
+    result = transcript_to_json_segments(topics, participants)
+
+    assert len(result) == 2
+    assert result[0].speaker == 0
+    assert result[0].speaker_name == "John Smith"
+    assert result[0].text == "Hello world."
+    assert result[0].start == 0.0
+    assert result[0].end == 2.0
+
+    assert result[1].speaker == 1
+    assert result[1].speaker_name == "Jane Doe"
+    assert result[1].text == "How are you?"
+    assert result[1].start == 2.0
+    assert result[1].end == 5.0
+
+
+@pytest.mark.asyncio
+async def test_transcript_formats_with_empty_topics():
+    """Test format conversion with empty topics list."""
+    topics = []
+    participants = []
+
+    assert transcript_to_text(topics, participants) == ""
+    assert transcript_to_text_timestamped(topics, participants) == ""
+    assert "WEBVTT" in topics_to_webvtt_named(topics, participants)
+    assert transcript_to_json_segments(topics, participants) == []
+
+
+@pytest.mark.asyncio
+async def test_transcript_formats_with_empty_words():
+    """Test format conversion with topics containing no words."""
+    topics = [
+        TranscriptTopic(
+            id="1",
+            title="Topic 1",
+            summary="Summary 1",
+            timestamp=0.0,
+            words=[],
+        ),
+    ]
+    participants = []
+
+    assert transcript_to_text(topics, participants) == ""
+    assert transcript_to_text_timestamped(topics, participants) == ""
+    assert "WEBVTT" in topics_to_webvtt_named(topics, participants)
+    assert transcript_to_json_segments(topics, participants) == []
+
+
+@pytest.mark.asyncio
+async def test_transcript_formats_with_multiple_speakers():
+    """Test format conversion with multiple speaker changes."""
+    topics = [
+        TranscriptTopic(
+            id="1",
+            title="Topic 1",
+            summary="Summary 1",
+            timestamp=0.0,
+            words=[
+                Word(text="Hello", start=0.0, end=1.0, speaker=0),
+                Word(text=" there.", start=1.0, end=2.0, speaker=0),
+                Word(text="Hi", start=2.0, end=3.0, speaker=1),
+                Word(text=" back.", start=3.0, end=4.0, speaker=1),
+                Word(text="Good", start=4.0, end=5.0, speaker=0),
+                Word(text=" morning.", start=5.0, end=6.0, speaker=0),
+            ],
+        ),
+    ]
+
+    participants = [
+        TranscriptParticipant(id="1", speaker=0, name="Alice"),
+        TranscriptParticipant(id="2", speaker=1, name="Bob"),
+    ]
+
+    text_result = transcript_to_text(topics, participants)
+    lines = text_result.split("\n")
+    assert len(lines) == 3
+    assert "Alice: Hello there." in lines[0]
+    assert "Bob: Hi back." in lines[1]
+    assert "Alice: Good morning." in lines[2]
+
+    json_result = transcript_to_json_segments(topics, participants)
+    assert len(json_result) == 3
+    assert json_result[0].speaker_name == "Alice"
+    assert json_result[1].speaker_name == "Bob"
+    assert json_result[2].speaker_name == "Alice"
+
+
+@pytest.mark.asyncio
+async def test_transcript_formats_with_overlapping_speakers_multitrack():
+    """Test format conversion for multitrack recordings with truly interleaved words.
+
+    Multitrack recordings have words from different speakers sorted by start time,
+    causing frequent speaker alternation. This tests the sentence-based segmentation
+    that groups each speaker's words into complete sentences.
+    """
+    # Real multitrack data: words sorted by start time, speakers interleave
+    # Alice says: "Hello there." (0.0-1.0)
+    # Bob says: "I'm good." (0.5-1.5)
+    # When sorted by time, words interleave: Hello, I'm, there., good.
+    topics = [
+        TranscriptTopic(
+            id="1",
+            title="Topic 1",
+            summary="Summary 1",
+            timestamp=0.0,
+            words=[
+                Word(text="Hello ", start=0.0, end=0.5, speaker=0),
+                Word(text="I'm ", start=0.5, end=0.8, speaker=1),
+                Word(text="there.", start=0.5, end=1.0, speaker=0),
+                Word(text="good.", start=1.0, end=1.5, speaker=1),
+            ],
+        ),
+    ]
+
+    participants = [
+        TranscriptParticipant(id="1", speaker=0, name="Alice"),
+        TranscriptParticipant(id="2", speaker=1, name="Bob"),
+    ]
+
+    # With is_multitrack=True, should produce 2 segments (one per speaker sentence)
+    # not 4 segments (one per speaker change)
+    webvtt_result = topics_to_webvtt_named(topics, participants, is_multitrack=True)
+    expected_webvtt = """WEBVTT
+
+00:00:00.000 --> 00:00:01.000
+<v Alice>Hello there.
+
+00:00:00.500 --> 00:00:01.500
+<v Bob>I'm good.
+"""
+    assert webvtt_result == expected_webvtt
+
+    text_result = transcript_to_text(topics, participants, is_multitrack=True)
+    lines = text_result.split("\n")
+    assert len(lines) == 2
+    assert "Alice: Hello there." in lines[0]
+    assert "Bob: I'm good." in lines[1]
+
+    timestamped_result = transcript_to_text_timestamped(
+        topics, participants, is_multitrack=True
+    )
+    timestamped_lines = timestamped_result.split("\n")
+    assert len(timestamped_lines) == 2
+    assert "[00:00] Alice: Hello there." in timestamped_lines[0]
+    assert "[00:00] Bob: I'm good." in timestamped_lines[1]
+
+    segments = transcript_to_json_segments(topics, participants, is_multitrack=True)
+    assert len(segments) == 2
+    assert segments[0].speaker_name == "Alice"
+    assert segments[0].text == "Hello there."
+    assert segments[1].speaker_name == "Bob"
+    assert segments[1].text == "I'm good."
+
+
+@pytest.mark.asyncio
+async def test_api_transcript_format_text(client):
+    """Test GET /transcripts/{id} with transcript_format=text."""
+    response = await client.post("/transcripts", json={"name": "Test transcript"})
+    assert response.status_code == 200
+    tid = response.json()["id"]
+
+    from reflector.db.transcripts import (
+        TranscriptParticipant,
+        TranscriptTopic,
+        transcripts_controller,
+    )
+    from reflector.processors.types import Word
+
+    transcript = await transcripts_controller.get_by_id(tid)
+
+    await transcripts_controller.update(
+        transcript,
+        {
+            "participants": [
+                TranscriptParticipant(
+                    id="1", speaker=0, name="John Smith"
+                ).model_dump(),
+                TranscriptParticipant(id="2", speaker=1, name="Jane Doe").model_dump(),
+            ]
+        },
+    )
+
+    await transcripts_controller.upsert_topic(
+        transcript,
+        TranscriptTopic(
+            title="Topic 1",
+            summary="Summary 1",
+            timestamp=0,
+            words=[
+                Word(text="Hello", start=0, end=1, speaker=0),
+                Word(text=" world.", start=1, end=2, speaker=0),
+            ],
+        ),
+    )
+
+    response = await client.get(f"/transcripts/{tid}?transcript_format=text")
+    assert response.status_code == 200
+    data = response.json()
+
+    assert data["transcript_format"] == "text"
+    assert "transcript" in data
+    assert "John Smith: Hello world." in data["transcript"]
+
+
+@pytest.mark.asyncio
+async def test_api_transcript_format_text_timestamped(client):
+    """Test GET /transcripts/{id} with transcript_format=text-timestamped."""
+    response = await client.post("/transcripts", json={"name": "Test transcript"})
+    assert response.status_code == 200
+    tid = response.json()["id"]
+
+    from reflector.db.transcripts import (
+        TranscriptParticipant,
+        TranscriptTopic,
+        transcripts_controller,
+    )
+    from reflector.processors.types import Word
+
+    transcript = await transcripts_controller.get_by_id(tid)
+
+    await transcripts_controller.update(
+        transcript,
+        {
+            "participants": [
+                TranscriptParticipant(
+                    id="1", speaker=0, name="John Smith"
+                ).model_dump(),
+            ]
+        },
+    )
+
+    await transcripts_controller.upsert_topic(
+        transcript,
+        TranscriptTopic(
+            title="Topic 1",
+            summary="Summary 1",
+            timestamp=0,
+            words=[
+                Word(text="Hello", start=65, end=66, speaker=0),
+                Word(text=" world.", start=66, end=67, speaker=0),
+            ],
+        ),
+    )
+
+    response = await client.get(
+        f"/transcripts/{tid}?transcript_format=text-timestamped"
+    )
+    assert response.status_code == 200
+    data = response.json()
+
+    assert data["transcript_format"] == "text-timestamped"
+    assert "transcript" in data
+    assert "[01:05] John Smith: Hello world." in data["transcript"]
+
+
+@pytest.mark.asyncio
+async def test_api_transcript_format_webvtt_named(client):
+    """Test GET /transcripts/{id} with transcript_format=webvtt-named."""
+    response = await client.post("/transcripts", json={"name": "Test transcript"})
+    assert response.status_code == 200
+    tid = response.json()["id"]
+
+    from reflector.db.transcripts import (
+        TranscriptParticipant,
+        TranscriptTopic,
+        transcripts_controller,
+    )
+    from reflector.processors.types import Word
+
+    transcript = await transcripts_controller.get_by_id(tid)
+
+    await transcripts_controller.update(
+        transcript,
+        {
+            "participants": [
+                TranscriptParticipant(
+                    id="1", speaker=0, name="John Smith"
+                ).model_dump(),
+            ]
+        },
+    )
+
+    await transcripts_controller.upsert_topic(
+        transcript,
+        TranscriptTopic(
+            title="Topic 1",
+            summary="Summary 1",
+            timestamp=0,
+            words=[
+                Word(text="Hello", start=0, end=1, speaker=0),
+                Word(text=" world.", start=1, end=2, speaker=0),
+            ],
+        ),
+    )
+
+    response = await client.get(f"/transcripts/{tid}?transcript_format=webvtt-named")
+    assert response.status_code == 200
+    data = response.json()
+
+    assert data["transcript_format"] == "webvtt-named"
+    assert "transcript" in data
+    assert "WEBVTT" in data["transcript"]
+    assert "<v John Smith>" in data["transcript"]
+
+
+@pytest.mark.asyncio
+async def test_api_transcript_format_json(client):
+    """Test GET /transcripts/{id} with transcript_format=json."""
+    response = await client.post("/transcripts", json={"name": "Test transcript"})
+    assert response.status_code == 200
+    tid = response.json()["id"]
+
+    from reflector.db.transcripts import (
+        TranscriptParticipant,
+        TranscriptTopic,
+        transcripts_controller,
+    )
+    from reflector.processors.types import Word
+
+    transcript = await transcripts_controller.get_by_id(tid)
+
+    await transcripts_controller.update(
+        transcript,
+        {
+            "participants": [
+                TranscriptParticipant(
+                    id="1", speaker=0, name="John Smith"
+                ).model_dump(),
+            ]
+        },
+    )
+
+    await transcripts_controller.upsert_topic(
+        transcript,
+        TranscriptTopic(
+            title="Topic 1",
+            summary="Summary 1",
+            timestamp=0,
+            words=[
+                Word(text="Hello", start=0, end=1, speaker=0),
+                Word(text=" world.", start=1, end=2, speaker=0),
+            ],
+        ),
+    )
+
+    response = await client.get(f"/transcripts/{tid}?transcript_format=json")
+    assert response.status_code == 200
+    data = response.json()
+
+    assert data["transcript_format"] == "json"
+    assert "transcript" in data
+    assert isinstance(data["transcript"], list)
+    assert len(data["transcript"]) == 1
+    assert data["transcript"][0]["speaker"] == 0
+    assert data["transcript"][0]["speaker_name"] == "John Smith"
+    assert data["transcript"][0]["text"] == "Hello world."
+
+
+@pytest.mark.asyncio
+async def test_api_transcript_format_default_is_text(client):
+    """Test GET /transcripts/{id} defaults to text format."""
+    response = await client.post("/transcripts", json={"name": "Test transcript"})
+    assert response.status_code == 200
+    tid = response.json()["id"]
+
+    from reflector.db.transcripts import TranscriptTopic, transcripts_controller
+    from reflector.processors.types import Word
+
+    transcript = await transcripts_controller.get_by_id(tid)
+
+    await transcripts_controller.upsert_topic(
+        transcript,
+        TranscriptTopic(
+            title="Topic 1",
+            summary="Summary 1",
+            timestamp=0,
+            words=[
+                Word(text="Hello", start=0, end=1, speaker=0),
+            ],
+        ),
+    )
+
+    response = await client.get(f"/transcripts/{tid}")
+    assert response.status_code == 200
+    data = response.json()
+
+    assert data["transcript_format"] == "text"
+    assert "transcript" in data
+
+
+@pytest.mark.asyncio
+async def test_api_topics_endpoint_multitrack_segmentation(client):
+    """Test GET /transcripts/{id}/topics uses sentence-based segmentation for multitrack.
+
+    This tests the fix for TASKS2.md - ensuring /topics endpoints correctly detect
+    multitrack recordings and use sentence-based segmentation instead of fragmenting
+    on every speaker change.
+    """
+    from datetime import datetime, timezone
+
+    from reflector.db.recordings import Recording, recordings_controller
+    from reflector.db.transcripts import (
+        TranscriptParticipant,
+        TranscriptTopic,
+        transcripts_controller,
+    )
+    from reflector.processors.types import Word
+
+    # Create a multitrack recording (has track_keys)
+    recording = Recording(
+        bucket_name="test-bucket",
+        object_key="test-key",
+        recorded_at=datetime.now(timezone.utc),
+        track_keys=["track1.webm", "track2.webm"],  # This makes it multitrack
+    )
+    await recordings_controller.create(recording)
+
+    # Create transcript linked to the recording
+    transcript = await transcripts_controller.add(
+        name="Multitrack Test",
+        source_kind="file",
+        recording_id=recording.id,
+    )
+
+    await transcripts_controller.update(
+        transcript,
+        {
+            "participants": [
+                TranscriptParticipant(id="1", speaker=0, name="Alice").model_dump(),
+                TranscriptParticipant(id="2", speaker=1, name="Bob").model_dump(),
+            ]
+        },
+    )
+
+    # Add interleaved words (as they appear in real multitrack data)
+    await transcripts_controller.upsert_topic(
+        transcript,
+        TranscriptTopic(
+            title="Topic 1",
+            summary="Summary 1",
+            timestamp=0,
+            words=[
+                Word(text="Hello ", start=0.0, end=0.5, speaker=0),
+                Word(text="I'm ", start=0.5, end=0.8, speaker=1),
+                Word(text="there.", start=0.5, end=1.0, speaker=0),
+                Word(text="good.", start=1.0, end=1.5, speaker=1),
+            ],
+        ),
+    )
+
+    # Test /topics endpoint
+    response = await client.get(f"/transcripts/{transcript.id}/topics")
+    assert response.status_code == 200
+    data = response.json()
+
+    assert len(data) == 1
+    topic = data[0]
+
+    # Key assertion: multitrack should produce 2 segments (one per speaker sentence)
+    # Not 4 segments (one per speaker change)
+    assert len(topic["segments"]) == 2
+
+    # Check content
+    segment_texts = [s["text"] for s in topic["segments"]]
+    assert "Hello there." in segment_texts
+    assert "I'm good." in segment_texts
+
+
+@pytest.mark.asyncio
+async def test_api_topics_endpoint_non_multitrack_segmentation(client):
+    """Test GET /transcripts/{id}/topics uses default segmentation for non-multitrack.
+
+    Ensures backward compatibility - transcripts without multitrack recordings
+    should continue using the default speaker-change-based segmentation.
+    """
+    from reflector.db.transcripts import (
+        TranscriptParticipant,
+        TranscriptTopic,
+        transcripts_controller,
+    )
+    from reflector.processors.types import Word
+
+    # Create transcript WITHOUT recording (defaulted as not multitrack) TODO better heuristic
+    response = await client.post("/transcripts", json={"name": "Test transcript"})
+    assert response.status_code == 200
+    tid = response.json()["id"]
+
+    transcript = await transcripts_controller.get_by_id(tid)
+
+    await transcripts_controller.update(
+        transcript,
+        {
+            "participants": [
+                TranscriptParticipant(id="1", speaker=0, name="Alice").model_dump(),
+                TranscriptParticipant(id="2", speaker=1, name="Bob").model_dump(),
+            ]
+        },
+    )
+
+    # Add interleaved words
+    await transcripts_controller.upsert_topic(
+        transcript,
+        TranscriptTopic(
+            title="Topic 1",
+            summary="Summary 1",
+            timestamp=0,
+            words=[
+                Word(text="Hello ", start=0.0, end=0.5, speaker=0),
+                Word(text="I'm ", start=0.5, end=0.8, speaker=1),
+                Word(text="there.", start=0.5, end=1.0, speaker=0),
+                Word(text="good.", start=1.0, end=1.5, speaker=1),
+            ],
+        ),
+    )
+
+    # Test /topics endpoint
+    response = await client.get(f"/transcripts/{tid}/topics")
+    assert response.status_code == 200
+    data = response.json()
+
+    assert len(data) == 1
+    topic = data[0]
+
+    # Non-multitrack: should produce 4 segments (one per speaker change)
+    assert len(topic["segments"]) == 4
+
+
+@pytest.mark.asyncio
+async def test_api_topics_with_words_endpoint_multitrack(client):
+    """Test GET /transcripts/{id}/topics/with-words uses multitrack segmentation."""
+    from datetime import datetime, timezone
+
+    from reflector.db.recordings import Recording, recordings_controller
+    from reflector.db.transcripts import (
+        TranscriptParticipant,
+        TranscriptTopic,
+        transcripts_controller,
+    )
+    from reflector.processors.types import Word
+
+    # Create multitrack recording
+    recording = Recording(
+        bucket_name="test-bucket",
+        object_key="test-key-2",
+        recorded_at=datetime.now(timezone.utc),
+        track_keys=["track1.webm", "track2.webm"],
+    )
+    await recordings_controller.create(recording)
+
+    transcript = await transcripts_controller.add(
+        name="Multitrack Test 2",
+        source_kind="file",
+        recording_id=recording.id,
+    )
+
+    await transcripts_controller.update(
+        transcript,
+        {
+            "participants": [
+                TranscriptParticipant(id="1", speaker=0, name="Alice").model_dump(),
+                TranscriptParticipant(id="2", speaker=1, name="Bob").model_dump(),
+            ]
+        },
+    )
+
+    await transcripts_controller.upsert_topic(
+        transcript,
+        TranscriptTopic(
+            title="Topic 1",
+            summary="Summary 1",
+            timestamp=0,
+            words=[
+                Word(text="Hello ", start=0.0, end=0.5, speaker=0),
+                Word(text="I'm ", start=0.5, end=0.8, speaker=1),
+                Word(text="there.", start=0.5, end=1.0, speaker=0),
+                Word(text="good.", start=1.0, end=1.5, speaker=1),
+            ],
+        ),
+    )
+
+    response = await client.get(f"/transcripts/{transcript.id}/topics/with-words")
+    assert response.status_code == 200
+    data = response.json()
+
+    assert len(data) == 1
+    topic = data[0]
+
+    # Should have 2 segments (multitrack sentence-based)
+    assert len(topic["segments"]) == 2
+    # Should also have words field
+    assert "words" in topic
+    assert len(topic["words"]) == 4

server/tests/test_transcripts.py

@@ -1,5 +1,8 @@
 import pytest
 
+from reflector.db.rooms import rooms_controller
+from reflector.db.transcripts import transcripts_controller
+
 
 @pytest.mark.asyncio
 async def test_transcript_create(client):
@@ -182,3 +185,51 @@ async def test_transcript_mark_reviewed(authenticated_client, client):
     response = await client.get(f"/transcripts/{tid}")
     assert response.status_code == 200
     assert response.json()["reviewed"] is True
+
+
+@pytest.mark.asyncio
+async def test_transcript_get_returns_room_name(authenticated_client, client):
+    """Test that getting a transcript returns its room_name when linked to a room."""
+    # Create a room
+    room = await rooms_controller.add(
+        name="test-room-for-transcript",
+        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,
+        webhook_url="",
+        webhook_secret="",
+    )
+
+    # Create a transcript linked to the room
+    transcript = await transcripts_controller.add(
+        name="transcript-with-room",
+        source_kind="file",
+        room_id=room.id,
+    )
+
+    # Get the transcript and verify room_name is returned
+    response = await client.get(f"/transcripts/{transcript.id}")
+    assert response.status_code == 200
+    assert response.json()["room_id"] == room.id
+    assert response.json()["room_name"] == "test-room-for-transcript"
+
+
+@pytest.mark.asyncio
+async def test_transcript_get_returns_null_room_name_when_no_room(
+    authenticated_client, client
+):
+    """Test that room_name is null when transcript has no room."""
+    response = await client.post("/transcripts", json={"name": "no-room-transcript"})
+    assert response.status_code == 200
+    tid = response.json()["id"]
+
+    response = await client.get(f"/transcripts/{tid}")
+    assert response.status_code == 200
+    assert response.json()["room_id"] is None
+    assert response.json()["room_name"] is None

www/app/(app)/rooms/page.tsx

@@ -15,9 +15,12 @@ import {
   createListCollection,
   useDisclosure,
   Tabs,
+  Popover,
+  Text,
+  HStack,
 } from "@chakra-ui/react";
 import { useEffect, useMemo, useState } from "react";
-import { LuEye, LuEyeOff } from "react-icons/lu";
+import { LuEye, LuEyeOff, LuInfo } from "react-icons/lu";
 import useRoomList from "./useRoomList";
 import type { components } from "../../reflector-api";
 import {
@@ -67,6 +70,11 @@ const recordingTypeOptions: SelectOption[] = [
   { label: "Cloud", value: "cloud" },
 ];
 
+const platformOptions: SelectOption[] = [
+  { label: "Whereby", value: "whereby" },
+  { label: "Daily", value: "daily" },
+];
+
 const roomInitialState = {
   name: "",
   zulipAutoPost: false,
@@ -82,6 +90,8 @@ const roomInitialState = {
   icsUrl: "",
   icsEnabled: false,
   icsFetchInterval: 5,
+  platform: "whereby",
+  skipConsent: false,
 };
 
 export default function RoomsList() {
@@ -99,6 +109,11 @@ export default function RoomsList() {
   const recordingTypeCollection = createListCollection({
     items: recordingTypeOptions,
   });
+
+  const platformCollection = createListCollection({
+    items: platformOptions,
+  });
+
   const [roomInput, setRoomInput] = useState<null | typeof roomInitialState>(
     null,
   );
@@ -143,15 +158,25 @@ export default function RoomsList() {
             zulipStream: detailedEditedRoom.zulip_stream,
             zulipTopic: detailedEditedRoom.zulip_topic,
             isLocked: detailedEditedRoom.is_locked,
-            roomMode: detailedEditedRoom.room_mode,
+            roomMode:
+              detailedEditedRoom.platform === "daily"
+                ? "group"
+                : detailedEditedRoom.room_mode,
             recordingType: detailedEditedRoom.recording_type,
-            recordingTrigger: detailedEditedRoom.recording_trigger,
+            recordingTrigger:
+              detailedEditedRoom.platform === "daily"
+                ? detailedEditedRoom.recording_type === "cloud"
+                  ? "automatic-2nd-participant"
+                  : "none"
+                : detailedEditedRoom.recording_trigger,
             isShared: detailedEditedRoom.is_shared,
             webhookUrl: detailedEditedRoom.webhook_url || "",
             webhookSecret: detailedEditedRoom.webhook_secret || "",
             icsUrl: detailedEditedRoom.ics_url || "",
             icsEnabled: detailedEditedRoom.ics_enabled || false,
             icsFetchInterval: detailedEditedRoom.ics_fetch_interval || 5,
+            platform: detailedEditedRoom.platform,
+            skipConsent: detailedEditedRoom.skip_consent || false,
           }
         : null,
     [detailedEditedRoom],
@@ -277,21 +302,33 @@ export default function RoomsList() {
         return;
       }
 
+      const platform: "whereby" | "daily" | null =
+        room.platform === "whereby" || room.platform === "daily"
+          ? room.platform
+          : null;
+
       const roomData = {
         name: room.name,
         zulip_auto_post: room.zulipAutoPost,
         zulip_stream: room.zulipStream,
         zulip_topic: room.zulipTopic,
         is_locked: room.isLocked,
-        room_mode: room.roomMode,
+        room_mode: platform === "daily" ? "group" : room.roomMode,
         recording_type: room.recordingType,
-        recording_trigger: room.recordingTrigger,
+        recording_trigger:
+          platform === "daily"
+            ? room.recordingType === "cloud"
+              ? "automatic-2nd-participant"
+              : "none"
+            : room.recordingTrigger,
         is_shared: room.isShared,
         webhook_url: room.webhookUrl,
         webhook_secret: room.webhookSecret,
         ics_url: room.icsUrl,
         ics_enabled: room.icsEnabled,
         ics_fetch_interval: room.icsFetchInterval,
+        platform,
+        skip_consent: room.skipConsent,
       };
 
       if (isEditing) {
@@ -339,15 +376,22 @@ export default function RoomsList() {
       zulipStream: roomData.zulip_stream,
       zulipTopic: roomData.zulip_topic,
       isLocked: roomData.is_locked,
-      roomMode: roomData.room_mode,
+      roomMode: roomData.platform === "daily" ? "group" : roomData.room_mode, // Daily always uses 2-200
       recordingType: roomData.recording_type,
-      recordingTrigger: roomData.recording_trigger,
+      recordingTrigger:
+        roomData.platform === "daily"
+          ? roomData.recording_type === "cloud"
+            ? "automatic-2nd-participant"
+            : "none"
+          : roomData.recording_trigger,
       isShared: roomData.is_shared,
       webhookUrl: roomData.webhook_url || "",
       webhookSecret: roomData.webhook_secret || "",
       icsUrl: roomData.ics_url || "",
       icsEnabled: roomData.ics_enabled || false,
       icsFetchInterval: roomData.ics_fetch_interval || 5,
+      platform: roomData.platform,
+      skipConsent: roomData.skip_consent || false,
     });
     setEditRoomId(roomId);
     setIsEditing(true);
@@ -482,6 +526,52 @@ export default function RoomsList() {
                       )}
                     </Field.Root>
 
+                    <Field.Root mt={4}>
+                      <Field.Label>Platform</Field.Label>
+                      <Select.Root
+                        value={[room.platform]}
+                        onValueChange={(e) => {
+                          const newPlatform = e.value[0] as "whereby" | "daily";
+                          const updates: Partial<typeof room> = {
+                            platform: newPlatform,
+                          };
+                          if (newPlatform === "daily") {
+                            updates.roomMode = "group";
+                            updates.recordingTrigger =
+                              room.recordingType === "cloud"
+                                ? "automatic-2nd-participant"
+                                : "none";
+                          } else {
+                            if (room.recordingType !== "cloud") {
+                              updates.recordingTrigger = "none";
+                            }
+                          }
+                          setRoomInput({ ...room, ...updates });
+                        }}
+                        collection={platformCollection}
+                      >
+                        <Select.HiddenSelect />
+                        <Select.Control>
+                          <Select.Trigger>
+                            <Select.ValueText placeholder="Select platform" />
+                          </Select.Trigger>
+                          <Select.IndicatorGroup>
+                            <Select.Indicator />
+                          </Select.IndicatorGroup>
+                        </Select.Control>
+                        <Select.Positioner>
+                          <Select.Content>
+                            {platformOptions.map((option) => (
+                              <Select.Item key={option.value} item={option}>
+                                {option.label}
+                                <Select.ItemIndicator />
+                              </Select.Item>
+                            ))}
+                          </Select.Content>
+                        </Select.Positioner>
+                      </Select.Root>
+                    </Field.Root>
+
                     <Field.Root mt={4}>
                       <Checkbox.Root
                         name="isLocked"
@@ -504,50 +594,95 @@ export default function RoomsList() {
                         <Checkbox.Label>Locked room</Checkbox.Label>
                       </Checkbox.Root>
                     </Field.Root>
+                    {room.platform !== "daily" && (
+                      <Field.Root mt={4}>
+                        <Field.Label>Room size</Field.Label>
+                        <Select.Root
+                          value={[room.roomMode]}
+                          onValueChange={(e) =>
+                            setRoomInput({ ...room, roomMode: e.value[0] })
+                          }
+                          collection={roomModeCollection}
+                        >
+                          <Select.HiddenSelect />
+                          <Select.Control>
+                            <Select.Trigger>
+                              <Select.ValueText placeholder="Select room size" />
+                            </Select.Trigger>
+                            <Select.IndicatorGroup>
+                              <Select.Indicator />
+                            </Select.IndicatorGroup>
+                          </Select.Control>
+                          <Select.Positioner>
+                            <Select.Content>
+                              {roomModeOptions.map((option) => (
+                                <Select.Item key={option.value} item={option}>
+                                  {option.label}
+                                  <Select.ItemIndicator />
+                                </Select.Item>
+                              ))}
+                            </Select.Content>
+                          </Select.Positioner>
+                        </Select.Root>
+                      </Field.Root>
+                    )}
                     <Field.Root mt={4}>
-                      <Field.Label>Room size</Field.Label>
+                      <HStack gap={2} alignItems="center">
-                      <Select.Root
+                        <Field.Label>Recording type</Field.Label>
-                        value={[room.roomMode]}
+                        <Popover.Root>
-                        onValueChange={(e) =>
+                          <Popover.Trigger asChild>
-                          setRoomInput({ ...room, roomMode: e.value[0] })
+                            <IconButton
-                        }
+                              aria-label="Recording type help"
-                        collection={roomModeCollection}
+                              variant="ghost"
-                      >
+                              size="xs"
-                        <Select.HiddenSelect />
+                              colorPalette="gray"
-                        <Select.Control>
+                            >
-                          <Select.Trigger>
+                              <LuInfo />
-                            <Select.ValueText placeholder="Select room size" />
+                            </IconButton>
-                          </Select.Trigger>
+                          </Popover.Trigger>
-                          <Select.IndicatorGroup>
+                          <Popover.Positioner>
-                            <Select.Indicator />
+                            <Popover.Content>
-                          </Select.IndicatorGroup>
+                              <Popover.Arrow />
-                        </Select.Control>
+                              <Popover.Body>
-                        <Select.Positioner>
+                                <Text fontSize="sm" lineHeight="1.6">
-                          <Select.Content>
+                                  <strong>None:</strong> No recording will be
-                            {roomModeOptions.map((option) => (
+                                  created.
-                              <Select.Item key={option.value} item={option}>
+                                  <br />
-                                {option.label}
+                                  <br />
-                                <Select.ItemIndicator />
+                                  <strong>Local:</strong> Recording happens on
-                              </Select.Item>
+                                  each participant's device. Files are saved
-                            ))}
+                                  locally.
-                          </Select.Content>
+                                  <br />
-                        </Select.Positioner>
+                                  <br />
-                      </Select.Root>
+                                  <strong>Cloud:</strong> Recording happens on
-                    </Field.Root>
+                                  the platform's servers and is available after
-                    <Field.Root mt={4}>
+                                  the meeting ends.
-                      <Field.Label>Recording type</Field.Label>
+                                </Text>
+                              </Popover.Body>
+                            </Popover.Content>
+                          </Popover.Positioner>
+                        </Popover.Root>
+                      </HStack>
                       <Select.Root
                         value={[room.recordingType]}
-                        onValueChange={(e) =>
+                        onValueChange={(e) => {
-                          setRoomInput({
+                          const newRecordingType = e.value[0];
-                            ...room,
+                          const updates: Partial<typeof room> = {
-                            recordingType: e.value[0],
+                            recordingType: newRecordingType,
-                            recordingTrigger:
+                          };
-                              e.value[0] !== "cloud"
+                          if (room.platform === "daily") {
+                            updates.recordingTrigger =
+                              newRecordingType === "cloud"
+                                ? "automatic-2nd-participant"
+                                : "none";
+                          } else {
+                            updates.recordingTrigger =
+                              newRecordingType !== "cloud"
                                 ? "none"
-                                : room.recordingTrigger,
+                                : room.recordingTrigger;
-                          })
+                          }
-                        }
+                          setRoomInput({ ...room, ...updates });
+                        }}
                         collection={recordingTypeCollection}
                       >
                         <Select.HiddenSelect />
@@ -571,40 +706,77 @@ export default function RoomsList() {
                         </Select.Positioner>
                       </Select.Root>
                     </Field.Root>
-                    <Field.Root mt={4}>
+                    {room.recordingType === "cloud" &&
-                      <Field.Label>Cloud recording start trigger</Field.Label>
+                      room.platform !== "daily" && (
-                      <Select.Root
+                        <Field.Root mt={4}>
-                        value={[room.recordingTrigger]}
+                          <HStack gap={2} alignItems="center">
-                        onValueChange={(e) =>
+                            <Field.Label>Recording start trigger</Field.Label>
-                          setRoomInput({
+                            <Popover.Root>
-                            ...room,
+                              <Popover.Trigger asChild>
-                            recordingTrigger: e.value[0],
+                                <IconButton
-                          })
+                                  aria-label="Recording start trigger help"
-                        }
+                                  variant="ghost"
-                        collection={recordingTriggerCollection}
+                                  size="xs"
-                        disabled={room.recordingType !== "cloud"}
+                                  colorPalette="gray"
-                      >
+                                >
-                        <Select.HiddenSelect />
+                                  <LuInfo />
-                        <Select.Control>
+                                </IconButton>
-                          <Select.Trigger>
+                              </Popover.Trigger>
-                            <Select.ValueText placeholder="Select trigger" />
+                              <Popover.Positioner>
-                          </Select.Trigger>
+                                <Popover.Content>
-                          <Select.IndicatorGroup>
+                                  <Popover.Arrow />
-                            <Select.Indicator />
+                                  <Popover.Body>
-                          </Select.IndicatorGroup>
+                                    <Text fontSize="sm" lineHeight="1.6">
-                        </Select.Control>
+                                      <strong>None:</strong> Recording must be
-                        <Select.Positioner>
+                                      started manually by a participant.
-                          <Select.Content>
+                                      <br />
-                            {recordingTriggerOptions.map((option) => (
+                                      <br />
-                              <Select.Item key={option.value} item={option}>
+                                      <strong>Prompt:</strong> Participants will
-                                {option.label}
+                                      be prompted to start recording when they
-                                <Select.ItemIndicator />
+                                      join.
-                              </Select.Item>
+                                      <br />
-                            ))}
+                                      <br />
-                          </Select.Content>
+                                      <strong>Automatic:</strong> Recording
-                        </Select.Positioner>
+                                      starts automatically when a second
-                      </Select.Root>
+                                      participant joins.
-                    </Field.Root>
+                                    </Text>
+                                  </Popover.Body>
+                                </Popover.Content>
+                              </Popover.Positioner>
+                            </Popover.Root>
+                          </HStack>
+                          <Select.Root
+                            value={[room.recordingTrigger]}
+                            onValueChange={(e) =>
+                              setRoomInput({
+                                ...room,
+                                recordingTrigger: e.value[0],
+                              })
+                            }
+                            collection={recordingTriggerCollection}
+                          >
+                            <Select.HiddenSelect />
+                            <Select.Control>
+                              <Select.Trigger>
+                                <Select.ValueText placeholder="Select trigger" />
+                              </Select.Trigger>
+                              <Select.IndicatorGroup>
+                                <Select.Indicator />
+                              </Select.IndicatorGroup>
+                            </Select.Control>
+                            <Select.Positioner>
+                              <Select.Content>
+                                {recordingTriggerOptions.map((option) => (
+                                  <Select.Item key={option.value} item={option}>
+                                    {option.label}
+                                    <Select.ItemIndicator />
+                                  </Select.Item>
+                                ))}
+                              </Select.Content>
+                            </Select.Positioner>
+                          </Select.Root>
+                        </Field.Root>
+                      )}
 
                     <Field.Root mt={4}>
                       <Checkbox.Root
@@ -628,6 +800,34 @@ export default function RoomsList() {
                         <Checkbox.Label>Shared room</Checkbox.Label>
                       </Checkbox.Root>
                     </Field.Root>
+                    {room.recordingType === "cloud" && (
+                      <Field.Root mt={4}>
+                        <Checkbox.Root
+                          name="skipConsent"
+                          checked={room.skipConsent}
+                          onCheckedChange={(e) => {
+                            const syntheticEvent = {
+                              target: {
+                                name: "skipConsent",
+                                type: "checkbox",
+                                checked: e.checked,
+                              },
+                            };
+                            handleRoomChange(syntheticEvent);
+                          }}
+                        >
+                          <Checkbox.HiddenInput />
+                          <Checkbox.Control>
+                            <Checkbox.Indicator />
+                          </Checkbox.Control>
+                          <Checkbox.Label>Skip consent dialog</Checkbox.Label>
+                        </Checkbox.Root>
+                        <Field.HelperText>
+                          When enabled, participants won't be asked for
+                          recording consent. Audio will be stored automatically.
+                        </Field.HelperText>
+                      </Field.Root>
+                    )}
                   </Tabs.Content>
 
                   <Tabs.Content value="share" pt={6}>

www/app/(app)/transcripts/[transcriptId]/page.tsx

@@ -117,15 +117,6 @@ export default function TranscriptDetails(details: TranscriptDetails) {
     return <Modal title="Loading" text={"Loading transcript..."} />;
   }
 
-  if (mp3.error) {
-    return (
-      <Modal
-        title="Transcription error"
-        text={`There was an error loading the recording. Error: ${mp3.error}`}
-      />
-    );
-  }
-
   return (
     <>
       <Grid
@@ -147,7 +138,12 @@ export default function TranscriptDetails(details: TranscriptDetails) {
               />
             ) : !mp3.loading && (waveform.error || mp3.error) ? (
               <Box p={4} bg="red.100" borderRadius="md">
-                <Text>Error loading this recording</Text>
+                <Text>
+                  Error loading{" "}
+                  {[waveform.error && "waveform", mp3.error && "mp3"]
+                    .filter(Boolean)
+                    .join(" and ")}
+                </Text>
               </Box>
             ) : (
               <Skeleton h={14} />

www/app/(app)/transcripts/shareCopy.tsx

@@ -1,14 +1,16 @@
 import { useState } from "react";
-import type { components } from "../../reflector-api";
+import type { components, operations } from "../../reflector-api";
-type GetTranscript = components["schemas"]["GetTranscript"];
+type GetTranscriptWithParticipants =
+  components["schemas"]["GetTranscriptWithParticipants"];
 type GetTranscriptTopic = components["schemas"]["GetTranscriptTopic"];
-import { Button, BoxProps, Box } from "@chakra-ui/react";
+import { Button, BoxProps, Box, Menu, Text } from "@chakra-ui/react";
-import { buildTranscriptWithTopics } from "./buildTranscriptWithTopics";
+import { LuChevronDown } from "react-icons/lu";
-import { useTranscriptParticipants } from "../../lib/apiHooks";
+import { client } from "../../lib/apiClient";
+import { toaster } from "../../components/ui/toaster";
 
 type ShareCopyProps = {
   finalSummaryElement: HTMLDivElement | null;
-  transcript: GetTranscript;
+  transcript: GetTranscriptWithParticipants;
   topics: GetTranscriptTopic[];
 };
 
@@ -20,11 +22,33 @@ export default function ShareCopy({
 }: ShareCopyProps & BoxProps) {
   const [isCopiedSummary, setIsCopiedSummary] = useState(false);
   const [isCopiedTranscript, setIsCopiedTranscript] = useState(false);
-  const participantsQuery = useTranscriptParticipants(transcript?.id || null);
+  const [isCopying, setIsCopying] = useState(false);
+
+  type ApiTranscriptFormat = NonNullable<
+    operations["v1_transcript_get"]["parameters"]["query"]
+  >["transcript_format"];
+  const TRANSCRIPT_FORMATS = [
+    "text",
+    "text-timestamped",
+    "webvtt-named",
+    "json",
+  ] as const satisfies ApiTranscriptFormat[];
+  type TranscriptFormat = (typeof TRANSCRIPT_FORMATS)[number];
+
+  const TRANSCRIPT_FORMAT_LABELS: { [k in TranscriptFormat]: string } = {
+    text: "Plain text",
+    "text-timestamped": "Text + timestamps",
+    "webvtt-named": "WebVTT (named)",
+    json: "JSON",
+  };
+
+  const formatOptions = TRANSCRIPT_FORMATS.map((f) => ({
+    value: f,
+    label: TRANSCRIPT_FORMAT_LABELS[f],
+  }));
 
   const onCopySummaryClick = () => {
     const text_to_copy = finalSummaryElement?.innerText;
-
     if (text_to_copy) {
       navigator.clipboard.writeText(text_to_copy).then(() => {
         setIsCopiedSummary(true);
@@ -34,27 +58,91 @@ export default function ShareCopy({
     }
   };
 
-  const onCopyTranscriptClick = () => {
+  const onCopyTranscriptFormatClick = async (format: TranscriptFormat) => {
-    const text_to_copy =
+    try {
-      buildTranscriptWithTopics(
+      setIsCopying(true);
-        topics || [],
+      const { data, error } = await client.GET(
-        participantsQuery?.data || null,
+        "/v1/transcripts/{transcript_id}",
-        transcript?.title || null,
+        {
-      ) || "";
+          params: {
+            path: { transcript_id: transcript.id },
+            query: { transcript_format: format },
+          },
+        },
+      );
+      if (error) {
+        console.error("Failed to copy transcript:", error);
+        toaster.create({
+          duration: 3000,
+          render: () => (
+            <Box bg="red.500" color="white" px={4} py={3} borderRadius="md">
+              <Text fontWeight="bold">Error</Text>
+              <Text fontSize="sm">Failed to fetch transcript</Text>
+            </Box>
+          ),
+        });
+        return;
+      }
 
-    text_to_copy &&
+      const copiedText =
-      navigator.clipboard.writeText(text_to_copy).then(() => {
+        format === "json"
+          ? JSON.stringify(data?.transcript ?? {}, null, 2)
+          : String(data?.transcript ?? "");
+
+      if (copiedText) {
+        await navigator.clipboard.writeText(copiedText);
         setIsCopiedTranscript(true);
-        // Reset the copied state after 2 seconds
         setTimeout(() => setIsCopiedTranscript(false), 2000);
+      }
+    } catch (e) {
+      console.error("Failed to copy transcript:", e);
+      toaster.create({
+        duration: 3000,
+        render: () => (
+          <Box bg="red.500" color="white" px={4} py={3} borderRadius="md">
+            <Text fontWeight="bold">Error</Text>
+            <Text fontSize="sm">Failed to copy transcript</Text>
+          </Box>
+        ),
       });
+    } finally {
+      setIsCopying(false);
+    }
   };
 
   return (
     <Box {...boxProps}>
-      <Button onClick={onCopyTranscriptClick} mr={2} variant="subtle">
+      <Menu.Root
-        {isCopiedTranscript ? "Copied!" : "Copy Transcript"}
+        closeOnSelect={true}
-      </Button>
+        lazyMount={true}
+        positioning={{ gutter: 4 }}
+      >
+        <Menu.Trigger asChild>
+          <Button
+            mr={2}
+            variant="subtle"
+            loading={isCopying}
+            loadingText="Copying..."
+          >
+            {isCopiedTranscript ? "Copied!" : "Copy Transcript"}
+            <LuChevronDown style={{ marginLeft: 6 }} />
+          </Button>
+        </Menu.Trigger>
+        <Menu.Positioner>
+          <Menu.Content>
+            {formatOptions.map((opt) => (
+              <Menu.Item
+                key={opt.value}
+                value={opt.value}
+                _hover={{ backgroundColor: "gray.100" }}
+                onClick={() => onCopyTranscriptFormatClick(opt.value)}
+              >
+                {opt.label}
+              </Menu.Item>
+            ))}
+          </Menu.Content>
+        </Menu.Positioner>
+      </Menu.Root>
       <Button onClick={onCopySummaryClick} variant="subtle">
         {isCopiedSummary ? "Copied!" : "Copy Summary"}
       </Button>

www/app/(auth)/userInfo.tsx

@@ -13,9 +13,12 @@ export default function UserInfo() {
     <Spinner size="xs" className="mx-3" />
   ) : !isAuthenticated && !isRefreshing ? (
     <Link
-      href="/"
+      href="#"
       className="font-light px-2"
-      onClick={() => auth.signIn("authentik")}
+      onClick={(e) => {
+        e.preventDefault();
+        auth.signIn("authentik");
+      }}
     >
       Log in
     </Link>

www/app/[roomName]/MeetingSelection.tsx

@@ -26,6 +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";
 
 type Meeting = components["schemas"]["Meeting"];
 
@@ -98,7 +99,7 @@ export default function MeetingSelection({
     onMeetingSelect(meeting);
   };
 
-  const handleEndMeeting = async (meetingId: string) => {
+  const handleEndMeeting = async (meetingId: MeetingId) => {
     try {
       await deactivateMeetingMutation.mutateAsync({
         params: {

www/app/[roomName]/components/DailyRoom.tsx

@@ -1,37 +1,196 @@
 "use client";
 
-import { useCallback, useEffect, useRef, useState } from "react";
+import {
+  RefObject,
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
 import { Box, Spinner, Center, Text } from "@chakra-ui/react";
 import { useRouter, useParams } from "next/navigation";
-import DailyIframe, { DailyCall } from "@daily-co/daily-js";
+import DailyIframe, {
+  DailyCall,
+  DailyCallOptions,
+  DailyCustomTrayButton,
+  DailyCustomTrayButtons,
+  DailyEventObjectCustomButtonClick,
+  DailyFactoryOptions,
+  DailyParticipantsObject,
+} from "@daily-co/daily-js";
 import type { components } from "../../reflector-api";
 import { useAuth } from "../../lib/AuthProvider";
-import {
+import { useConsentDialog } from "../../lib/consent";
-  ConsentDialogButton,
-  recordingTypeRequiresConsent,
-} from "../../lib/consent";
 import { useRoomJoinMeeting } from "../../lib/apiHooks";
+import { omit } from "remeda";
+import { assertExists } from "../../lib/utils";
+import { assertMeetingId } from "../../lib/types";
+
+const CONSENT_BUTTON_ID = "recording-consent";
+const RECORDING_INDICATOR_ID = "recording-indicator";
 
 type Meeting = components["schemas"]["Meeting"];
+type Room = components["schemas"]["RoomDetails"];
 
-interface DailyRoomProps {
+type DailyRoomProps = {
   meeting: Meeting;
-}
+  room: Room;
+};
 
-export default function DailyRoom({ meeting }: DailyRoomProps) {
+const useCustomTrayButtons = (
+  frame: {
+    updateCustomTrayButtons: (
+      customTrayButtons: DailyCustomTrayButtons,
+    ) => void;
+    joined: boolean;
+  } | null,
+) => {
+  const [, setCustomTrayButtons] = useState<DailyCustomTrayButtons>({});
+  return useCallback(
+    (id: string, button: DailyCustomTrayButton | null) => {
+      setCustomTrayButtons((prev) => {
+        // would blink state when frame blinks but it's ok here
+        const state =
+          button === null ? omit(prev, [id]) : { ...prev, [id]: button };
+        if (frame !== null && frame.joined)
+          frame.updateCustomTrayButtons(state);
+        return state;
+      });
+    },
+    [setCustomTrayButtons, frame],
+  );
+};
+
+const USE_FRAME_INIT_STATE = {
+  frame: null as DailyCall | null,
+  joined: false as boolean,
+} as const;
+
+// Daily js and not Daily react used right now because daily-js allows for prebuild interface vs. -react is customizable but has no nice defaults
+const useFrame = (
+  container: HTMLDivElement | null,
+  cbs: {
+    onLeftMeeting: () => void;
+    onCustomButtonClick: (ev: DailyEventObjectCustomButtonClick) => void;
+    onJoinMeeting: (
+      startRecording: (args: { type: "raw-tracks" }) => void,
+    ) => void;
+  },
+) => {
+  const [{ frame, joined }, setState] = useState(USE_FRAME_INIT_STATE);
+  const setJoined = useCallback(
+    (joined: boolean) => setState((prev) => ({ ...prev, joined })),
+    [setState],
+  );
+  const setFrame = useCallback(
+    (frame: DailyCall | null) => setState((prev) => ({ ...prev, frame })),
+    [setState],
+  );
+  useEffect(() => {
+    if (!container) return;
+    const init = async () => {
+      const existingFrame = DailyIframe.getCallInstance();
+      if (existingFrame) {
+        console.error("existing daily frame present");
+        await existingFrame.destroy();
+      }
+      const frameOptions: DailyFactoryOptions = {
+        iframeStyle: {
+          width: "100vw",
+          height: "100vh",
+          border: "none",
+        },
+        showLeaveButton: true,
+        showFullscreenButton: true,
+      };
+      const frame = DailyIframe.createFrame(container, frameOptions);
+      setFrame(frame);
+    };
+    init().catch(
+      console.error.bind(console, "Failed to initialize daily frame:"),
+    );
+    return () => {
+      frame
+        ?.destroy()
+        .catch(console.error.bind(console, "Failed to destroy daily frame:"));
+      setState(USE_FRAME_INIT_STATE);
+    };
+  }, [container]);
+  useEffect(() => {
+    if (!frame) return;
+    frame.on("left-meeting", cbs.onLeftMeeting);
+    frame.on("custom-button-click", cbs.onCustomButtonClick);
+    const joinCb = () => {
+      if (!frame) {
+        console.error("frame is null in joined-meeting callback");
+        return;
+      }
+      cbs.onJoinMeeting(frame.startRecording.bind(frame));
+    };
+    frame.on("joined-meeting", joinCb);
+    return () => {
+      frame.off("left-meeting", cbs.onLeftMeeting);
+      frame.off("custom-button-click", cbs.onCustomButtonClick);
+      frame.off("joined-meeting", joinCb);
+    };
+  }, [frame, cbs]);
+  const frame_ = useMemo(() => {
+    if (frame === null) return frame;
+    return {
+      join: async (
+        properties?: DailyCallOptions,
+      ): Promise<DailyParticipantsObject | void> => {
+        await frame.join(properties);
+        setJoined(!frame.isDestroyed());
+      },
+      updateCustomTrayButtons: (
+        customTrayButtons: DailyCustomTrayButtons,
+      ): DailyCall => frame.updateCustomTrayButtons(customTrayButtons),
+    };
+  }, [frame]);
+  const setCustomTrayButton = useCustomTrayButtons(
+    useMemo(() => {
+      if (frame_ === null) return null;
+      return {
+        updateCustomTrayButtons: frame_.updateCustomTrayButtons,
+        joined,
+      };
+    }, [frame_, joined]),
+  );
+  return [
+    frame_,
+    {
+      setCustomTrayButton,
+    },
+  ] as const;
+};
+
+export default function DailyRoom({ meeting, room }: DailyRoomProps) {
   const router = useRouter();
   const params = useParams();
   const auth = useAuth();
-  const status = auth.status;
+  const authLastUserId = auth.lastUserId;
-  const containerRef = useRef<HTMLDivElement>(null);
+  const [container, setContainer] = useState<HTMLDivElement | null>(null);
   const joinMutation = useRoomJoinMeeting();
   const [joinedMeeting, setJoinedMeeting] = useState<Meeting | null>(null);
 
   const roomName = params?.roomName as string;
 
-  // Always call /join to get a fresh token with user_id
+  const {
+    showConsentModal,
+    showRecordingIndicator: showRecordingInTray,
+    showConsentButton,
+  } = useConsentDialog({
+    meetingId: assertMeetingId(meeting.id),
+    recordingType: meeting.recording_type,
+    skipConsent: room.skip_consent,
+  });
+  const showConsentModalRef = useRef(showConsentModal);
+  showConsentModalRef.current = showConsentModal;
+
   useEffect(() => {
-    if (status === "loading" || !meeting?.id || !roomName) return;
+    if (authLastUserId === undefined || !meeting?.id || !roomName) return;
 
     const join = async () => {
       try {
@@ -49,74 +208,97 @@ export default function DailyRoom({ meeting }: DailyRoomProps) {
       }
     };
 
-    join();
+    join().catch(console.error.bind(console, "Failed to join meeting:"));
-  }, [meeting?.id, roomName, status]);
+  }, [meeting?.id, roomName, authLastUserId]);
 
-  const roomUrl = joinedMeeting?.host_room_url || joinedMeeting?.room_url;
+  const roomUrl = joinedMeeting?.room_url;
-  const isLoading =
-    status === "loading" || joinMutation.isPending || !joinedMeeting;
 
   const handleLeave = useCallback(() => {
     router.push("/browse");
   }, [router]);
 
-  useEffect(() => {
+  const handleCustomButtonClick = useCallback(
-    if (isLoading || !roomUrl || !containerRef.current) return;
+    (ev: DailyEventObjectCustomButtonClick) => {
+      if (ev.button_id === CONSENT_BUTTON_ID) {
+        showConsentModalRef.current();
+      }
+    },
+    [
+      /*keep static; iframe recreation depends on it*/
+    ],
+  );
 
-    let frame: DailyCall | null = null;
+  const handleFrameJoinMeeting = useCallback(
-    let destroyed = false;
+    (startRecording: (args: { type: "raw-tracks" }) => void) => {
-
-    const createAndJoin = async () => {
       try {
-        const existingFrame = DailyIframe.getCallInstance();
+        if (meeting.recording_type === "cloud") {
-        if (existingFrame) {
+          console.log("Starting cloud recording");
-          await existingFrame.destroy();
+          startRecording({ type: "raw-tracks" });
         }
-
-        frame = DailyIframe.createFrame(containerRef.current!, {
-          iframeStyle: {
-            width: "100vw",
-            height: "100vh",
-            border: "none",
-          },
-          showLeaveButton: true,
-          showFullscreenButton: true,
-        });
-
-        if (destroyed) {
-          await frame.destroy();
-          return;
-        }
-
-        frame.on("left-meeting", handleLeave);
-
-        frame.on("joined-meeting", async () => {
-          try {
-            await frame.startRecording({ type: "raw-tracks" });
-          } catch (error) {
-            console.error("Failed to start recording:", error);
-          }
-        });
-
-        await frame.join({ url: roomUrl });
       } catch (error) {
-        console.error("Error creating Daily frame:", error);
+        console.error("Failed to start recording:", error);
       }
-    };
+    },
+    [meeting.recording_type],
+  );
 
-    createAndJoin();
+  const recordingIconUrl = useMemo(
+    () => new URL("/recording-icon.svg", window.location.origin),
+    [],
+  );
 
-    return () => {
+  const [frame, { setCustomTrayButton }] = useFrame(container, {
-      destroyed = true;
+    onLeftMeeting: handleLeave,
-      if (frame) {
+    onCustomButtonClick: handleCustomButtonClick,
-        frame.destroy().catch((e) => {
+    onJoinMeeting: handleFrameJoinMeeting,
-          console.error("Error destroying frame:", e);
+  });
-        });
-      }
-    };
-  }, [roomUrl, isLoading, handleLeave]);
 
-  if (isLoading) {
+  useEffect(() => {
+    if (!frame || !roomUrl) return;
+    frame
+      .join({
+        url: roomUrl,
+        sendSettings: {
+          video: {
+            // Optimize bandwidth for camera video
+            // allowAdaptiveLayers automatically adjusts quality based on network conditions
+            allowAdaptiveLayers: true,
+            // Use bandwidth-optimized preset as fallback for browsers without adaptive support
+            maxQuality: "medium",
+          },
+          // Note: screenVideo intentionally not configured to preserve full quality for screen shares
+        },
+      })
+      .catch(console.error.bind(console, "Failed to join daily room:"));
+  }, [frame, roomUrl]);
+
+  useEffect(() => {
+    setCustomTrayButton(
+      RECORDING_INDICATOR_ID,
+      showRecordingInTray
+        ? {
+            iconPath: recordingIconUrl.href,
+            label: "Recording",
+            tooltip: "Recording in progress",
+          }
+        : null,
+    );
+  }, [showRecordingInTray, recordingIconUrl, setCustomTrayButton]);
+
+  useEffect(() => {
+    setCustomTrayButton(
+      CONSENT_BUTTON_ID,
+      showConsentButton
+        ? {
+            iconPath: recordingIconUrl.href,
+            label: "Recording (click to consent)",
+            tooltip: "Recording (click to consent)",
+          }
+        : null,
+    );
+  }, [showConsentButton, recordingIconUrl, setCustomTrayButton]);
+
+  if (authLastUserId === undefined) {
     return (
       <Center width="100vw" height="100vh">
         <Spinner size="xl" />
@@ -138,10 +320,7 @@ export default function DailyRoom({ meeting }: DailyRoomProps) {
 
   return (
     <Box position="relative" width="100vw" height="100vh">
-      <div ref={containerRef} style={{ width: "100%", height: "100%" }} />
+      <div ref={setContainer} style={{ width: "100%", height: "100%" }} />
-      {meeting.recording_type &&
-        recordingTypeRequiresConsent(meeting.recording_type) &&
-        meeting.id && <ConsentDialogButton meetingId={meeting.id} />}
     </Box>
   );
 }

www/app/[roomName]/components/RoomContainer.tsx

@@ -18,6 +18,7 @@ import { useAuth } from "../../lib/AuthProvider";
 import { useError } from "../../(errors)/errorContext";
 import { parseNonEmptyString } from "../../lib/utils";
 import { printApiError } from "../../api/_error";
+import { assertMeetingId } from "../../lib/types";
 
 type Meeting = components["schemas"]["Meeting"];
 
@@ -67,7 +68,10 @@ export default function RoomContainer(details: RoomDetails) {
     room && !room.ics_enabled && !pageMeetingId ? roomName : null,
   );
 
-  const explicitMeeting = useRoomGetMeeting(roomName, pageMeetingId || null);
+  const explicitMeeting = useRoomGetMeeting(
+    roomName,
+    pageMeetingId ? assertMeetingId(pageMeetingId) : null,
+  );
 
   const meeting = explicitMeeting.data || defaultMeeting.response;
 
@@ -192,9 +196,9 @@ export default function RoomContainer(details: RoomDetails) {
 
   switch (platform) {
     case "daily":
-      return <DailyRoom meeting={meeting} />;
+      return <DailyRoom meeting={meeting} room={room} />;
     case "whereby":
-      return <WherebyRoom meeting={meeting} />;
+      return <WherebyRoom meeting={meeting} room={room} />;
     default: {
       const _exhaustive: never = platform;
       return (

www/app/[roomName]/components/WherebyRoom.tsx

@@ -5,24 +5,29 @@ import { useRouter } from "next/navigation";
 import type { components } from "../../reflector-api";
 import { useAuth } from "../../lib/AuthProvider";
 import { getWherebyUrl, useWhereby } from "../../lib/wherebyClient";
-import { assertExistsAndNonEmptyString, NonEmptyString } from "../../lib/utils";
 import {
   ConsentDialogButton as BaseConsentDialogButton,
   useConsentDialog,
-  recordingTypeRequiresConsent,
 } from "../../lib/consent";
+import { assertMeetingId, MeetingId } from "../../lib/types";
 
 type Meeting = components["schemas"]["Meeting"];
+type Room = components["schemas"]["RoomDetails"];
 
 interface WherebyRoomProps {
   meeting: Meeting;
+  room: Room;
 }
 
 function WherebyConsentDialogButton({
   meetingId,
+  recordingType,
+  skipConsent,
   wherebyRef,
 }: {
-  meetingId: NonEmptyString;
+  meetingId: MeetingId;
+  recordingType: Meeting["recording_type"];
+  skipConsent: boolean;
   wherebyRef: React.RefObject<HTMLElement>;
 }) {
   const previousFocusRef = useRef<HTMLElement | null>(null);
@@ -45,10 +50,16 @@ function WherebyConsentDialogButton({
     };
   }, [wherebyRef]);
 
-  return <BaseConsentDialogButton meetingId={meetingId} />;
+  return (
+    <BaseConsentDialogButton
+      meetingId={meetingId}
+      recordingType={recordingType}
+      skipConsent={skipConsent}
+    />
+  );
 }
 
-export default function WherebyRoom({ meeting }: WherebyRoomProps) {
+export default function WherebyRoom({ meeting, room }: WherebyRoomProps) {
   const wherebyLoaded = useWhereby();
   const wherebyRef = useRef<HTMLElement>(null);
   const router = useRouter();
@@ -57,9 +68,14 @@ export default function WherebyRoom({ meeting }: WherebyRoomProps) {
   const isAuthenticated = status === "authenticated";
 
   const wherebyRoomUrl = getWherebyUrl(meeting);
-  const recordingType = meeting.recording_type;
   const meetingId = meeting.id;
 
+  const { showConsentButton } = useConsentDialog({
+    meetingId: assertMeetingId(meetingId),
+    recordingType: meeting.recording_type,
+    skipConsent: room.skip_consent,
+  });
+
   const isLoading = status === "loading";
 
   const handleLeave = useCallback(() => {
@@ -88,14 +104,14 @@ export default function WherebyRoom({ meeting }: WherebyRoomProps) {
         room={wherebyRoomUrl}
         style={{ width: "100vw", height: "100vh" }}
       />
-      {recordingType &&
+      {showConsentButton && (
-        recordingTypeRequiresConsent(recordingType) &&
+        <WherebyConsentDialogButton
-        meetingId && (
+          meetingId={assertMeetingId(meetingId)}
-          <WherebyConsentDialogButton
+          recordingType={meeting.recording_type}
-            meetingId={assertExistsAndNonEmptyString(meetingId)}
+          skipConsent={room.skip_consent}
-            wherebyRef={wherebyRef}
+          wherebyRef={wherebyRef}
-          />
+        />
-        )}
+      )}
     </>
   );
 }

www/app/[roomName]/room.tsx

@@ -6,7 +6,6 @@ import {
   useEffect,
   useRef,
   useState,
-  useContext,
   RefObject,
   use,
 } from "react";
@@ -25,8 +24,6 @@ import { useRecordingConsent } from "../recordingConsentContext";
 import {
   useMeetingAudioConsent,
   useRoomGetByName,
-  useRoomActiveMeetings,
-  useRoomUpcomingMeetings,
   useRoomsCreateMeeting,
   useRoomGetMeeting,
 } from "../lib/apiHooks";
@@ -39,12 +36,9 @@ import { FaBars } from "react-icons/fa6";
 import { useAuth } from "../lib/AuthProvider";
 import { getWherebyUrl, useWhereby } from "../lib/wherebyClient";
 import { useError } from "../(errors)/errorContext";
-import {
+import { parseNonEmptyString } from "../lib/utils";
-  assertExistsAndNonEmptyString,
-  NonEmptyString,
-  parseNonEmptyString,
-} from "../lib/utils";
 import { printApiError } from "../api/_error";
+import { assertMeetingId, MeetingId } from "../lib/types";
 
 export type RoomDetails = {
   params: Promise<{
@@ -92,16 +86,16 @@ const useConsentWherebyFocusManagement = (
 };
 
 const useConsentDialog = (
-  meetingId: string,
+  meetingId: MeetingId,
   wherebyRef: RefObject<HTMLElement> /*accessibility*/,
 ) => {
-  const { state: consentState, touch, hasConsent } = useRecordingConsent();
+  const { state: consentState, touch, hasAnswered } = useRecordingConsent();
   // toast would open duplicates, even with using "id=" prop
   const [modalOpen, setModalOpen] = useState(false);
   const audioConsentMutation = useMeetingAudioConsent();
 
   const handleConsent = useCallback(
-    async (meetingId: string, given: boolean) => {
+    async (meetingId: MeetingId, given: boolean) => {
       try {
         await audioConsentMutation.mutateAsync({
           params: {
@@ -114,7 +108,7 @@ const useConsentDialog = (
           },
         });
 
-        touch(meetingId);
+        touch(meetingId, given);
       } catch (error) {
         console.error("Error submitting consent:", error);
       }
@@ -216,7 +210,7 @@ const useConsentDialog = (
   return {
     showConsentModal,
     consentState,
-    hasConsent,
+    hasAnswered,
     consentLoading: audioConsentMutation.isPending,
   };
 };
@@ -225,13 +219,13 @@ function ConsentDialogButton({
   meetingId,
   wherebyRef,
 }: {
-  meetingId: NonEmptyString;
+  meetingId: MeetingId;
   wherebyRef: React.RefObject<HTMLElement>;
 }) {
-  const { showConsentModal, consentState, hasConsent, consentLoading } =
+  const { showConsentModal, consentState, hasAnswered, consentLoading } =
     useConsentDialog(meetingId, wherebyRef);
 
-  if (!consentState.ready || hasConsent(meetingId) || consentLoading) {
+  if (!consentState.ready || hasAnswered(meetingId) || consentLoading) {
     return null;
   }
 
@@ -284,7 +278,10 @@ export default function Room(details: RoomDetails) {
     room && !room.ics_enabled && !pageMeetingId ? roomName : null,
   );
 
-  const explicitMeeting = useRoomGetMeeting(roomName, pageMeetingId || null);
+  const explicitMeeting = useRoomGetMeeting(
+    roomName,
+    pageMeetingId ? assertMeetingId(pageMeetingId) : null,
+  );
   const wherebyRoomUrl = explicitMeeting.data
     ? getWherebyUrl(explicitMeeting.data)
     : defaultMeeting.response
@@ -437,7 +434,7 @@ export default function Room(details: RoomDetails) {
             recordingTypeRequiresConsent(recordingType) &&
             meetingId && (
               <ConsentDialogButton
-                meetingId={assertExistsAndNonEmptyString(meetingId)}
+                meetingId={assertMeetingId(meetingId)}
                 wherebyRef={wherebyRef}
               />
             )}

www/app/lib/AuthProvider.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import { createContext, useContext } from "react";
+import { createContext, useContext, useRef } from "react";
 import { useSession as useNextAuthSession } from "next-auth/react";
 import { signOut, signIn } from "next-auth/react";
 import { configureApiAuth } from "./apiClient";
@@ -25,6 +25,9 @@ type AuthContextType = (
   update: () => Promise<Session | null>;
   signIn: typeof signIn;
   signOut: typeof signOut;
+  // TODO probably rename isLoading to isReloading and make THIS field "isLoading"
+  // undefined is "not known", null is "is certainly logged out"
+  lastUserId: CustomSession["user"]["id"] | null | undefined;
 };
 
 const AuthContext = createContext<AuthContextType | undefined>(undefined);
@@ -41,10 +44,15 @@ const noopAuthContext: AuthContextType = {
   signOut: async () => {
     throw new Error("signOut not supposed to be called");
   },
+  lastUserId: undefined,
 };
 
 export function AuthProvider({ children }: { children: React.ReactNode }) {
   const { data: session, status, update } = useNextAuthSession();
+  // referential comparison done in component, must be primitive /or cached
+  const lastUserId = useRef<CustomSession["user"]["id"] | null | undefined>(
+    null,
+  );
 
   const contextValue: AuthContextType = isAuthEnabled
     ? {
@@ -73,11 +81,16 @@ export function AuthProvider({ children }: { children: React.ReactNode }) {
             case "authenticated": {
               const customSession = assertCustomSession(session);
               if (customSession?.error === REFRESH_ACCESS_TOKEN_ERROR) {
+                // warning: call order-dependent
+                lastUserId.current = null;
                 // token had expired but next auth still returns "authenticated" so show user unauthenticated state
                 return {
                   status: "unauthenticated" as const,
                 };
               } else if (customSession?.accessToken) {
+                // updates anyways with updated properties below
+                // warning! execution order conscience, must be ran before reading lastUserId.current below
+                lastUserId.current = customSession.user.id;
                 return {
                   status,
                   accessToken: customSession.accessToken,
@@ -92,6 +105,8 @@ export function AuthProvider({ children }: { children: React.ReactNode }) {
               }
             }
             case "unauthenticated": {
+              // warning: call order-dependent
+              lastUserId.current = null;
               return { status: "unauthenticated" as const };
             }
             default: {
@@ -103,6 +118,8 @@ export function AuthProvider({ children }: { children: React.ReactNode }) {
         update,
         signIn,
         signOut,
+        // for optimistic cases when we assume "loading" doesn't immediately invalidate the user
+        lastUserId: lastUserId.current,
       }
     : noopAuthContext;
 

www/app/lib/apiHooks.ts

@@ -5,6 +5,7 @@ import { useError } from "../(errors)/errorContext";
 import { QueryClient, useQueryClient } from "@tanstack/react-query";
 import type { components } from "../reflector-api";
 import { useAuth } from "./AuthProvider";
+import { MeetingId } from "./types";
 
 /*
  * XXX error types returned from the hooks are not always correct; declared types are ValidationError but real type could be string or any other
@@ -718,7 +719,7 @@ export function useRoomActiveMeetings(roomName: string | null) {
 
 export function useRoomGetMeeting(
   roomName: string | null,
-  meetingId: string | null,
+  meetingId: MeetingId | null,
 ) {
   return $api.useQuery(
     "get",

www/app/lib/authBackend.ts

@@ -32,6 +32,11 @@ async function getUserId(accessToken: string): Promise<string | null> {
     });
 
     if (!response.ok) {
+      try {
+        console.error(await response.text());
+      } catch (e) {
+        console.error("Failed to parse error response", e);
+      }
       return null;
     }
 
@@ -143,7 +148,7 @@ export const authOptions = (): AuthOptions =>
           },
           async session({ session, token }) {
             const extendedToken = token as JWTWithAccessToken;
-
+            console.log("extendedToken", extendedToken);
             const userId = await getUserId(extendedToken.accessToken);
 
             return {

www/app/lib/consent/ConsentDialog.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import { useState, useEffect } from "react";
 import { Box, Button, Text, VStack, HStack } from "@chakra-ui/react";
 import { CONSENT_DIALOG_TEXT } from "./constants";
 
@@ -9,6 +10,15 @@ interface ConsentDialogProps {
 }
 
 export function ConsentDialog({ onAccept, onReject }: ConsentDialogProps) {
+  const [acceptButton, setAcceptButton] = useState<HTMLButtonElement | null>(
+    null,
+  );
+
+  useEffect(() => {
+    // Auto-focus accept button so Escape key works (Daily iframe captures keyboard otherwise)
+    acceptButton?.focus();
+  }, [acceptButton]);
+
   return (
     <Box
       p={6}
@@ -26,7 +36,12 @@ export function ConsentDialog({ onAccept, onReject }: ConsentDialogProps) {
           <Button variant="ghost" size="sm" onClick={onReject}>
             {CONSENT_DIALOG_TEXT.rejectButton}
           </Button>
-          <Button colorPalette="primary" size="sm" onClick={onAccept}>
+          <Button
+            ref={setAcceptButton}
+            colorPalette="primary"
+            size="sm"
+            onClick={onAccept}
+          >
             {CONSENT_DIALOG_TEXT.acceptButton}
           </Button>
         </HStack>

www/app/lib/consent/ConsentDialogButton.tsx

@@ -9,16 +9,26 @@ import {
   CONSENT_BUTTON_Z_INDEX,
   CONSENT_DIALOG_TEXT,
 } from "./constants";
+import { MeetingId } from "../types";
+import type { components } from "../../reflector-api";
 
-interface ConsentDialogButtonProps {
+type Meeting = components["schemas"]["Meeting"];
-  meetingId: string;
-}
 
-export function ConsentDialogButton({ meetingId }: ConsentDialogButtonProps) {
+type ConsentDialogButtonProps = {
-  const { showConsentModal, consentState, hasConsent, consentLoading } =
+  meetingId: MeetingId;
-    useConsentDialog(meetingId);
+  recordingType: Meeting["recording_type"];
+  skipConsent: boolean;
+};
 
-  if (!consentState.ready || hasConsent(meetingId) || consentLoading) {
+export function ConsentDialogButton({
+  meetingId,
+  recordingType,
+  skipConsent,
+}: ConsentDialogButtonProps) {
+  const { showConsentModal, consentState, showConsentButton, consentLoading } =
+    useConsentDialog({ meetingId, recordingType, skipConsent });
+
+  if (!consentState.ready || !showConsentButton || consentLoading) {
     return null;
   }
 

www/app/lib/consent/RecordingIndicator.tsx

@@ -0,0 +1,33 @@
+"use client";
+
+import { Box, Text } from "@chakra-ui/react";
+import { FaCircle } from "react-icons/fa6";
+import {
+  CONSENT_BUTTON_TOP_OFFSET,
+  CONSENT_BUTTON_LEFT_OFFSET,
+  CONSENT_BUTTON_Z_INDEX,
+} from "./constants";
+
+export function RecordingIndicator() {
+  return (
+    <Box
+      position="absolute"
+      top={CONSENT_BUTTON_TOP_OFFSET}
+      left={CONSENT_BUTTON_LEFT_OFFSET}
+      zIndex={CONSENT_BUTTON_Z_INDEX}
+      display="flex"
+      alignItems="center"
+      gap={2}
+      bg="red.500"
+      color="white"
+      px={3}
+      py={1.5}
+      borderRadius="md"
+      fontSize="sm"
+      fontWeight="medium"
+    >
+      <FaCircle size={8} />
+      <Text>Recording</Text>
+    </Box>
+  );
+}

www/app/lib/consent/index.ts

@@ -2,6 +2,7 @@
 
 export { ConsentDialogButton } from "./ConsentDialogButton";
 export { ConsentDialog } from "./ConsentDialog";
+export { RecordingIndicator } from "./RecordingIndicator";
 export { useConsentDialog } from "./useConsentDialog";
 export { recordingTypeRequiresConsent } from "./utils";
 export * from "./constants";

www/app/lib/consent/types.ts

@@ -1,9 +1,14 @@
-export interface ConsentDialogResult {
+import { MeetingId } from "../types";
+
+export type ConsentDialogResult = {
   showConsentModal: () => void;
   consentState: {
     ready: boolean;
-    consentAnsweredForMeetings?: Set<string>;
+    consentForMeetings?: Map<MeetingId, boolean>;
   };
-  hasConsent: (meetingId: string) => boolean;
+  hasAnswered: (meetingId: MeetingId) => boolean;
+  hasAccepted: (meetingId: MeetingId) => boolean;
   consentLoading: boolean;
-}
+  showRecordingIndicator: boolean;
+  showConsentButton: boolean;
+};

www/app/lib/consent/useConsentDialog.tsx

@@ -7,9 +7,29 @@ import { useMeetingAudioConsent } from "../apiHooks";
 import { ConsentDialog } from "./ConsentDialog";
 import { TOAST_CHECK_INTERVAL_MS } from "./constants";
 import type { ConsentDialogResult } from "./types";
+import { MeetingId } from "../types";
+import { recordingTypeRequiresConsent } from "./utils";
+import type { components } from "../../reflector-api";
 
-export function useConsentDialog(meetingId: string): ConsentDialogResult {
+type Meeting = components["schemas"]["Meeting"];
-  const { state: consentState, touch, hasConsent } = useRecordingConsent();
+
+type UseConsentDialogParams = {
+  meetingId: MeetingId;
+  recordingType: Meeting["recording_type"];
+  skipConsent: boolean;
+};
+
+export function useConsentDialog({
+  meetingId,
+  recordingType,
+  skipConsent,
+}: UseConsentDialogParams): ConsentDialogResult {
+  const {
+    state: consentState,
+    touch,
+    hasAnswered,
+    hasAccepted,
+  } = useRecordingConsent();
   const [modalOpen, setModalOpen] = useState(false);
   const audioConsentMutation = useMeetingAudioConsent();
   const intervalRef = useRef<NodeJS.Timeout | null>(null);
@@ -42,7 +62,7 @@ export function useConsentDialog(meetingId: string): ConsentDialogResult {
           },
         });
 
-        touch(meetingId);
+        touch(meetingId, given);
       } catch (error) {
         console.error("Error submitting consent:", error);
       }
@@ -100,10 +120,23 @@ export function useConsentDialog(meetingId: string): ConsentDialogResult {
     });
   }, [handleConsent, modalOpen]);
 
+  const requiresConsent = Boolean(
+    recordingType && recordingTypeRequiresConsent(recordingType),
+  );
+
+  const showRecordingIndicator =
+    requiresConsent && (skipConsent || hasAccepted(meetingId));
+
+  const showConsentButton =
+    requiresConsent && !skipConsent && !hasAnswered(meetingId);
+
   return {
     showConsentModal,
     consentState,
-    hasConsent,
+    hasAnswered,
+    hasAccepted,
     consentLoading: audioConsentMutation.isPending,
+    showRecordingIndicator,
+    showConsentButton,
   };
 }

www/app/lib/types.ts

@@ -1,6 +1,10 @@
 import type { Session } from "next-auth";
 import type { JWT } from "next-auth/jwt";
-import { parseMaybeNonEmptyString } from "./utils";
+import {
+  assertExistsAndNonEmptyString,
+  NonEmptyString,
+  parseMaybeNonEmptyString,
+} from "./utils";
 
 export interface JWTWithAccessToken extends JWT {
   accessToken: string;
@@ -78,3 +82,10 @@ export const assertCustomSession = <T extends Session>(
 export type Mutable<T> = {
   -readonly [P in keyof T]: T[P];
 };
+
+export type MeetingId = NonEmptyString & { __type: "MeetingId" };
+export const assertMeetingId = (s: string): MeetingId => {
+  const nes = assertExistsAndNonEmptyString(s);
+  // just cast for now
+  return nes as MeetingId;
+};

www/app/recordingConsentContext.tsx

@@ -1,18 +1,22 @@
 "use client";
 
 import React, { createContext, useContext, useEffect, useState } from "react";
+import { MeetingId } from "./lib/types";
+
+type ConsentMap = Map<MeetingId, boolean>;
 
 type ConsentContextState =
   | { ready: false }
   | {
       ready: true;
-      consentAnsweredForMeetings: Set<string>;
+      consentForMeetings: ConsentMap;
     };
 
 interface RecordingConsentContextValue {
   state: ConsentContextState;
-  touch: (meetingId: string) => void;
+  touch: (meetingId: MeetingId, accepted: boolean) => void;
-  hasConsent: (meetingId: string) => boolean;
+  hasAnswered: (meetingId: MeetingId) => boolean;
+  hasAccepted: (meetingId: MeetingId) => boolean;
 }
 
 const RecordingConsentContext = createContext<
@@ -35,81 +39,116 @@ interface RecordingConsentProviderProps {
 
 const LOCAL_STORAGE_KEY = "recording_consent_meetings";
 
+const ACCEPTED = "T" as const;
+type Accepted = typeof ACCEPTED;
+const REJECTED = "F" as const;
+type Rejected = typeof REJECTED;
+type Consent = Accepted | Rejected;
+const SEPARATOR = "|" as const;
+type Separator = typeof SEPARATOR;
+const DEFAULT_CONSENT = ACCEPTED;
+type Entry = `${MeetingId}${Separator}${Consent}`;
+type EntryAndDefault = Entry | MeetingId;
+
+// Format: "meetingId|T" or "meetingId|F", legacy format "meetingId" is treated as accepted
+const encodeEntry = (meetingId: MeetingId, accepted: boolean): Entry =>
+  `${meetingId}|${accepted ? ACCEPTED : REJECTED}`;
+
+const decodeEntry = (
+  entry: EntryAndDefault,
+): { meetingId: MeetingId; accepted: boolean } | null => {
+  const pipeIndex = entry.lastIndexOf(SEPARATOR);
+  if (pipeIndex === -1) {
+    // Legacy format: no pipe means accepted (backward compat)
+    return { meetingId: entry as MeetingId, accepted: true };
+  }
+  const suffix = entry.slice(pipeIndex + 1);
+  const meetingId = entry.slice(0, pipeIndex) as MeetingId;
+  // T = accepted, F = rejected, anything else = accepted (safe default)
+  const accepted = suffix !== REJECTED;
+  return { meetingId, accepted };
+};
+
 export const RecordingConsentProvider: React.FC<
   RecordingConsentProviderProps
 > = ({ children }) => {
   const [state, setState] = useState<ConsentContextState>({ ready: false });
 
-  const safeWriteToStorage = (meetingIds: string[]): void => {
+  const safeWriteToStorage = (consentMap: ConsentMap): void => {
     try {
       if (typeof window !== "undefined" && window.localStorage) {
-        localStorage.setItem(LOCAL_STORAGE_KEY, JSON.stringify(meetingIds));
+        const entries = Array.from(consentMap.entries())
+          .slice(-5)
+          .map(([id, accepted]) => encodeEntry(id, accepted));
+        localStorage.setItem(LOCAL_STORAGE_KEY, JSON.stringify(entries));
       }
     } catch (error) {
       console.error("Failed to save consent data to localStorage:", error);
     }
   };
 
-  // writes to local storage and to the state of context both
+  const touch = (meetingId: MeetingId, accepted: boolean): void => {
-  const touch = (meetingId: string): void => {
     if (!state.ready) {
       console.warn("Attempted to touch consent before context is ready");
       return;
     }
 
-    // has success regardless local storage write success: we don't handle that
+    const newMap = new Map(state.consentForMeetings);
-    // and don't want to crash anything with just consent functionality
+    newMap.set(meetingId, accepted);
-    const newSet = state.consentAnsweredForMeetings.has(meetingId)
+    safeWriteToStorage(newMap);
-      ? state.consentAnsweredForMeetings
+    setState({ ready: true, consentForMeetings: newMap });
-      : new Set([...state.consentAnsweredForMeetings, meetingId]);
-    // note: preserves the set insertion order
-    const array = Array.from(newSet).slice(-5); // Keep latest 5
-    safeWriteToStorage(array);
-    setState({ ready: true, consentAnsweredForMeetings: newSet });
   };
 
-  const hasConsent = (meetingId: string): boolean => {
+  const hasAnswered = (meetingId: MeetingId): boolean => {
     if (!state.ready) return false;
-    return state.consentAnsweredForMeetings.has(meetingId);
+    return state.consentForMeetings.has(meetingId);
+  };
+
+  const hasAccepted = (meetingId: MeetingId): boolean => {
+    if (!state.ready) return false;
+    return state.consentForMeetings.get(meetingId) === true;
   };
 
   // initialize on mount
   useEffect(() => {
     try {
       if (typeof window === "undefined" || !window.localStorage) {
-        setState({ ready: true, consentAnsweredForMeetings: new Set() });
+        setState({ ready: true, consentForMeetings: new Map() });
         return;
       }
 
       const stored = localStorage.getItem(LOCAL_STORAGE_KEY);
       if (!stored) {
-        setState({ ready: true, consentAnsweredForMeetings: new Set() });
+        setState({ ready: true, consentForMeetings: new Map() });
         return;
       }
 
       const parsed = JSON.parse(stored);
       if (!Array.isArray(parsed)) {
         console.warn("Invalid consent data format in localStorage, resetting");
-        setState({ ready: true, consentAnsweredForMeetings: new Set() });
+        setState({ ready: true, consentForMeetings: new Map() });
         return;
       }
 
-      // pre-historic way of parsing!
+      const consentForMeetings = new Map<MeetingId, boolean>();
-      const consentAnsweredForMeetings = new Set(
+      for (const entry of parsed) {
-        parsed.filter((id) => !!id && typeof id === "string"),
+        const decoded = decodeEntry(entry);
-      );
+        if (decoded) {
-      setState({ ready: true, consentAnsweredForMeetings });
+          consentForMeetings.set(decoded.meetingId, decoded.accepted);
+        }
+      }
+      setState({ ready: true, consentForMeetings });
     } catch (error) {
-      // we don't want to fail the page here; the component is not essential.
       console.error("Failed to parse consent data from localStorage:", error);
-      setState({ ready: true, consentAnsweredForMeetings: new Set() });
+      setState({ ready: true, consentForMeetings: new Map() });
     }
   }, []);
 
   const value: RecordingConsentContextValue = {
     state,
     touch,
-    hasConsent,
+    hasAnswered,
+    hasAccepted,
   };
 
   return (

www/app/reflector-api.d.ts

@@ -696,7 +696,7 @@ export interface paths {
     patch?: never;
     trace?: never;
   };
-  "/v1/webhook": {
+  "/v1/daily/webhook": {
     parameters: {
       query?: never;
       header?: never;
@@ -708,6 +708,27 @@ export interface paths {
     /**
      * Webhook
      * @description Handle Daily webhook events.
+     *
+     *     Example webhook payload:
+     *     {
+     *       "version": "1.0.0",
+     *       "type": "recording.ready-to-download",
+     *       "id": "rec-rtd-c3df927c-f738-4471-a2b7-066fa7e95a6b-1692124192",
+     *       "payload": {
+     *         "recording_id": "08fa0b24-9220-44c5-846c-3f116cf8e738",
+     *         "room_name": "Xcm97xRZ08b2dePKb78g",
+     *         "start_ts": 1692124183,
+     *         "status": "finished",
+     *         "max_participants": 1,
+     *         "duration": 9,
+     *         "share_token": "ntDCL5k98Ulq", #gitleaks:allow
+     *         "s3_key": "api-test-1j8fizhzd30c/Xcm97xRZ08b2dePKb78g/1692124183028"
+     *       },
+     *       "event_ts": 1692124192
+     *     }
+     *
+     *     Daily.co circuit-breaker: After 3+ failed responses (4xx/5xx), webhook
+     *     state→FAILED, stops sending events. Reset: scripts/recreate_daily_webhook.py
      */
     post: operations["v1_webhook"];
     delete?: never;
@@ -872,8 +893,16 @@ export interface components {
        * @default false
        */
       ics_enabled: boolean;
-      /** Platform */
+      /**
-      platform?: ("whereby" | "daily") | null;
+       * Platform
+       * @enum {string}
+       */
+      platform: "whereby" | "daily";
+      /**
+       * Skip Consent
+       * @default false
+       */
+      skip_consent: boolean;
     };
     /** CreateRoomMeeting */
     CreateRoomMeeting: {
@@ -899,81 +928,11 @@ export interface components {
       target_language: string;
       source_kind?: components["schemas"]["SourceKind"] | null;
     };
-    /**
-     * DailyWebhookEvent
-     * @description Daily webhook event structure.
-     */
-    DailyWebhookEvent: {
-      /** Type */
-      type: string;
-      /** Id */
-      id: string;
-      /** Ts */
-      ts: number;
-      /** Data */
-      data: {
-        [key: string]: unknown;
-      };
-    };
     /** DeletionStatus */
     DeletionStatus: {
       /** Status */
       status: string;
     };
-    /** GetTranscript */
-    GetTranscript: {
-      /** Id */
-      id: string;
-      /** User Id */
-      user_id: string | null;
-      /** Name */
-      name: string;
-      /**
-       * Status
-       * @enum {string}
-       */
-      status:
-        | "idle"
-        | "uploaded"
-        | "recording"
-        | "processing"
-        | "error"
-        | "ended";
-      /** Locked */
-      locked: boolean;
-      /** Duration */
-      duration: number;
-      /** Title */
-      title: string | null;
-      /** Short Summary */
-      short_summary: string | null;
-      /** Long Summary */
-      long_summary: string | null;
-      /** Created At */
-      created_at: string;
-      /**
-       * Share Mode
-       * @default private
-       */
-      share_mode: string;
-      /** Source Language */
-      source_language: string | null;
-      /** Target Language */
-      target_language: string | null;
-      /** Reviewed */
-      reviewed: boolean;
-      /** Meeting Id */
-      meeting_id: string | null;
-      source_kind: components["schemas"]["SourceKind"];
-      /** Room Id */
-      room_id?: string | null;
-      /** Room Name */
-      room_name?: string | null;
-      /** Audio Deleted */
-      audio_deleted?: boolean | null;
-      /** Participants */
-      participants: components["schemas"]["TranscriptParticipant"][] | null;
-    };
     /** GetTranscriptMinimal */
     GetTranscriptMinimal: {
       /** Id */
@@ -1105,6 +1064,355 @@ export interface components {
        */
       words_per_speaker: components["schemas"]["SpeakerWords"][];
     };
+    /**
+     * GetTranscriptWithJSON
+     * @description Transcript response as structured JSON segments.
+     *
+     *     Format: Array of segment objects with speaker info, text, and timing.
+     *     Example:
+     *         [
+     *             {
+     *                 "speaker": 0,
+     *                 "speaker_name": "John Smith",
+     *                 "text": "Hello everyone",
+     *                 "start": 0.0,
+     *                 "end": 5.0
+     *             }
+     *         ]
+     */
+    GetTranscriptWithJSON: {
+      /** Id */
+      id: string;
+      /** User Id */
+      user_id: string | null;
+      /** Name */
+      name: string;
+      /**
+       * Status
+       * @enum {string}
+       */
+      status:
+        | "idle"
+        | "uploaded"
+        | "recording"
+        | "processing"
+        | "error"
+        | "ended";
+      /** Locked */
+      locked: boolean;
+      /** Duration */
+      duration: number;
+      /** Title */
+      title: string | null;
+      /** Short Summary */
+      short_summary: string | null;
+      /** Long Summary */
+      long_summary: string | null;
+      /** Created At */
+      created_at: string;
+      /**
+       * Share Mode
+       * @default private
+       */
+      share_mode: string;
+      /** Source Language */
+      source_language: string | null;
+      /** Target Language */
+      target_language: string | null;
+      /** Reviewed */
+      reviewed: boolean;
+      /** Meeting Id */
+      meeting_id: string | null;
+      source_kind: components["schemas"]["SourceKind"];
+      /** Room Id */
+      room_id?: string | null;
+      /** Room Name */
+      room_name?: string | null;
+      /** Audio Deleted */
+      audio_deleted?: boolean | null;
+      /** Participants */
+      participants:
+        | components["schemas"]["TranscriptParticipantWithEmail"][]
+        | null;
+      /**
+       * @description discriminator enum property added by openapi-typescript
+       * @enum {string}
+       */
+      transcript_format: "json";
+      /** Transcript */
+      transcript: components["schemas"]["TranscriptSegment"][];
+    };
+    /** GetTranscriptWithParticipants */
+    GetTranscriptWithParticipants: {
+      /** Id */
+      id: string;
+      /** User Id */
+      user_id: string | null;
+      /** Name */
+      name: string;
+      /**
+       * Status
+       * @enum {string}
+       */
+      status:
+        | "idle"
+        | "uploaded"
+        | "recording"
+        | "processing"
+        | "error"
+        | "ended";
+      /** Locked */
+      locked: boolean;
+      /** Duration */
+      duration: number;
+      /** Title */
+      title: string | null;
+      /** Short Summary */
+      short_summary: string | null;
+      /** Long Summary */
+      long_summary: string | null;
+      /** Created At */
+      created_at: string;
+      /**
+       * Share Mode
+       * @default private
+       */
+      share_mode: string;
+      /** Source Language */
+      source_language: string | null;
+      /** Target Language */
+      target_language: string | null;
+      /** Reviewed */
+      reviewed: boolean;
+      /** Meeting Id */
+      meeting_id: string | null;
+      source_kind: components["schemas"]["SourceKind"];
+      /** Room Id */
+      room_id?: string | null;
+      /** Room Name */
+      room_name?: string | null;
+      /** Audio Deleted */
+      audio_deleted?: boolean | null;
+      /** Participants */
+      participants:
+        | components["schemas"]["TranscriptParticipantWithEmail"][]
+        | null;
+    };
+    /**
+     * GetTranscriptWithText
+     * @description Transcript response with plain text format.
+     *
+     *     Format: Speaker names followed by their dialogue, one line per segment.
+     *     Example:
+     *         John Smith: Hello everyone
+     *         Jane Doe: Hi there
+     */
+    GetTranscriptWithText: {
+      /** Id */
+      id: string;
+      /** User Id */
+      user_id: string | null;
+      /** Name */
+      name: string;
+      /**
+       * Status
+       * @enum {string}
+       */
+      status:
+        | "idle"
+        | "uploaded"
+        | "recording"
+        | "processing"
+        | "error"
+        | "ended";
+      /** Locked */
+      locked: boolean;
+      /** Duration */
+      duration: number;
+      /** Title */
+      title: string | null;
+      /** Short Summary */
+      short_summary: string | null;
+      /** Long Summary */
+      long_summary: string | null;
+      /** Created At */
+      created_at: string;
+      /**
+       * Share Mode
+       * @default private
+       */
+      share_mode: string;
+      /** Source Language */
+      source_language: string | null;
+      /** Target Language */
+      target_language: string | null;
+      /** Reviewed */
+      reviewed: boolean;
+      /** Meeting Id */
+      meeting_id: string | null;
+      source_kind: components["schemas"]["SourceKind"];
+      /** Room Id */
+      room_id?: string | null;
+      /** Room Name */
+      room_name?: string | null;
+      /** Audio Deleted */
+      audio_deleted?: boolean | null;
+      /** Participants */
+      participants:
+        | components["schemas"]["TranscriptParticipantWithEmail"][]
+        | null;
+      /**
+       * @description discriminator enum property added by openapi-typescript
+       * @enum {string}
+       */
+      transcript_format: "text";
+      /** Transcript */
+      transcript: string;
+    };
+    /**
+     * GetTranscriptWithTextTimestamped
+     * @description Transcript response with timestamped text format.
+     *
+     *     Format: [MM:SS] timestamp prefix before each speaker and dialogue.
+     *     Example:
+     *         [00:00] John Smith: Hello everyone
+     *         [00:05] Jane Doe: Hi there
+     */
+    GetTranscriptWithTextTimestamped: {
+      /** Id */
+      id: string;
+      /** User Id */
+      user_id: string | null;
+      /** Name */
+      name: string;
+      /**
+       * Status
+       * @enum {string}
+       */
+      status:
+        | "idle"
+        | "uploaded"
+        | "recording"
+        | "processing"
+        | "error"
+        | "ended";
+      /** Locked */
+      locked: boolean;
+      /** Duration */
+      duration: number;
+      /** Title */
+      title: string | null;
+      /** Short Summary */
+      short_summary: string | null;
+      /** Long Summary */
+      long_summary: string | null;
+      /** Created At */
+      created_at: string;
+      /**
+       * Share Mode
+       * @default private
+       */
+      share_mode: string;
+      /** Source Language */
+      source_language: string | null;
+      /** Target Language */
+      target_language: string | null;
+      /** Reviewed */
+      reviewed: boolean;
+      /** Meeting Id */
+      meeting_id: string | null;
+      source_kind: components["schemas"]["SourceKind"];
+      /** Room Id */
+      room_id?: string | null;
+      /** Room Name */
+      room_name?: string | null;
+      /** Audio Deleted */
+      audio_deleted?: boolean | null;
+      /** Participants */
+      participants:
+        | components["schemas"]["TranscriptParticipantWithEmail"][]
+        | null;
+      /**
+       * @description discriminator enum property added by openapi-typescript
+       * @enum {string}
+       */
+      transcript_format: "text-timestamped";
+      /** Transcript */
+      transcript: string;
+    };
+    /**
+     * GetTranscriptWithWebVTTNamed
+     * @description Transcript response in WebVTT subtitle format with participant names.
+     *
+     *     Format: Standard WebVTT with voice tags using participant names.
+     *     Example:
+     *         WEBVTT
+     *
+     *         00:00:00.000 --> 00:00:05.000
+     *         <v John Smith>Hello everyone
+     */
+    GetTranscriptWithWebVTTNamed: {
+      /** Id */
+      id: string;
+      /** User Id */
+      user_id: string | null;
+      /** Name */
+      name: string;
+      /**
+       * Status
+       * @enum {string}
+       */
+      status:
+        | "idle"
+        | "uploaded"
+        | "recording"
+        | "processing"
+        | "error"
+        | "ended";
+      /** Locked */
+      locked: boolean;
+      /** Duration */
+      duration: number;
+      /** Title */
+      title: string | null;
+      /** Short Summary */
+      short_summary: string | null;
+      /** Long Summary */
+      long_summary: string | null;
+      /** Created At */
+      created_at: string;
+      /**
+       * Share Mode
+       * @default private
+       */
+      share_mode: string;
+      /** Source Language */
+      source_language: string | null;
+      /** Target Language */
+      target_language: string | null;
+      /** Reviewed */
+      reviewed: boolean;
+      /** Meeting Id */
+      meeting_id: string | null;
+      source_kind: components["schemas"]["SourceKind"];
+      /** Room Id */
+      room_id?: string | null;
+      /** Room Name */
+      room_name?: string | null;
+      /** Audio Deleted */
+      audio_deleted?: boolean | null;
+      /** Participants */
+      participants:
+        | components["schemas"]["TranscriptParticipantWithEmail"][]
+        | null;
+      /**
+       * @description discriminator enum property added by openapi-typescript
+       * @enum {string}
+       */
+      transcript_format: "webvtt-named";
+      /** Transcript */
+      transcript: string;
+    };
     /** HTTPValidationError */
     HTTPValidationError: {
       /** Detail */
@@ -1233,7 +1541,6 @@ export interface components {
       } | null;
       /**
        * Platform
-       * @default whereby
        * @enum {string}
        */
       platform: "whereby" | "daily";
@@ -1278,6 +1585,11 @@ export interface components {
       /** Name */
       name: string;
     };
+    /** ProcessStatus */
+    ProcessStatus: {
+      /** Status */
+      status: string;
+    };
     /** Room */
     Room: {
       /** Id */
@@ -1325,10 +1637,14 @@ export interface components {
       ics_last_etag?: string | null;
       /**
        * Platform
-       * @default whereby
        * @enum {string}
        */
       platform: "whereby" | "daily";
+      /**
+       * Skip Consent
+       * @default false
+       */
+      skip_consent: boolean;
     };
     /** RoomDetails */
     RoomDetails: {
@@ -1377,10 +1693,14 @@ export interface components {
       ics_last_etag?: string | null;
       /**
        * Platform
-       * @default whereby
        * @enum {string}
        */
       platform: "whereby" | "daily";
+      /**
+       * Skip Consent
+       * @default false
+       */
+      skip_consent: boolean;
       /** Webhook Url */
       webhook_url: string | null;
       /** Webhook Secret */
@@ -1523,6 +1843,37 @@ export interface components {
       speaker: number | null;
       /** Name */
       name: string;
+      /** User Id */
+      user_id?: string | null;
+    };
+    /** TranscriptParticipantWithEmail */
+    TranscriptParticipantWithEmail: {
+      /** Id */
+      id?: string;
+      /** Speaker */
+      speaker: number | null;
+      /** Name */
+      name: string;
+      /** User Id */
+      user_id?: string | null;
+      /** Email */
+      email?: string | null;
+    };
+    /**
+     * TranscriptSegment
+     * @description A single transcript segment with speaker and timing information.
+     */
+    TranscriptSegment: {
+      /** Speaker */
+      speaker: number;
+      /** Speaker Name */
+      speaker_name: string;
+      /** Text */
+      text: string;
+      /** Start */
+      start: number;
+      /** End */
+      end: number;
     };
     /** UpdateParticipant */
     UpdateParticipant: {
@@ -1563,6 +1914,8 @@ export interface components {
       ics_enabled?: boolean | null;
       /** Platform */
       platform?: ("whereby" | "daily") | null;
+      /** Skip Consent */
+      skip_consent?: boolean | null;
     };
     /** UpdateTranscript */
     UpdateTranscript: {
@@ -2311,7 +2664,7 @@ export interface operations {
           [name: string]: unknown;
         };
         content: {
-          "application/json": components["schemas"]["GetTranscript"];
+          "application/json": components["schemas"]["GetTranscriptWithParticipants"];
         };
       };
       /** @description Validation Error */
@@ -2369,7 +2722,13 @@ export interface operations {
   };
   v1_transcript_get: {
     parameters: {
-      query?: never;
+      query?: {
+        transcript_format?:
+          | "text"
+          | "text-timestamped"
+          | "webvtt-named"
+          | "json";
+      };
       header?: never;
       path: {
         transcript_id: string;
@@ -2384,7 +2743,11 @@ export interface operations {
           [name: string]: unknown;
         };
         content: {
-          "application/json": components["schemas"]["GetTranscript"];
+          "application/json":
+            | components["schemas"]["GetTranscriptWithText"]
+            | components["schemas"]["GetTranscriptWithTextTimestamped"]
+            | components["schemas"]["GetTranscriptWithWebVTTNamed"]
+            | components["schemas"]["GetTranscriptWithJSON"];
         };
       };
       /** @description Validation Error */
@@ -2450,7 +2813,7 @@ export interface operations {
           [name: string]: unknown;
         };
         content: {
-          "application/json": components["schemas"]["GetTranscript"];
+          "application/json": components["schemas"]["GetTranscriptWithParticipants"];
         };
       };
       /** @description Validation Error */
@@ -3047,7 +3410,7 @@ export interface operations {
           [name: string]: unknown;
         };
         content: {
-          "application/json": unknown;
+          "application/json": components["schemas"]["ProcessStatus"];
         };
       };
       /** @description Validation Error */
@@ -3256,11 +3619,7 @@ export interface operations {
       path?: never;
       cookie?: never;
     };
-    requestBody: {
+    requestBody?: never;
-      content: {
-        "application/json": components["schemas"]["DailyWebhookEvent"];
-      };
-    };
     responses: {
       /** @description Successful Response */
       200: {
@@ -3271,15 +3630,6 @@ export interface operations {
           "application/json": unknown;
         };
       };
-      /** @description Validation Error */
-      422: {
-        headers: {
-          [name: string]: unknown;
-        };
-        content: {
-          "application/json": components["schemas"]["HTTPValidationError"];
-        };
-      };
     };
   };
 }

www/package.json

@@ -31,7 +31,7 @@
     "ioredis": "^5.7.0",
     "jest-worker": "^29.6.2",
     "lucide-react": "^0.525.0",
-    "next": "^15.5.3",
+    "next": "^15.5.9",
     "next-auth": "^4.24.7",
     "next-themes": "^0.4.6",
     "nuqs": "^2.4.3",

www/public/recording-icon.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="#ef4444" stroke="none">
+  <circle cx="12" cy="12" r="8"/>
+</svg>